verteilen-core 1.3.7 → 1.3.9

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

@@ -11,6 +11,9 @@ export declare class Project_Module {
     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) {
@@ -60,6 +61,43 @@ class Project_Module {
         }).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.7",
+  "version": "1.3.9",
   "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

@@ -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
@@ -81,6 +82,58 @@ export class Project_Module {
         }).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