Semi

Author: sheepzh

src/api/http.ts

@@ -32,6 +32,20 @@ export async function fetchPost<T>(url: string, body?: T, option?: Option): Prom
     }
 }
 
+export async function fetchPut<T>(url: string, body?: T, option?: Option): Promise<Response> {
+    try {
+        const response = await fetch(url, {
+            ...(option || {}),
+            method: "PUT",
+            body: body ? JSON.stringify(body) : null,
+        })
+        return response
+    } catch (e) {
+        console.error("Failed to fetch post", e)
+        throw Error(e)
+    }
+}
+
 export async function fetchPutText(url: string, bodyText?: string, option?: Option): Promise<Response> {
     try {
         const response = await fetch(url, {

src/api/quantified-resume.ts

@@ -1,4 +1,4 @@
-import { fetchGet, fetchPost } from "./http"
+import { fetchGet, fetchPost, fetchPut } from "./http"
 
 const QR_BUILTIN_TYPE = "BrowserTime"
 export const DEFAULT_ENDPOINT = "http://localhost:12233"
@@ -22,6 +22,12 @@ export type QrRequestContext = {
     endpoint?: string
 }
 
+const headers = (): Headers => {
+    const headers = new Headers()
+    headers.append("Content-Type", "application/json")
+    return headers
+}
+
 export const listBuckets = async (ctx: QrRequestContext, clientId?: string): Promise<Bucket[]> => {
     const response = await fetchGet(`${ctx?.endpoint || DEFAULT_ENDPOINT}/api/0/bucket?bt=${QR_BUILTIN_TYPE}&bt_rid=${clientId || ''}`)
     const status = response?.status
@@ -36,7 +42,7 @@ export const listBuckets = async (ctx: QrRequestContext, clientId?: string): Pro
 }
 
 export const createBucket = async (ctx: QrRequestContext, bucket: Bucket): Promise<number> => {
-    const response = await fetchPost(`${ctx?.endpoint || DEFAULT_ENDPOINT}/api/0/bucket`, bucket)
+    const response = await fetchPost(`${ctx?.endpoint || DEFAULT_ENDPOINT}/api/0/bucket`, bucket, { headers: headers() })
     const status = response?.status
     if (status === 200) {
         return await response.json()
@@ -46,4 +52,18 @@ export const createBucket = async (ctx: QrRequestContext, bucket: Bucket): Promi
         console.error(response)
         throw new Error("Unexpected status code: " + status)
     }
+}
+
+export const updateBucket = async (ctx: QrRequestContext, bucket: Bucket): Promise<void> => {
+    const response = await fetchPut(`${ctx?.endpoint || DEFAULT_ENDPOINT}/api/0/bucket/${bucket?.id}`, bucket, { headers: headers() })
+    const status = response?.status
+    if (status === 200) {
+        return
+    }
+    if (status === 422) {
+        throw new Error("Failed to connect Quantified Resume, please contact the developer")
+    } else {
+        console.error(response)
+        throw new Error("Unexpected status code: " + status)
+    }
 }

src/common/backup/quantified-resume/coordinator.ts

@@ -1,4 +1,7 @@
-import { Bucket, listBuckets } from "@api/quantified-resume"
+import { Bucket, createBucket, listBuckets, updateBucket } from "@api/quantified-resume"
+import metaMessages, { } from "@i18n/message/common/meta"
+import { t } from "@i18n"
+import { groupBy } from "@util/array"
 
 export type QuantifiedResumeCache = {
     bucketIds: {
@@ -7,6 +10,19 @@ export type QuantifiedResumeCache = {
     }
 }
 
+async function createNewBucket(context: timer.backup.CoordinatorContext<QuantifiedResumeCache>): Promise<number> {
+    const { cid, cname } = context || {}
+    const { endpoint } = context?.ext || {}
+    const appName = t(metaMessages, { key: msg => msg.name })
+    const bucket: Bucket = {
+        name: `${appName}: ${cid}`,
+        builtin: "BrowserTime",
+        builtinRefId: cid,
+        payload: { name: cname }
+    }
+    return createBucket({ endpoint }, bucket)
+}
+
 async function getBucketId(context: timer.backup.CoordinatorContext<QuantifiedResumeCache>): Promise<number> {
     const { cid, cache } = context || {}
     // 1. query from cache
@@ -16,25 +32,31 @@ async function getBucketId(context: timer.backup.CoordinatorContext<QuantifiedRe
     const { endpoint } = context?.ext || {}
     // 2. query again
     bucketId = (await listBuckets({ endpoint }, cid))?.[0]?.id
-    // TODO
     if (!bucketId) {
         // 3. create one
-        const bucket: Bucket = {
-            name: "Time Tracker: " + cid,
-            builtin: "BrowserTime",
-            builtinRefId: cid,
-            payload: {
-                name: ""
-            }
-        }
+        bucketId = await createNewBucket(context)
     }
-    throw new Error("TODO")
+    return bucketId
 }
 
 export default class QuantifiedResumeCoordinator implements timer.backup.Coordinator<QuantifiedResumeCache> {
-
-    updateClients(_: timer.backup.CoordinatorContext<QuantifiedResumeCache>, clients: timer.backup.Client[]): Promise<void> {
-        throw new Error("Method not implemented.");
+    async updateClients(context: timer.backup.CoordinatorContext<QuantifiedResumeCache>, clients: timer.backup.Client[]): Promise<void> {
+        const { endpoint } = context?.ext || {}
+        const existBuckets = groupBy(await listBuckets({ endpoint }) || [], b => b.builtinRefId, l => l?.[0])
+        if (!clients?.length) return
+        const promises = Promise.all(clients.map(
+            async ({ id, name, minDate, maxDate }) => {
+                const exist = existBuckets[id]
+                if (exist) {
+                    // update payload
+                    exist.payload = { name, minDate, maxDate }
+                    await updateBucket({ endpoint }, exist)
+                } else {
+                    await createNewBucket(context)
+                }
+            })
+        )
+        await promises
     }
 
     async listAllClients(context: timer.backup.CoordinatorContext<QuantifiedResumeCache>): Promise<timer.backup.Client[]> {
@@ -66,7 +88,9 @@ export default class QuantifiedResumeCoordinator implements timer.backup.Coordin
 
     async upload(context: timer.backup.CoordinatorContext<QuantifiedResumeCache>, rows: timer.stat.RowBase[]): Promise<void> {
         const bucketId = await getBucketId(context)
-        throw new Error("Method not implemented.");
+        rows.forEach(row => {
+
+        })
     }
 
     async testAuth(_auth: timer.backup.Auth, ext: timer.backup.TypeExt): Promise<string> {