add more pasteboard dao methods

Author: WhiredPlanck

entry/src/main/ets/InputMethodExtensionAbility/model/pasteboard/PasteboardController.ets

@@ -9,9 +9,7 @@ import { StrUtil } from '../../../utils/StrUtil'
 
 const systemPasteboard: pasteboard.SystemPasteboard = pasteboard.getSystemPasteboard()
 
-export interface OnPasteboardUpdateListener {
-  onUpdate(entry: PasteboardEntry): void
-}
+export type OnPasteboardUpdateListener = (entry: PasteboardEntry) => void
 
 export class PasteboardController {
   private psbDao: PasteboardDao | null = null
@@ -29,12 +27,22 @@ export class PasteboardController {
     this.onUpdateListeners.remove(listener)
   }
 
+  private itemCount: number = 0
+
+  getItemCount(): number {
+    return this.itemCount
+  }
+
+  private async updateItemCount() {
+    this.itemCount = await this.psbDao!.itemCount()
+  }
+
   public lastEntry: PasteboardEntry | null = null
 
   private updateLastEntry(entry: PasteboardEntry): void {
     this.lastEntry = entry
     this.onUpdateListeners.forEach((listener) => {
-      listener?.onUpdate(entry)
+      listener?.(entry)
     })
   }
 
@@ -43,20 +51,86 @@ export class PasteboardController {
     PasteboardDatabase.init(context)
     this.psbDao = new PasteboardDao()
     systemPasteboard.on('update', this.onSystemPasteboardUpdate)
+    const launch = async () => {
+      await this.updateItemCount()
+    }
+    launch().catch()
   }
 
   public onDestroy(): void {
     console.debug('onDestroy')
     systemPasteboard.off('update', this.onSystemPasteboardUpdate)
   }
 
+  async get(id: number): Promise<PasteboardEntry> {
+    return await this.psbDao!.getById(id)
+  }
+
+  async haveUnpinned(): Promise<boolean> {
+    return await this.psbDao!.haveUnpinned()
+  }
+
+  async allEntries(): Promise<Array<PasteboardEntry>> {
+    return await this.psbDao!.allEntries()
+  }
+
+  async pin(id: number) {
+    await this.psbDao!.updatePinStatus(id, true)
+  }
+
+  async unpin(id: number) {
+    await this.psbDao!.updatePinStatus(id, false)
+  }
+
+  async updateText(id: number, text: string) {
+    if (this.lastEntry) {
+      if (id === this.lastEntry.id) {
+        const copy = this.lastEntry
+        copy.text = text
+        this.updateLastEntry(copy)
+      }
+    }
+    await this.psbDao!.updateText(id, text)
+  }
+
+  async delete(id: number) {
+    await this.psbDao!.markAsDeleted(id)
+    await this.updateItemCount()
+  }
+
+  async deleteAll(skipPinned: boolean = true): Promise<Array<number>> {
+    let ids: number[]
+    if (skipPinned) {
+      ids = await this.psbDao!.findUnpinnedIds()
+    } else {
+      ids = await this.psbDao!.findAllIds()
+    }
+    this.psbDao?.markAsDeleted(...ids)
+    await this.updateItemCount()
+    return ids
+  }
+
+  async undoDelete(...ids: number[]) {
+    await this.psbDao!.undoDelete(...ids)
+    await this.updateItemCount()
+  }
+
+  async realDelete() {
+    await this.psbDao!.realDelete()
+  }
+
+  async nukeTables() {
+    await this.psbDao!.clearAllTables()
+    await this.updateItemCount()
+  }
+
   @sql.Transactional()
   private async insertEntry(entry: PasteboardEntry): Promise<PasteboardEntry> {
     const rowId = await this.psbDao!.insert(entry)
     if (!rowId) {
       return entry
     }
-    const inserted = await this.psbDao!.get(rowId)
+    const inserted = await this.psbDao!.getByRowId(rowId)
     return inserted ? inserted : entry
   }
 
@@ -73,11 +147,15 @@ export class PasteboardController {
       try {
         const existed = await pasteboardController.psbDao!.find(entry.text, entry.sensitive)
         if (existed) {
+          const copy = existed
+          copy.timestamp = entry.timestamp
+          pasteboardController.updateLastEntry(copy)
           await pasteboardController.psbDao!.updateTime(existed.id, entry.timestamp)
         } else {
           const insertedEntry = await pasteboardController.insertEntry(entry)
           console.debug('get entry text: ' + insertedEntry.text)
           pasteboardController.updateLastEntry(insertedEntry)
+          pasteboardController.updateItemCount()
         }
       } catch (e) {
         const error = e as Error

entry/src/main/ets/InputMethodExtensionAbility/model/pasteboard/PasteboardDao.ets

@@ -12,14 +12,54 @@ export class PasteboardDao {
     return sql.PromiseNull()
   }
 
+  @sql.SqlUpdate(`UPDATE ${PasteboardEntry.TABLE_NAME} SET pinned=#{pinned} WHERE id=#{id}`)
+  updatePinStatus(@sql.Param('id') id: number, @sql.Param('pinned') pinned: boolean): Promise<void> {
+    return sql.PromiseNull()
+  }
+
+  @sql.SqlUpdate(`UPDATE ${PasteboardEntry.TABLE_NAME} SET text=#{text} WHERE id=#{id}`)
+  updateText(@sql.Param('id') id: number, @sql.Param('text') text: string): Promise<void> {
+    return sql.PromiseNull()
+  }
+
   @sql.SqlUpdate(`UPDATE ${PasteboardEntry.TABLE_NAME} SET timestamp=#{timestamp} WHERE id=#{id}`)
   updateTime(@sql.Param('id') id: number, @sql.Param('timestamp') timestamp: number): Promise<void> {
     return sql.PromiseNull()
   }
 
+  @sql.SqlQuery(`SELECT COUNT(*) FROM ${PasteboardEntry.TABLE_NAME} WHERE deleted=0`)
+  @sql.ReturnType(Number)
+  itemCount(): Promise<number> {
+    return sql.PromiseNull()
+  }
+
+  @sql.SqlQuery(`SELECT * FROM ${PasteboardEntry.TABLE_NAME} WHERE id=#{id} AND deleted=0 LIMIT 1`)
+  @sql.ReturnType(PasteboardEntry)
+  getById(@sql.Param('id') id: number): Promise<PasteboardEntry> {
+    return sql.PromiseNull()
+  }
+
   @sql.SqlQuery(`SELECT * FROM ${PasteboardEntry.TABLE_NAME} WHERE rowId=#{rowId} AND deleted=0 LIMIT 1`)
   @sql.ReturnType(PasteboardEntry)
-  get(@sql.Param('rowId') rowId: number): Promise<PasteboardEntry> {
+  getByRowId(@sql.Param('rowId') rowId: number): Promise<PasteboardEntry> {
+    return sql.PromiseNull()
+  }
+
+  @sql.SqlQuery(`SELECT EXISTS(SELECT 1 FROM ${PasteboardEntry.TABLE_NAME} WHERE pinned=0 AND deleted=0)`)
+  @sql.ReturnType(Boolean)
+  haveUnpinned(): Promise<boolean> {
+    return sql.PromiseNull()
+  }
+
+  @sql.SqlQuery(`SELECT * FROM ${PasteboardEntry.TABLE_NAME} WHERE pinned=0 AND deleted=0`)
+  @sql.ReturnType([PasteboardEntry])
+  getAllUnpinned(): Promise<Array<PasteboardEntry>> {
+    return sql.PromiseNull()
+  }
+
+  @sql.SqlQuery(`SELECT * FROM ${PasteboardEntry.TABLE_NAME} WHERE deleted=0 ORDER BY pinned DESC, timestamp DESC`)
+  @sql.ReturnType([PasteboardEntry])
+  allEntries(): Promise<Array<PasteboardEntry>> {
     return sql.PromiseNull()
   }
 
@@ -29,4 +69,41 @@ export class PasteboardDao {
     @sql.Param('sensitive') sensitive: boolean = false): Promise<PasteboardEntry> {
     return sql.PromiseNull()
   }
+
+  @sql.SqlQuery(`SELECT id FROM ${PasteboardEntry.TABLE_NAME} WHERE deleted=0`)
+  @sql.ReturnType([Number])
+  findAllIds(): Promise<Array<number>> {
+    return sql.PromiseNull()
+  }
+
+  @sql.SqlQuery(`SELECT id FROM ${PasteboardEntry.TABLE_NAME} WHERE pinned=0 AND deleted=0`)
+  @sql.ReturnType([Number])
+  findUnpinnedIds(): Promise<Array<number>> {
+    return sql.PromiseNull()
+  }
+
+  @sql.SqlUpdate(`UPDATE ${PasteboardEntry.TABLE_NAME} SET deleted=1 WHERE id in (#{ids})`)
+  markAsDeleted(@sql.Param('ids') ...ids: number[]): Promise<void> {
+    return sql.PromiseNull()
+  }
+
+  @sql.SqlUpdate(`UPDATE ${PasteboardEntry.TABLE_NAME} SET deleted=1 WHERE timestamp<#{timestamp} AND pinned=0 AND deleted=0`)
+  markUnpinnedAsDeletedEarlierThan(@sql.Param('timestamp') timestamp: number): Promise<void> {
+    return sql.PromiseNull()
+  }
+
+  @sql.SqlUpdate(`UPDATE ${PasteboardEntry.TABLE_NAME} SET deleted=0 WHERE id in (#{ids}) AND deleted=1`)
+  undoDelete(@sql.Param(`ids`) ...ids: number[]): Promise<void> {
+    return sql.PromiseNull()
+  }
+
+  @sql.SqlDelete(`DELETE FROM ${PasteboardEntry.TABLE_NAME} WHERE deleted=1`)
+  realDelete(): Promise<void> {
+    return sql.PromiseNull()
+  }
+
+  @sql.SqlDelete(`DELETE FROM ${PasteboardEntry.TABLE_NAME}`)
+  clearAllTables(): Promise<void> {
+    return sql.PromiseNull()
+  }
 }