verteilen-core 1.3.9 → 1.3.11

package/dist/server/io.js

@@ -114,7 +114,7 @@ const _CreateRecordIOLoader = (loader, memory, type, folder, ext = ".json") => {
             if (cache) {
                 const b = arr.findIndex(x => x.uuid == name);
                 if (b != -1)
-                    return arr[b];
+                    return JSON.stringify(arr[b]);
             }
             const root = loader.join(loader.root, folder);
             if (!loader.exists(root))

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.9",
+  "version": "1.3.11",
   "license": "MIT",
   "homepage": "https://verteilen.github.io/wiki/",
   "author": "Elly",

package/src/server/io.ts

@@ -195,7 +195,7 @@ export const _CreateRecordIOLoader = (loader:RecordIOBase, memory:MemoryData, ty
             const arr = get_array(type)
             if(cache){
                 const b = arr.findIndex(x => x.uuid == name)
-                if(b != -1) return arr[b]
+                if(b != -1) return JSON.stringify(arr[b])
             }
             const root = loader.join(loader.root, folder)
             if(!loader.exists(root)) await loader.mkdir(root)

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