fix(core): update

ts/smartdaemon.classes.service.ts

@@ -4,6 +4,7 @@ import { SmartDaemon } from './smartdaemon.classes.smartdaemon';
 
 export interface SmartDaemonServiceConstructorOptions {
   name: string;
+  description: string;
   command: string;
   workingDir: string;
 }
@@ -23,6 +24,7 @@ export class SmartDaemonService implements SmartDaemonServiceConstructorOptions
   public options: SmartDaemonServiceConstructorOptions;
 
   public name: string;
+  public description: string;
   public command: string;
   public workingDir: string;
 
@@ -36,22 +38,45 @@ export class SmartDaemonService implements SmartDaemonServiceConstructorOptions
    * enables the service
    */
   public async enable() {
-    this.smartdaemonRef
+    await this.save();
+    await this.smartdaemonRef.systemdManager.enableService(this.name);
   }
 
   /**
    * disables the service
    */
   public async disable() {
-
+    await this.smartdaemonRef.systemdManager.disableService(this.name);
   }
 
   /**
-   * pauses the service
+   * starts a service
    */
-  public pause() {};
+  public async start() {
+    await this.smartdaemonRef.systemdManager.startService(this.name);
+  }
 
-  public save() {
+  /**
+   * stops a service
+   */
+  public async stop() {
+    await this.smartdaemonRef.systemdManager.stopService(this.name);
+  }
 
+
+  // Save and Delete
+  public async save() {
+    await this.smartdaemonRef.systemdManager.saveService(this.name, this.smartdaemonRef.templateManager.generateServiceTemplate({
+      command: this.command,
+      description: this.description,
+      pathWorkkingDir: this.workingDir,
+      serviceName: this.name,
+      serviceVersion: 'x.x.x'
+    }));
+  }
+
+  /** */
+  public async delete() {
+    await this.smartdaemonRef.systemdManager.deleteService(this.name);
   }
 }

ts/smartdaemon.classes.smartdaemon.ts

@@ -1,6 +1,6 @@
 import * as plugins from './smartdaemon.plugins';
 import { SmartDaemonTemplateManager } from './smartdaemon.classes.templatemanager';
-import { SmartDaemonService } from './smartdaemon.classes.service';
+import { SmartDaemonService, SmartDaemonServiceConstructorOptions } from './smartdaemon.classes.service';
 import { SmartDaemonSystemdManager } from './smartdaemon.classes.systemdmanager';
 
 
@@ -17,19 +17,23 @@ export class SmartDaemon {
     this.systemdManager = new SmartDaemonSystemdManager(this);
   }
 
-  public async addService(nameArg: string, commandArg: string, workingDirectoryArg?: string): Promise<SmartDaemonService> {
+  /**
+   * adds a service
+   * @param nameArg
+   * @param commandArg 
+   * @param workingDirectoryArg 
+   */
+  public async addService(optionsArg: SmartDaemonServiceConstructorOptions): Promise<SmartDaemonService> {
     let serviceToAdd: SmartDaemonService;
     const existingService = this.serviceMap.find(serviceArg => {
-      return serviceArg.name === nameArg;
+      return serviceArg.name === optionsArg.name;
     });
     if (!existingService) {
-      serviceToAdd = await SmartDaemonService.createFromOptions(this, {
-        command: commandArg,
-        name: nameArg,
-        workingDir: workingDirectoryArg
-      })
+      serviceToAdd = await SmartDaemonService.createFromOptions(this, optionsArg);
     } else {
-
+      serviceToAdd = existingService;
+      Object.assign(serviceToAdd, optionsArg);
+      await serviceToAdd.save();
     }
     return serviceToAdd;
   };

ts/smartdaemon.classes.systemdmanager.ts

@@ -3,7 +3,20 @@ import * as paths from './smartdaemon.paths';
 import { SmartDaemon } from './smartdaemon.classes.smartdaemon';
 
 export class SmartDaemonSystemdManager {
-  private smartDaemonNamespace = 'smartdaemon_';
+  // STATIC
+  private static smartDaemonNamespace = 'smartdaemon_';
+  public static createFileNameFromServiceName = (serviceNameArg: string) => {
+    return `${SmartDaemonSystemdManager.smartDaemonNamespace}_${serviceNameArg}.service`;
+  };
+
+  public static createFilePathFromServiceName = (serviceNameArg: string) => {
+    return plugins.path.join(
+      paths.systemdDir,
+      SmartDaemonSystemdManager.createFileNameFromServiceName(serviceNameArg)
+    );
+  };
+
+  // INSTANCE
   public smartdaemonRef: SmartDaemon;
   public smartshellInstance: plugins.smartshell.Smartshell;
   public smartsystem: plugins.smartsystem.Smartsystem;
@@ -29,15 +42,56 @@ export class SmartDaemonSystemdManager {
   }
 
   public async execute(commandArg: string) {
-    (await this.checkElegibility()) ? await this.smartshellInstance.exec(commandArg) : null;
+    if (await this.checkElegibility()) {
+      await this.smartshellInstance.exec(commandArg);
+    }
   }
 
-  public async getServices () {
-    const availableServices = plugins.smartfile.fs.listAllItems(paths.systemdDir, new RegExp(`${this.smartDaemonNamespace}`));
+  public async getServices() {
+    if (await this.checkElegibility()) {
+      const availableServices = plugins.smartfile.fs.listAllItems(
+        paths.systemdDir,
+        new RegExp(`${SmartDaemonSystemdManager.smartDaemonNamespace}`)
+      );
+    }
   }
 
-  public async init() {
-
+  public async startService(serviceNameArg: string) {
+    if (await this.checkElegibility()) {
+      await this.execute(`systemctl start ${SmartDaemonSystemdManager.createFilePathFromServiceName(serviceNameArg)}`);
+    }
   };
+  public async stopService(serviceNameArg: string) {
+    if (await this.checkElegibility()) {
+      await this.execute(`systemctl stop ${SmartDaemonSystemdManager.createFilePathFromServiceName(serviceNameArg)}`);
+    }
+  }
 
-}
+  public async saveService(serviceNameArg: string, serviceFileString: string) {
+    if (await this.checkElegibility()) {
+      await plugins.smartfile.memory.toFs(
+        serviceFileString,
+        SmartDaemonSystemdManager.createFilePathFromServiceName(serviceNameArg)
+      );
+    }
+  }
+
+  public async deleteService(serviceName: string) {
+    if (await this.checkElegibility()) {
+      await plugins.smartfile.fs.remove(SmartDaemonSystemdManager.createFilePathFromServiceName(serviceName));
+    }
+  }
+
+  public async enableService(serviceName: string) {
+    if (await this.checkElegibility()) {
+      await this.execute(`systemctl enable ${SmartDaemonSystemdManager.createFileNameFromServiceName(serviceName)}`);
+    }
+  }
+  public async disableService(serviceName: string) {
+    if (await this.checkElegibility()) {
+      await this.execute(`systemctl disable ${SmartDaemonSystemdManager.createFileNameFromServiceName(serviceName)}`);
+    }
+  }
+
+  public async init() {}
+}

ts/smartdaemon.classes.templatemanager.ts

@@ -14,7 +14,6 @@ export class SmartDaemonTemplateManager {
     serviceVersion: string;
     command: string;
     pathWorkkingDir;
-    pathJsFileToRun;
   }) => {
     return `
 # servicVersion: ${optionsArg.serviceVersion}