verteilen-core 1.3.14 → 1.3.16

package/dist/server/io.js

@@ -105,9 +105,9 @@ const _CreateRecordIOLoader = (loader, memory, type, folder, ext = ".json") => {
             const arr = get_array(type);
             const b = arr.findIndex(x => x.uuid == uuid);
             if (b != -1)
-                arr.push(JSON.parse(data));
-            else
                 arr[b] = JSON.parse(data);
+            else
+                arr.push(JSON.parse(data));
         },
         load: async (uuid, cache) => {
             const arr = get_array(type);
@@ -120,6 +120,12 @@ const _CreateRecordIOLoader = (loader, memory, type, folder, ext = ".json") => {
             if (!loader.exists(root))
                 await loader.mkdir(root);
             const file = loader.join(root, uuid + ext);
+            if (!loader.exists(file)) {
+                const b = arr.findIndex(x => x.uuid == uuid);
+                if (b != -1)
+                    arr.splice(b, 1);
+                return "";
+            }
             const a = await loader.read_string(file);
             if (cache)
                 arr.push(JSON.parse(a));
@@ -143,7 +149,9 @@ const _CreateRecordIOLoader = (loader, memory, type, folder, ext = ".json") => {
             if (!loader.exists(root))
                 await loader.mkdir(root);
             const file = loader.join(root, uuid + ext);
-            await loader.rm(file);
+            if (loader.exists(file)) {
+                await loader.rm(file);
+            }
             const arr = get_array(type);
             const b = arr.findIndex(x => x.uuid == uuid);
             if (b != -1)

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

@@ -16,5 +16,6 @@ export declare class Project_Module {
     CloneJobs(uuids: Array<string>): Promise<Array<string>>;
     CascadeDeleteProject(uuid: string, bind: boolean): Promise<void>;
     CascadeDeleteTask(uuid: string): Promise<void>;
+    CascadeDeleteJob(uuid: string): Promise<void>;
     Delete_Database_Idle(uuid: string): Promise<void>;
 }

package/dist/server/module/project.js

@@ -124,6 +124,21 @@ class Project_Module {
         const ps = p.jobs_uuid.map(j_uuid => this.loader.job.delete(j_uuid));
         await Promise.all(ps);
         await this.loader.task.delete(uuid);
+        const ps2 = this.memory.projects.filter(x => x.tasks_uuid.includes(uuid)).map(x => x.uuid);
+        for (let u of ps2) {
+            const index = this.memory.projects.findIndex(x => x.uuid == u);
+            if (index != -1)
+                this.memory.projects.splice(index, 1);
+        }
+    }
+    async CascadeDeleteJob(uuid) {
+        await this.loader.job.delete(uuid);
+        const ps2 = this.memory.tasks.filter(x => x.jobs_uuid.includes(uuid)).map(x => x.uuid);
+        for (let u of ps2) {
+            const index = this.memory.tasks.findIndex(x => x.uuid == u);
+            if (index != -1)
+                this.memory.tasks.splice(index, 1);
+        }
     }
     async Delete_Database_Idle(uuid) {
         return this.loader.project.load_all().then(() => {

package/package.json

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

package/src/server/io.ts

@@ -188,8 +188,8 @@ export const _CreateRecordIOLoader = (loader:RecordIOBase, memory:MemoryData, ty
             await loader.write_string(file, data)
             const arr = get_array(type)
             const b = arr.findIndex(x => x.uuid == uuid)
-            if(b != -1) arr.push(JSON.parse(data))
-            else arr[b] = JSON.parse(data)
+            if(b != -1) arr[b] = JSON.parse(data)
+            else arr.push(JSON.parse(data))
         },
         load: async (uuid:string, cache: boolean):Promise<string> => {
             const arr:Array<any> = get_array(type)
@@ -200,6 +200,11 @@ export const _CreateRecordIOLoader = (loader:RecordIOBase, memory:MemoryData, ty
             const root = loader.join(loader.root, folder)
             if(!loader.exists(root)) await loader.mkdir(root)
             const file = loader.join(root, uuid + ext)
+            if(!loader.exists(file)){
+                const b = arr.findIndex(x => x.uuid == uuid)
+                if(b != -1) arr.splice(b, 1)
+                return ""
+            }
             const a = await loader.read_string(file)
             if(cache) arr.push(JSON.parse(a))
             return a
@@ -219,7 +224,9 @@ export const _CreateRecordIOLoader = (loader:RecordIOBase, memory:MemoryData, ty
             const root = loader.join(loader.root, folder)
             if(!loader.exists(root)) await loader.mkdir(root)
             const file = loader.join(root, uuid + ext)
-            await loader.rm(file)
+            if(loader.exists(file)){
+                await loader.rm(file)
+            }
             const arr = get_array(type)
             const b = arr.findIndex(x => x.uuid == uuid)
             if(b != -1) arr.splice(b, 1)

package/src/server/module/project.ts

@@ -158,13 +158,30 @@ export class Project_Module {
      * Delete Task related data and project itself
      * @param uuid Task UUID
      */
-    async  CascadeDeleteTask(uuid:string):Promise<void>{
+    async CascadeDeleteTask(uuid:string):Promise<void>{
         await this.loader.task.load(uuid, true)
         const p:Task = this.memory.tasks.find(p=> p.uuid == uuid)!
         if(!p) return
         const ps = p.jobs_uuid.map(j_uuid => this.loader.job.delete(j_uuid))
         await Promise.all(ps)
         await this.loader.task.delete(uuid)
+        const ps2 = this.memory.projects.filter(x => x.tasks_uuid.includes(uuid)).map(x => x.uuid)
+        for(let u of ps2){
+            const index = this.memory.projects.findIndex(x => x.uuid == u)
+            if(index != -1) this.memory.projects.splice(index, 1)
+        }
+    }
+    /**
+     * Delete Task related data and project itself
+     * @param uuid Task UUID
+     */
+    async CascadeDeleteJob(uuid:string):Promise<void>{
+        await this.loader.job.delete(uuid)
+        const ps2 = this.memory.tasks.filter(x => x.jobs_uuid.includes(uuid)).map(x => x.uuid)
+        for(let u of ps2){
+            const index = this.memory.tasks.findIndex(x => x.uuid == u)
+            if(index != -1) this.memory.tasks.splice(index, 1)
+        }
     }
     /**
      * Delete idle database

package/test/call/print.ts

@@ -0,0 +1,32 @@
+import { CreateRecordIOLoader, DATA_FOLDER, RecordIOBase, Server } from '../../src/index'
+import * as path from 'path'
+import * as os from 'os'
+import * as fs from "fs";
+import * as fsp from "fs/promises";
+
+const CreateIO = ():RecordIOBase => {
+    return {
+        root: path.join(os.homedir(), DATA_FOLDER),
+        join: path.join,
+        read_dir: (path:string) => fsp.readdir(path, { withFileTypes: false }),
+        read_dir_dir: (path:string) => fsp.readdir(path, { withFileTypes: true }).then(x => x.filter(y => !y.isFile()).map(y => y.name)),
+        read_dir_file: (path:string) => fsp.readdir(path, { withFileTypes: true }).then(x => x.filter(y => y.isFile()).map(y => y.name)),
+        read_string: (path:string, options?:any) => fsp.readFile(path, options).then(x => x.toString('utf-8')),
+        write_string: (path:string, content:string) => fsp.writeFile(path, content),
+        exists: (path:string) => fs.existsSync(path),
+        mkdir: async (path:string) => { await fsp.mkdir(path, {recursive: true}) },
+        rm: (path:string) => fsp.rm(path, {recursive: true}),
+        cp: (path:string, newpath:string) => fsp.cp(path, newpath)
+    }
+}
+
+async function main(){
+    const server:Server = new Server()
+    server.io = CreateIO()
+    server.loader = CreateRecordIOLoader(server.io, server.memory)
+
+    const p = await server.loader.task.load_all()
+    console.log(p.map(x => JSON.parse(x)))
+}
+
+main()