feat: implementation of some Transaction methods

Author: MessiasLima

src/index.ts

@@ -1,12 +1,18 @@
-import { InterfaceProvider } from './interface.provider';
 import { PackageKit } from './packagekit';
+import { container } from 'tsyringe';
+import { TransactionProvider } from './transaction.provider';
+import { SearchFilter } from './search-filter.enum';
 
 async function teste() {
     try {
         console.log('getting interface');
         const packageKit = await PackageKit.create();
-        const transaction = await packageKit.createTransaction();
-        console.log('received', transaction);
+        const transactionPath = await packageKit.createTransaction();
+        const transactionProvider = container.resolve(TransactionProvider);
+        const transaction = await transactionProvider.getTransaction(
+            transactionPath
+        );
+        await transaction.cancel();
     } catch (e) {
         console.error(e);
     }

src/interface/transaction-dbus.interface.ts

@@ -1,3 +1,17 @@
 export interface TransactionDbus {
-    on(eventName: string, callback: (...args: any) => void): void;
+    SearchNames(
+        filter: number,
+        values: string[],
+        callback: (err: unknown, args: unknown) => void
+    ): void;
+
+    SearchDetails(
+        filter: number,
+        values: string[],
+        callback: (err: unknown, args: unknown) => void
+    ): void;
+
+    Cancel(callback: (err: unknown) => void): void;
+
+    on(eventName: string, callback: (args: unknown) => void): void;
 }

src/search-filter.enum.ts

@@ -0,0 +1,4 @@
+export enum SearchFilter {
+    NONE = 0,
+    INSTALLED = 1
+}

src/transaction.ts

@@ -1,32 +1,88 @@
 import { TransactionDbus } from './interface/transaction-dbus.interface';
 import { Subject } from 'rxjs';
+import { SearchFilter } from './search-filter.enum';
 
 export class Transaction {
     readonly onDestroy = new Subject<Transaction>();
+
     private active = true;
 
     constructor(private transactionDbus: TransactionDbus, public path: string) {
         this.initSignalListeners();
     }
 
     private initSignalListeners(): void {
-        this.initOnDestroyListener();
+        this.registerDestroyListener();
+    }
+
+    // #region Methods
+    searchNames(filter: SearchFilter, packages: string[]): Promise<void> {
+        return new Promise<void>((resolve, reject) => {
+            this.transactionDbus.SearchNames(
+                filter.valueOf(),
+                packages,
+                function (err) {
+                    if (err) {
+                        reject();
+                    } else {
+                        resolve();
+                    }
+                }
+            );
+        });
+    }
+
+    cancel(): Promise<void> {
+        return new Promise((resolve, reject) => {
+            this.transactionDbus.Cancel((err) => {
+                if (err) {
+                    console.error('Cancel', err);
+                    reject();
+                } else {
+                    console.log('cancel success');
+                    resolve();
+                }
+            });
+        });
     }
 
-    private initOnDestroyListener(): void {
+    // #endregion
+
+    // #region Signals
+    /**
+     * This signal is sent when the transaction has been destroyed and is no longer available for use.
+     */
+    private registerDestroyListener(): void {
         this.transactionDbus.on('Destroy', () => {
             this.active = false;
             this.onDestroy.next(this);
             this.clearSubscriptions();
         });
     }
 
-    private clearSubscriptions() {
+    /**
+     *  This signal allows the backend to communicate packages to the session.
+     *
+     * If updating, as packages are updated then emit them to the screen. This allows a summary to be presented after the transaction.
+     *
+     * When returning results from a search always return installed before available for the same package name.
+     */
+    private registerPackageListener(): void {
+        this.transactionDbus.on('Package', function () {
+            console.log('packages', arguments);
+        });
+    }
+
+    // #endregion
 
+    // #region auxiliary methods
+    private clearSubscriptions(): void {
         const observables = [this.onDestroy];
 
         observables.forEach((obs) => {
             obs.unsubscribe();
         });
     }
+
+    // #endregion
 }