verteilen-core 1.3.8 → 1.3.10

package/dist/interface/base.d.ts

@@ -85,3 +85,6 @@ export interface Node extends DataHeader {
     permission?: LocalPermission;
     acl?: ACLType;
 }
+export declare const CreateDefaultProject: () => Project;
+export declare const CreateDefaultTask: () => Task;
+export declare const CreateDefaultJob: () => Job;

package/dist/interface/base.js

@@ -1,2 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateDefaultJob = exports.CreateDefaultTask = exports.CreateDefaultProject = void 0;
+const enum_1 = require("./enum");
+const uuid_1 = require("uuid");
+const CreateDefaultProject = () => {
+    return {
+        uuid: (0, uuid_1.v6)(),
+        title: "",
+        description: "",
+        tasks: [],
+        tasks_uuid: [],
+        database_uuid: ""
+    };
+};
+exports.CreateDefaultProject = CreateDefaultProject;
+const CreateDefaultTask = () => {
+    return {
+        uuid: (0, uuid_1.v6)(),
+        title: "Default",
+        description: "",
+        setupjob: false,
+        cronjob: false,
+        cronjobKey: "",
+        multi: false,
+        multiKey: "",
+        properties: [],
+        jobs: [],
+        jobs_uuid: [],
+    };
+};
+exports.CreateDefaultTask = CreateDefaultTask;
+const CreateDefaultJob = () => {
+    return {
+        uuid: (0, uuid_1.v6)(),
+        category: enum_1.JobCategory.Execution,
+        type: enum_1.JobType.JAVASCRIPT,
+        script: "",
+        string_args: [],
+        number_args: [],
+        boolean_args: [],
+        id_args: [],
+    };
+};
+exports.CreateDefaultJob = CreateDefaultJob;

package/dist/server/module/project.d.ts

@@ -9,8 +9,8 @@ export declare class Project_Module {
     ProjectJobCount(uuid: string): number;
     PopulateProject(uuid: string): Project | undefined;
     PopulateTask(uuid: string): Task | undefined;
-    GetProjectRelatedTask(uuid: string): Array<Task>;
-    GetTaskRelatedJob(uuid: string): Array<Job>;
+    GetProjectRelatedTask(uuid: string): Promise<Array<Task>>;
+    GetTaskRelatedJob(uuid: string): Promise<Array<Job>>;
     CloneProjects(uuids: Array<string>): Promise<Array<string>>;
     CloneTasks(uuids: Array<string>): Promise<Array<string>>;
     CloneJobs(uuids: Array<string>): Promise<Array<string>>;

package/dist/server/module/project.js

@@ -43,23 +43,29 @@ class Project_Module {
         }
         return buffer;
     }
-    GetProjectRelatedTask(uuid) {
+    async GetProjectRelatedTask(uuid) {
+        await this.loader.project.load(uuid, true);
         const p = this.memory.projects.find(x => x.uuid == uuid);
         if (!p)
             return [];
         const r = p.tasks_uuid.map(x => {
-            return this.memory.tasks.find(y => y.uuid == x);
-        }).filter(x => x != undefined);
-        return r;
+            return this.loader.task.load(x, true);
+        });
+        await Promise.all(r);
+        const tasks = this.memory.tasks.filter(x => p.tasks_uuid.includes(x.uuid));
+        return tasks;
     }
-    GetTaskRelatedJob(uuid) {
+    async GetTaskRelatedJob(uuid) {
+        await this.loader.task.load(uuid, true);
         const p = this.memory.tasks.find(x => x.uuid == uuid);
         if (!p)
             return [];
         const r = p.jobs_uuid.map(x => {
-            return this.memory.jobs.find(y => y.uuid == x);
-        }).filter(x => x != undefined);
-        return r;
+            return this.loader.job.load(x, true);
+        });
+        await Promise.all(r);
+        const jobs = this.memory.jobs.filter(x => p.jobs_uuid.includes(x.uuid));
+        return jobs;
     }
     async CloneProjects(uuids) {
         const p = uuids.map(x => this.loader.project.load(x, true));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "verteilen-core",
-  "version": "1.3.8",
+  "version": "1.3.10",
   "license": "MIT",
   "homepage": "https://verteilen.github.io/wiki/",
   "author": "Elly",

package/src/interface/base.ts

@@ -6,9 +6,10 @@
 /**
  * Defined the basic compute use data structure
  */
-import { DataType, DataTypeBase, JobType, JobType2, ServiceMode } from "./enum"
+import { DataType, DataTypeBase, JobCategory, JobType, JobType2, ServiceMode } from "./enum"
 import { ACLType, LocalPermission as LocalPermission } from "./server"
 import { TaskLogic } from "./struct"
+import { v6 as uuidv6 } from 'uuid'
 
 export interface DatabaseConfigTrigger {
     types: Array<DataTypeBase>
@@ -389,4 +390,45 @@ export interface Node extends DataHeader {
      * Could be public, protected, private
      */
     acl?: ACLType
+}
+
+
+export const CreateDefaultProject = () : Project => {
+    return {
+        uuid: uuidv6(),
+        title: "",
+        description: "",
+        tasks: [],
+        tasks_uuid: [],
+        database_uuid: ""
+    }
+}
+
+export const CreateDefaultTask = () : Task => {
+    return {
+        uuid: uuidv6(),
+        title: "Default",
+        description: "",
+        setupjob: false,
+        cronjob: false,
+        cronjobKey: "",
+        multi: false,
+        multiKey: "",
+        properties: [],
+        jobs: [],
+        jobs_uuid: [],
+    }
+}
+
+export const CreateDefaultJob = () : Job => {
+    return {
+        uuid: uuidv6(),
+        category: JobCategory.Execution,
+        type: JobType.JAVASCRIPT,
+        script: "",
+        string_args: [],
+        number_args: [],
+        boolean_args: [],
+        id_args: [],
+    }
 }

package/src/server/module/project.ts

@@ -61,26 +61,32 @@ export class Project_Module {
      * @param uuid Project UUID
      * @returns Related Tasks
      */
-    GetProjectRelatedTask(uuid:string):Array<Task> {
+    async GetProjectRelatedTask(uuid:string):Promise<Array<Task>> {
+        await this.loader.project.load(uuid, true)
         const p = this.memory.projects.find(x => x.uuid == uuid)
         if(!p) return []
         const r = p.tasks_uuid.map(x => {
-            return this.memory.tasks.find(y => y.uuid == x)
-        }).filter(x => x != undefined)
-        return r
+            return this.loader.task.load(x, true)
+        })
+        await Promise.all(r)
+        const tasks = this.memory.tasks.filter(x => p.tasks_uuid.includes(x.uuid))
+        return tasks
     }
     /**
      * Get jobs from task related
      * @param uuid Task UUID
      * @returns Related Jobs
      */
-    GetTaskRelatedJob(uuid:string):Array<Job> {
+    async GetTaskRelatedJob(uuid:string):Promise<Array<Job>> {
+        await this.loader.task.load(uuid, true)
         const p = this.memory.tasks.find(x => x.uuid == uuid)
         if(!p) return []
         const r = p.jobs_uuid.map(x => {
-            return this.memory.jobs.find(y => y.uuid == x)
-        }).filter(x => x != undefined)
-        return r
+            return this.loader.job.load(x, true)
+        })
+        await Promise.all(r)
+        const jobs = this.memory.jobs.filter(x => p.jobs_uuid.includes(x.uuid))
+        return jobs
     }
     /**
      * Clone Project Container