Merge pull request #1 from JupiterPi/kimai-integration

Kimai integration

Author: JupiterPi

README.md

@@ -1,6 +1,6 @@
 # 🌿 Thyme
 
-_**Thyme** is a stopwatch in your taskbar with history._
+_**Thyme** is a stopwatch in your taskbar with history, notes and a [Kimai](https://www.kimai.org) integration._
 
 ## Installation
 
@@ -15,11 +15,12 @@ _**Thyme** is a stopwatch in your taskbar with history._
 - The **tray icon** is an activity indicator that lights up green/gray to indicate that the stopwatch is/isn't running. Click it to toggle the stopwatch. Double-click to show/hide the UI window(s).
 - Every time you stop the stopwatch, an **entry is saved to the history** including the start and end time. 
 - Save small **notes** at any time to document what you're doing.
-- The small **dashboard** shows you whether a stopwatch is running, as well as the start time and duration. 
+- The small **dashboard** shows you information about a running stopwatch. 
 - The **history** page displays all entries in chronological order and grouped by day.
 - **Advanced editing:** Edit entries' start and end times, delete them, merge two entries, insert entries, insert pauses...
 - The **timeline** page displays one day's entries like a calendar.
 - Export your data in CSV format.
+- **[Kimai](https://www.kimai.org) integration:** Simply bring your domain and API key. Choose a project and activity from Kimai for new entries. All future entries will be synced to Kimai, including notes.
 
 Thyme is in development, and more features are on the way. 
 

electron/ipcChannels.ts

@@ -1,17 +1,16 @@
 export const ipcPushChannels = [
-    "toggleActive",
-    "reduceTimeEntries",
-    "reduceNotes",
-    "deleteAllTimeEntriesAndNotes",
-    "loadMockData",
+    "dispatch",
     "openJSON",
     "exportCSV",
     "setTimelineDay",
     "openPage",
-    "closePage"
+    "closePage",
 ] as const
 
 export const ipcPullChannels = [
+    "errors",
     "state",
-    "timelineDay"
+    "timelineDay",
+    "kimaiUsername",
+    "kimaiProjectsAndActivities",
 ] as const

electron/kimai/kimaiApi.ts

@@ -0,0 +1,95 @@
+import dateFormat from "dateformat"
+import { midnight } from "../util"
+import { Note, TimeEntry } from "../schema"
+import z from "zod"
+
+export class KimaiAPI {
+    private url: string
+    private authToken: string
+
+    public constructor(url: string, authToken: string) {
+        this.url = url.endsWith("/") ? url.slice(0, -1) : url
+        this.authToken = authToken
+    }
+
+    // util
+
+    private async request(method: "GET" | "POST" | "DELETE", path: string, body?: unknown) {
+        const response = await fetch(this.url + path, {
+            method,
+            headers: {
+                "Authorization": `Bearer ${this.authToken}`,
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify(body)
+        })
+        if (!response.ok) {
+            throw new Error(`Error fetching ${method} ${path}: ${response.statusText}\nBody: ${body ?? "none"}\nResponse: ${await response.text()}`)
+        }
+        return response
+    }
+
+    private async get<T>(path: string, schema?: z.ZodType<T>) {
+        const response = await (await this.request("GET", path, undefined)).json() as T
+        if (schema) return schema.parse(response)
+        return response
+    }
+    private async post<T>(path: string, body?: unknown) {
+        return (await this.request("POST", path, body)).json() as T
+    }
+    private async delete(path: string) {
+        await this.request("DELETE", path, undefined)
+    }
+
+    // endpoints
+
+    public async fetchCurrentUser() {
+        return await this.get("/api/users/me", z.object({
+            alias: z.string(),
+            username: z.string(),
+        }))
+    }
+
+    public async fetchProjects() {
+        return await this.get("/api/projects", z.array(z.object({
+            id: z.number(),
+            name: z.string(),
+            globalActivities: z.boolean()
+        })))
+    }
+
+    public async fetchActivities() {
+        return await this.get("/api/activities", z.array(z.object({
+            id: z.number(),
+            name: z.string(),
+            project: z.number().nullable()
+        })))
+    }
+
+    public async fetchThymeTimesheets(day: Date) {
+        const start = formatDate(midnight(day, false))
+        const end = formatDate(midnight(day, true))
+        return await this.get(`/api/timesheets?begin=${start}&end=${end}&tags%5B%5D=thyme`, z.array(z.object({
+            id: z.string()
+        })))
+    }
+
+    public async createThymeTimesheet(projectId: number, activityId: number, entry: TimeEntry, notes: Note[]) {
+        return await this.post<{ id: number }>("/api/timesheets", {
+            project: projectId,
+            activity: activityId,
+            begin: formatDate(entry.startTime),
+            end: formatDate(entry.endTime),
+            description: notes.map(note => `${dateFormat(note.time, "HH:MM")}: ${note.text}`).join("\n"),
+            tags: ["thyme"].join(","),
+        })
+    }
+
+    public async deleteTimesheet(id: number) {
+        return await this.delete(`/api/timesheets/${id}`)
+    }
+}
+
+function formatDate(date: Date) {
+    return dateFormat(date, "yyyy-mm-dd") + "T" + dateFormat(date, "HH:MM:ss")
+}

electron/kimai/kimaiIntegration.ts

@@ -0,0 +1,119 @@
+import { auditTime, distinctUntilChanged, filter, map, shareReplay, switchMap } from "rxjs"
+import { PersistentState } from "../persistentState"
+import { KimaiAPI } from "./kimaiApi"
+import { actions, Kimai } from "../schema"
+import { showGlobalError } from "../main"
+
+export function makeKimaiIntegration(persistentState: PersistentState) {
+    const api$ = persistentState.getState().pipe(
+        map(state => state.kimai === undefined ? undefined : new KimaiAPI(state.kimai!.url, state.kimai!.authToken)),
+        shareReplay(1)
+    )
+
+    const username$ = api$.pipe(
+        filter(api => api !== undefined),
+        switchMap(async api => {
+            try {
+                const user = (await api.fetchCurrentUser())
+                return user.alias ?? user.username
+            } catch (e) {
+                showGlobalError("Failed to fetch Kimai user", e)
+                return undefined
+            }
+        }),
+        filter(username => username !== undefined),
+        shareReplay(1)
+    )
+
+    const projectsAndActivities$ = api$.pipe(
+        filter(api => api !== undefined),
+        switchMap(async api => {
+            const [projects, activities] = await Promise.all([
+                api.fetchProjects(),
+                api.fetchActivities()
+            ])
+            return projects.map(project => ({
+                project: { id: project.id, name: project.name },
+                activities: activities
+                    .filter(activity => activity.project === project.id || (project.globalActivities && activity.project === null))
+                    .map(activity => ({ id: activity.id, name: activity.name }))
+            }))
+        }),
+        shareReplay(1)
+    )
+
+    // sync entries
+    persistentState.getState().pipe(
+        distinctUntilChanged((previous, current) => {
+            return JSON.stringify(previous) === JSON.stringify(current)
+        }),
+        auditTime(1000),
+        switchMap(async state => {
+            if (state.kimai === undefined) return
+            const kimai = state.kimai!
+            const api = new KimaiAPI(kimai.url, kimai.authToken)
+
+            // compute entries to compare, handling cutoff and ignoring those without Kimai activity fields
+            const currentEntries = state.timeEntries
+                .filter(entry => entry.startTime.getTime() >= kimai.cutoff.getTime())
+                .filter(entry => entry.activity?.kimai !== undefined)
+                .map(entry => {
+                    const entryNotes = state.notes.filter(note => entry.startTime.getTime() <= note.time.getTime() && note.time.getTime() <= entry.endTime.getTime())
+                    return { entry, entryNotes }
+                })
+            const uploadedEntries = kimai.uploadedEntries.filter(entry => entry.entry.startTime.getTime() >= kimai.cutoff.getTime())
+
+            const promises: Promise<Kimai["uploadedEntries"][0] | undefined>[] = []
+
+            // write current entries
+            for (const currentEntry of currentEntries) {
+                promises.push((async () => {
+                    const uploadedEntry = uploadedEntries.find(uploadedEntry => uploadedEntry.entry.id === currentEntry.entry.id)
+                    if (uploadedEntry === undefined || JSON.stringify(currentEntry.entry) !== JSON.stringify(uploadedEntry.entry) || JSON.stringify(currentEntry.entryNotes) !== JSON.stringify(uploadedEntry.notes)) {
+                        if (uploadedEntry !== undefined) {
+                            try {
+                                await api.deleteTimesheet(uploadedEntry.kimaiTimesheetId)
+                                console.log("Deleted outdated entry: ", uploadedEntry.entry.startTime)
+                            } catch (e) {
+                                showGlobalError("Failed to delete Kimai entry", e)
+                            }
+                        }
+                        const kimaiActivity = currentEntry.entry.activity!.kimai! // filtered before
+                        try {
+                            const { id: timesheetId } = await api.createThymeTimesheet(kimaiActivity.projectId, kimaiActivity.activityId, currentEntry.entry, currentEntry.entryNotes)
+                            console.log("Created entry: ", currentEntry.entry.startTime)
+                            return { entry: currentEntry.entry, notes: currentEntry.entryNotes, kimaiTimesheetId: timesheetId }
+                        } catch (e) {
+                            showGlobalError("Failed to create Kimai entry", e)
+                            return uploadedEntry
+                        }
+                    } else {
+                        return uploadedEntry // keep existing uploaded entry
+                    }
+                })())
+            }
+
+            // delete uploaded entries that don't exist
+            for (const uploadedEntry of uploadedEntries) {
+                promises.push((async () => {
+                    const currentEntry = currentEntries.find(currentEntry => currentEntry.entry.id === uploadedEntry.entry.id)
+                    if (currentEntry === undefined) {
+                        try {
+                            await api.deleteTimesheet(uploadedEntry.kimaiTimesheetId)
+                            console.log("Deleted entry: ", uploadedEntry.entry.startTime)
+                        } catch (e) {
+                            showGlobalError("Failed to delete Kimai entry", e)
+                        }
+                    }
+                    return undefined
+                })())
+            }
+
+            return (await Promise.all(promises)).filter(entry => entry !== undefined)
+        })
+    ).subscribe(newUploadedEntries => {
+        if (newUploadedEntries !== undefined) persistentState.dispatch(actions.updateKimaiUploadedEntries(newUploadedEntries))
+    })
+
+    return { api$, projectsAndActivities$, username$ }
+}

electron/main.ts

@@ -4,11 +4,12 @@ import { fileURLToPath } from "node:url"
 import path from "node:path"
 import { TrayIcon } from "./trayIcon"
 import { PersistentState } from "./persistentState"
-import { BehaviorSubject, filter, first, Observable } from "rxjs"
+import { BehaviorSubject, filter, Observable } from "rxjs"
 import fs from "node:fs"
 import { ipcPullChannels, ipcPushChannels } from "./ipcChannels"
 import { pages, WindowManager } from "./windowManager"
-import { NotesAction, TimeEntriesAction } from "./types"
+import { makeKimaiIntegration } from "./kimai/kimaiIntegration"
+import { actions } from "./schema"
 
 export const __dirname = path.dirname(fileURLToPath(import.meta.url))
 process.env.APP_ROOT = path.join(__dirname, "..")
@@ -20,13 +21,28 @@ export const RENDERER_DIST = path.join(process.env.APP_ROOT, "dist")
 
 process.env.VITE_PUBLIC = VITE_DEV_SERVER_URL ? path.join(process.env.APP_ROOT, "public") : RENDERER_DIST
 
+const errors$ = new BehaviorSubject<string[]>([])
+export function showGlobalError(msg: string, err: unknown) {
+  console.error(err)
+  errors$.next(errors$.getValue().concat([`${msg}: ${err}`]))
+}
+
 const userDataDir = isDev ? path.join(process.env.APP_ROOT, "dev-data") : app.getPath("userData")
 if (!fs.existsSync(userDataDir)) {
   fs.mkdirSync(userDataDir, { recursive: true })
 }
 
 const persistentStateFile = path.join(userDataDir, "data.json")
-const persistentState = new PersistentState(persistentStateFile)
+const persistentState = (() => {
+  try {
+    return new PersistentState(persistentStateFile)
+  } catch (e) {
+    showGlobalError("Failed to load data.json", e)
+    return null as unknown as PersistentState
+  }
+})()
+
+const kimaiIntegration = makeKimaiIntegration(persistentState)
 
 const windowManager = new WindowManager()
 
@@ -46,7 +62,7 @@ app.whenReady().then(() => {
   })
   Object.keys(PullIPC).forEach((channel) => {
     let lastValue: any
-    PullIPC[channel as keyof typeof PullIPC].subscribe(value => {
+    (PullIPC[channel as keyof typeof PullIPC] as Observable<any>).subscribe(value => {
       lastValue = value
       windowManager.sendAll(("listen__" + channel), value)
     })
@@ -60,8 +76,8 @@ app.whenReady().then(() => {
   // tray icon
   new TrayIcon({
     vitePublicDirectory: process.env.VITE_PUBLIC,
-    activeStartTime$: persistentState.getActiveStartTime(),
-    toggleActive: () => toggleActive(),
+    state$: persistentState.getState(),
+    toggleActive: () => persistentState.dispatch(actions.toggleActive()),
     toggleOpen: () => {
       const window = windowManager.findWindow(pages.dashboard)
       if (window?.isVisible()) {
@@ -76,25 +92,10 @@ app.whenReady().then(() => {
   })
 })
 
-function toggleActive() {
-  persistentState.getActiveStartTime().pipe(first()).subscribe(activeStartTime => {
-    if (activeStartTime === null) {
-      persistentState.setActiveStartTime(new Date())
-    } else {
-      persistentState.setActiveStartTime(null)
-      persistentState.reduceTimeEntries([{ action: "create", entry: { startTime: activeStartTime, endTime: new Date() } }])
-    }
-  })
-}
-
 const timelineDay$ = new BehaviorSubject<string | null>(null)
 
 export const PushIPC = {
-  toggleActive: () => toggleActive(),
-  reduceTimeEntries: (...actions: TimeEntriesAction[]) => persistentState.reduceTimeEntries(actions),
-  reduceNotes: (...actions: NotesAction[]) => persistentState.reduceNotes(actions),
-  deleteAllTimeEntriesAndNotes: () => persistentState.deleteAllTimeEntriesAndNotes(),
-  loadMockData: () => persistentState.loadMockData(),
+  dispatch: persistentState.dispatch,
   openJSON: () => shell.showItemInFolder(persistentStateFile),
   exportCSV: async (type: "byDay" | "allEntries") => {
     const exportPath = await dialog.showSaveDialog({ title: "Export CSV", buttonLabel: "Export", filters: [{ name: "CSV", extensions: ["csv"] }] })
@@ -104,11 +105,14 @@ export const PushIPC = {
     }
   },
   setTimelineDay: (date: string) => timelineDay$.next(date),
-  openPage: (page: "history" | "timeline" | "settings") => windowManager.openOrShowPage(pages[page]),
+  openPage: (page: "history" | "timeline" | "settings" | "selectKimaiActivityDialog") => windowManager.openOrShowPage(pages[page]),
   closePage: (pageId: string) => windowManager.closeWindow(pageId),
 } satisfies { [key in typeof ipcPushChannels[number]]: (...args: any[]) => any }
 
-export const PullIPC: { [key in typeof ipcPullChannels[number]]: Observable<any> } = {
+export const PullIPC = {
+  errors: errors$.asObservable(),
   state: persistentState.getState(),
   timelineDay: timelineDay$.pipe(filter(day => day !== null)),
-}
+  kimaiUsername: kimaiIntegration.username$,
+  kimaiProjectsAndActivities: kimaiIntegration.projectsAndActivities$,
+} satisfies { [key in typeof ipcPullChannels[number]]: Observable<any> }