verteilen-core 1.3.6 → 1.3.8

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

@@ -1,4 +1,4 @@
-import { Project, Task } from "../../interface";
+import { Job, Project, Task } from "../../interface";
 import { MemoryData, RecordLoader } from "../io";
 import { Server } from "../server";
 export declare class Project_Module {
@@ -9,6 +9,11 @@ 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>;
+    CloneProjects(uuids: Array<string>): Promise<Array<string>>;
+    CloneTasks(uuids: Array<string>): Promise<Array<string>>;
+    CloneJobs(uuids: Array<string>): Promise<Array<string>>;
     CascadeDeleteProject(uuid: string, bind: boolean): void;
     CascadeDeleteTask(uuid: string): void;
     Delete_Database_Idle(uuid: string): Promise<void>;

package/dist/server/module/project.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Project_Module = void 0;
+const uuid_1 = require("uuid");
 class Project_Module {
     server;
     constructor(memory) {
@@ -42,6 +43,61 @@ class Project_Module {
         }
         return buffer;
     }
+    GetProjectRelatedTask(uuid) {
+        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;
+    }
+    GetTaskRelatedJob(uuid) {
+        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;
+    }
+    async CloneProjects(uuids) {
+        const p = uuids.map(x => this.loader.project.load(x, true));
+        const ps = await Promise.all(p);
+        const projects = ps.map(x => JSON.parse(x));
+        projects.forEach(x => x.uuid = (0, uuid_1.v6)());
+        const jus = projects.map(x => this.CloneTasks(x.tasks_uuid));
+        const ju = await Promise.all(jus);
+        projects.forEach((t, index) => {
+            t.tasks_uuid = ju[index];
+        });
+        const js = projects.map(x => this.loader.project.save(x.uuid, JSON.stringify(x)));
+        await Promise.all(js);
+        return projects.map(x => x.uuid);
+    }
+    async CloneTasks(uuids) {
+        const p = uuids.map(x => this.loader.task.load(x, true));
+        const ps = await Promise.all(p);
+        const tasks = ps.map(x => JSON.parse(x));
+        tasks.forEach(x => x.uuid = (0, uuid_1.v6)());
+        const jus = tasks.map(x => this.CloneJobs(x.jobs_uuid));
+        const ju = await Promise.all(jus);
+        tasks.forEach((t, index) => {
+            t.jobs_uuid = ju[index];
+        });
+        const js = tasks.map(x => this.loader.task.save(x.uuid, JSON.stringify(x)));
+        await Promise.all(js);
+        return tasks.map(x => x.uuid);
+    }
+    async CloneJobs(uuids) {
+        const p = uuids.map(x => this.loader.job.load(x, true));
+        const ps = await Promise.all(p);
+        const jobs = ps.map(x => JSON.parse(x));
+        jobs.forEach(x => x.uuid = (0, uuid_1.v6)());
+        const js = jobs.map(x => this.loader.job.save(x.uuid, JSON.stringify(x)));
+        await Promise.all(js);
+        return jobs.map(x => x.uuid);
+    }
     CascadeDeleteProject(uuid, bind) {
         const p = this.memory.projects.find(p => p.uuid == uuid);
         if (!p)

package/package.json

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

package/src/server/module/project.ts

@@ -6,6 +6,7 @@
 import { Job, Project, Task } from "../../interface"
 import { MemoryData, RecordLoader } from "../io"
 import { Server } from "../server"
+import { v6 as uuidv6 } from 'uuid'
 
 export class Project_Module {
     server:Server
@@ -55,6 +56,84 @@ export class Project_Module {
         }
         return buffer
     }
+    /**
+     * Get tasks from project related
+     * @param uuid Project UUID
+     * @returns Related Tasks
+     */
+    GetProjectRelatedTask(uuid:string):Array<Task> {
+        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
+    }
+    /**
+     * Get jobs from task related
+     * @param uuid Task UUID
+     * @returns Related Jobs
+     */
+    GetTaskRelatedJob(uuid:string):Array<Job> {
+        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
+    }
+    /**
+     * Clone Project Container
+     * @param uuids project uuids
+     * @returns The new uuids list
+     */
+    async CloneProjects(uuids:Array<string>):Promise<Array<string>>{
+        const p = uuids.map(x => this.loader.project.load(x, true))
+        const ps = await Promise.all(p)
+        const projects:Array<Project> = ps.map(x => JSON.parse(x))
+        projects.forEach(x => x.uuid = uuidv6())
+        const jus = projects.map(x => this.CloneTasks(x.tasks_uuid))
+        const ju = await Promise.all(jus)
+        projects.forEach((t, index) => {
+            t.tasks_uuid = ju[index]
+        })
+        const js = projects.map(x => this.loader.project.save(x.uuid, JSON.stringify(x)))
+        await Promise.all(js)
+        return projects.map(x => x.uuid)
+    }
+    /**
+     * Clone Task Container
+     * @param uuids task uuids
+     * @returns The new uuids list
+     */
+    async CloneTasks(uuids:Array<string>):Promise<Array<string>>{
+        const p = uuids.map(x => this.loader.task.load(x, true))
+        const ps = await Promise.all(p)
+        const tasks:Array<Task> = ps.map(x => JSON.parse(x))
+        tasks.forEach(x => x.uuid = uuidv6())
+        const jus = tasks.map(x => this.CloneJobs(x.jobs_uuid))
+        const ju = await Promise.all(jus)
+        tasks.forEach((t, index) => {
+            t.jobs_uuid = ju[index]
+        })
+        const js = tasks.map(x => this.loader.task.save(x.uuid, JSON.stringify(x)))
+        await Promise.all(js)
+        return tasks.map(x => x.uuid)
+    }
+    /**
+     * Clone Job Container
+     * @param uuids job uuids
+     * @returns The new uuids list
+     */
+    async CloneJobs(uuids:Array<string>):Promise<Array<string>>{
+        const p = uuids.map(x => this.loader.job.load(x, true))
+        const ps = await Promise.all(p)
+        const jobs:Array<Job> = ps.map(x => JSON.parse(x))
+        jobs.forEach(x => x.uuid = uuidv6())
+        const js = jobs.map(x => this.loader.job.save(x.uuid, JSON.stringify(x)))
+        await Promise.all(js)
+        return jobs.map(x => x.uuid)
+    }
     /**
      * Delete project related data and project itself
      * @param uuid Project UUID