添加资源类OK了

src/cache/index.js

@@ -246,6 +246,11 @@ async function makeResourceCache(sequelize) {
             },
         },
     });
+    // @ classListForAtomModel - String - 描述：按照元分类/模型ID区分资源类
+    const classListForAtomModel = {};
+    for(let atomModel of RAP.normalData){
+        classListForAtomModel[atomModel.atomModelId] = []
+    }
     // @ classIdList - Array[number] - 描述：资源类ID列表
     const classIdList = [];
     // @ classObject - Object[resourceClassBase] - 描述：资源类对象
@@ -271,6 +276,10 @@ async function makeResourceCache(sequelize) {
             1: '虚拟资源类',
             2: '层级管理资源类',
         }[classItem.resourceClassBaseType];
+        if(classListForAtomModel[classItem.atomModel] === undefined){
+            classListForAtomModel[classItem.atomModel] = []
+        }
+        classListForAtomModel[classItem.atomModel].push(classItem)
     }
     // console.log(classIdList)
     // console.log(classObject)
@@ -551,6 +560,8 @@ async function makeResourceCache(sequelize) {
             return {
                 resourceClassBaseId: this.resourceClass.resourceClassBaseId,
                 resourceClassBaseName: this.resourceClass.resourceClassBaseName,
+                resourceClassBaseColor: this.resourceClass.resourceClassBaseColor,
+                resourceClassBaseAvatar: this.resourceClass.resourceClassBaseAvatar,
             }
         }
         get info(){
@@ -656,7 +667,8 @@ async function makeResourceCache(sequelize) {
             const newClassRelationData = newClassRelation.dataValues;
             const newClassRelationDataId =
                 newClassRelationData.resourceClassRelationId;
-            classRelationIdList.push(newClassRelationData);
+            classRelationList.push(newClassRelationData)
+            classRelationIdList.push(newClassRelationDataId);
             classRelationObject[newClassRelationDataId] = newClassRelationData;
             classRelationObjectForTargetClass[classId] = [newClassRelationData];
             classNodeObject[newClassRelationDataId] = new ClassNodeModel(
@@ -709,7 +721,6 @@ async function makeResourceCache(sequelize) {
     console.timeEnd('==生成类关系节点数据模型==');
     // endregion
 
-
     // ! 获取资源实体 ===============================================================================
     console.time('获取资源实体');
     // region 获取资源实体
@@ -745,6 +756,7 @@ async function makeResourceCache(sequelize) {
         classList,
         classIdList,
         classObject,
+        classListForAtomModel,
         // 资源类拓展字段
         classExpandList,
         classExpandIdList,
@@ -755,6 +767,11 @@ async function makeResourceCache(sequelize) {
         entityStructIdList,
         entityStructObject,
         entityStructForClassBaseObject,
+        // 资源类关系
+        classRelationList,
+        classRelationIdList,
+        classRelationObject,
+        classRelationObjectForTargetClass,
         // 资源类模型
         ClassModel,
         classModelObject,

src/common/tools/getArrayPage.js

@@ -12,6 +12,9 @@
 // | ------------------------------------------------------------
 
 export default function getPage(array, pageSize, pageNumber){
+    if(!Array.isArray(array)){
+        return []
+    }
     const startIndex = (pageNumber - 1) * pageSize;
 
     // 使用 slice() 方法获取分页内容

src/routes/graphResource2/resourceClass/index.dto.js

@@ -237,13 +237,13 @@ export function CreateResourceClassItemDTO(data) {
                     minLength: '资源类图标长度过短',
                 },
             },
-            resourceClassBaseFather: {
+            resourceClassRelationId: {
                 type: ['integer'],
                 minimum: 0,
                 default: 0,
                 errorMessage: {
-                    type: '父资源类必须是整数',
+                    type: '父资源类节点ID必须是整数',
-                    minimum: '父资源类是一个正整数',
+                    minimum: '父资源类节点ID是一个正整数',
                 },
             },
         },

src/routes/graphResource2/resourceClass/index.js

@@ -10,128 +10,342 @@
 // | -*-*-*-  (时间--修改人--修改说明)  -*-*-*-
 // | =
 // | ------------------------------------------------------------
-import Router from "koa-router";
+import Router from 'koa-router';
 import {
     CreateResourceClassExpandFieldItemDTO,
     CreateResourceClassItemDTO,
-    CreateResourceClassRelationDTO, DeleteResourceClassExpandFieldItemDTO, DeleteResourceClassItemDTO,
+    CreateResourceClassRelationDTO,
-    DeleteResourceClassRelationDTO, EditResourceClassExpandFieldItemDTO, EditResourceClassItemDTO,
+    DeleteResourceClassExpandFieldItemDTO,
+    DeleteResourceClassItemDTO,
+    DeleteResourceClassRelationDTO,
+    EditResourceClassExpandFieldItemDTO,
+    EditResourceClassItemDTO,
     GetResourceClassCompleteInfoDTO,
     GetResourceClassListDTO,
     GetResourceClassPageDTO,
-    GetResourceClassTreeDTO
+    GetResourceClassTreeDTO,
-} from "#routes/graphResource2/resourceClass/index.dto.js";
+} from '#routes/graphResource2/resourceClass/index.dto.js';
+import getPage from '#common/tools/getArrayPage.js';
+import getNoSpacesStr from '#common/tools/getNoSpacesStr.js';
 
-const resourceClass = new Router()
+const resourceClass = new Router();
 
 // @ 获取资源类列表
 resourceClass.get('/getResourceClassList', async (ctx, next) => {
-    const verif = GetResourceClassListDTO(ctx.query)
+    const verif = GetResourceClassListDTO(ctx.query);
     if (!verif.status) {
         return ctx.throw(400, { e: verif.error.map((i) => i.message) });
     }
-    ctx.body = 1
+    const RAP = resourceCache.atomModelPool;
-})
+    const { searchData, atomModelId } = ctx.query;
+    if (!RAP.normalData.some((i) => i.atomModelId == atomModelId)) {
+        return ctx.throw(400, { e: '不存在该元分类/模型' });
+    }
+    const RRP = resourceCache.resourcePool;
+    const classListForAtomModel = RRP.classListForAtomModel[atomModelId].map(
+        (i) => ({
+            resourceClassBaseId: i.resourceClassBaseId,
+            resourceClassBaseName: i.resourceClassBaseName,
+            resourceClassBaseIdentify: i.resourceClassBaseIdentify,
+            resourceClassBaseColor: i.resourceClassBaseColor,
+            resourceClassBaseAvatar: i.resourceClassBaseAvatar,
+        }),
+    );
+    ctx.body = classListForAtomModel;
+    if (searchData) {
+        ctx.body = classListForAtomModel.filter((i) =>
+            i.resourceClassBaseName.includes(searchData.trim()),
+        );
+    }
+});
 
 // @ 获取资源类分页
 resourceClass.get('/getResourceClassPage', async (ctx, next) => {
-    const verif = GetResourceClassPageDTO(ctx.query)
+    const verif = GetResourceClassPageDTO(ctx.query);
     if (!verif.status) {
         return ctx.throw(400, { e: verif.error.map((i) => i.message) });
     }
-    ctx.body = 2
+    const RAP = resourceCache.atomModelPool;
-})
+    const { searchData, atomModelId, pageSize, pageNum } = ctx.query;
+    if (!RAP.normalData.some((i) => i.atomModelId == atomModelId)) {
+        return ctx.throw(400, { e: '不存在该元分类/模型' });
+    }
+    const RRP = resourceCache.resourcePool;
+    let classListForAtomModel = RRP.classListForAtomModel[atomModelId];
+    if (searchData) {
+        classListForAtomModel = classListForAtomModel.filter((i) =>
+            i.resourceClassBaseName.includes(searchData.trim()),
+        );
+    }
+    const pageList = getPage(classListForAtomModel, pageSize, pageNum);
+    ctx.body = {
+        total: classListForAtomModel.length,
+        data: classListForAtomModel,
+    };
+});
 
 // @ 获取资源类树
 resourceClass.get('/getResourceClassTree', async (ctx, next) => {
-    const verif = GetResourceClassTreeDTO(ctx.query)
+    const verif = GetResourceClassTreeDTO(ctx.query);
     if (!verif.status) {
         return ctx.throw(400, { e: verif.error.map((i) => i.message) });
     }
-    ctx.body = 3
+    const RAP = resourceCache.atomModelPool;
-})
+    const { searchData, atomModelId } = ctx.query;
-
+    if (!RAP.normalData.some((i) => i.atomModelId == atomModelId)) {
+        return ctx.throw(400, { e: '不存在该元分类/模型' });
+    }
+    const RRP = resourceCache.resourcePool;
+    ctx.body = RRP.classNodeObjectForAtomModel[atomModelId].map(
+        (i) => i.nodeZeroInfo,
+    );
+});
 
 // @ 添加资源类
 resourceClass.post('/createResourceClassItem', async (ctx, next) => {
-    const verif = CreateResourceClassItemDTO(ctx.request.body)
+    const verif = CreateResourceClassItemDTO(ctx.request.body);
     if (!verif.status) {
         return ctx.throw(400, { e: verif.error.map((i) => i.message) });
     }
-    ctx.body = 4
+    const {
-})
+        atomModelId,
+        resourceClassBaseName,
+        resourceClassBaseDescribe,
+        resourceClassBaseIdentify,
+        resourceClassBaseAvatar,
+        resourceClassBaseDefine,
+        resourceClassBaseColor,
+        resourceClassRelationId,
+        resourceClassBaseType,
+    } = ctx.request.body;
+    const RAP = resourceCache.atomModelPool;
+    const RRP = resourceCache.resourcePool;
+    // @ 判断是否存在元分类/模型
+    if (!RAP.normalData.some((i) => i.atomModelId == atomModelId)) {
+        return ctx.throw(400, { e: '不存在目标元分类/模型' });
+    }
+    // @ 判断是否重名
+    if (
+        RRP.classListForAtomModel[atomModelId].some(
+            (i) =>
+                i.resourceClassBaseName ==
+                getNoSpacesStr(resourceClassBaseName),
+        )
+    ) {
+        return ctx.throw(400, { e: '资源类在目标元分类/模型已存在' });
+    }
+    // @ 判断是否已存在资源类标识
+    if (
+        RRP.classList.some(
+            (i) =>
+                i.resourceClassBaseIdentify ==
+                getNoSpacesStr(resourceClassBaseIdentify).toUpperCase(),
+        )
+    ) {
+        return ctx.throw(400, { e: '资源类标识已存在' });
+    }
+    // @ 判断是否存在父节点
+    if(resourceClassRelationId != 0){
+        if(RRP.classRelationObject[resourceClassRelationId] == undefined){
+            return ctx.throw(400, { e: '不存在目标资源类树节点' });
+        }
+        if(!RRP.classListForAtomModel[atomModelId].some(i => i.resourceClassBaseId == RRP.classRelationObject[resourceClassRelationId].resourceClassRelationTarget)){
+            return ctx.throw(400, { e: '目标资源类树节点不存在于目标元分类/模型中' });
+        }
+    }
+
+
+    // 写入资源类
+    const newClassItem = await ctx.sequelize.models.ResourceClassBase.create({
+        atomModel: atomModelId,
+        resourceClassBaseName: getNoSpacesStr(resourceClassBaseName),
+        resourceClassBaseDescribe,
+        resourceClassBaseIdentify: getNoSpacesStr(
+            resourceClassBaseIdentify,
+        ).toUpperCase(),
+        resourceClassBaseAvatar,
+        resourceClassBaseDefine,
+        resourceClassBaseColor,
+        resourceClassBaseType,
+    });
+    const newClassData = newClassItem.dataValues;
+    const classId = newClassData.resourceClassBaseId;
+    // | 建立缓存
+    // @ 资源类基础信息
+    // ! 写入classList
+    RRP.classList.push(newClassData);
+    // ! 写入classListForAtomModel
+    if (RRP.classListForAtomModel[atomModelId] === undefined) {
+        RRP.classListForAtomModel[atomModelId] = [];
+    }
+    RRP.classListForAtomModel[atomModelId].push(newClassData);
+    // ! 写入classIdList
+    RRP.classIdList.push(classId);
+    // ! 写入classObject
+    RRP.classObject[classId] = newClassData;
+
+    // @ 资源类拓展字段信息
+    // ! 写入classExpandForClassBaseObject
+    RRP.classExpandForClassBaseObject[classId] = {};
+
+    // @ 资源实体结构表
+    // ! 写入entityStructForClassBaseObject
+    RRP.entityStructForClassBaseObject[classId] = {};
+
+    // @ 资源类关系
+    // ! 写入classRelationObjectForTargetClass
+    RRP.classRelationObjectForTargetClass[classId] = [];
+    // @ 获取目标资源关系节点的资源类ID
+    const fatherClassId = resourceClassRelationId == 0 ? 0 :
+        RRP.classRelationObject[resourceClassRelationId]
+            .resourceClassRelationTarget;
+    // 在数据库添加这条关系
+    const newClassRelation =
+        await ctx.sequelize.models.ResourceClassRelation.create({
+            resourceClassRelationFather: fatherClassId,
+            resourceClassRelationTarget: classId,
+        });
+    const newClassRelationData = newClassRelation.dataValues;
+    const newRelationId = newClassRelationData.resourceClassRelationId;
+
+    RRP.classRelationList.push(newClassRelationData);
+    RRP.classRelationIdList.push(newRelationId);
+    RRP.classRelationObject[newRelationId] = newClassRelationData;
+    RRP.classRelationObjectForTargetClass[classId].push(newClassRelationData);
+
+    // @ 资源类数据模型对象集合
+    // ! 写入classModelObject
+    RRP.classModelObject[classId] = new RRP.ClassModel(
+        RRP.classObject[classId],
+    );
+    await RRP.classModelObject[
+        newClassData.resourceClassBaseId
+    ].createSequelizeModel();
+
+    // @ 关系节点数据模型
+    // ! 这里生成关系节点数据模型
+    // 拿到当前资源类模型
+    const nowClassModel = RRP.classModelObject[classId];
+    // 获取当前资源类模型的关联列表
+    const nowRelationList = nowClassModel.classRelationList;
+    // 拿到父节点和节点ID
+    const nodeId = nowRelationList[0].resourceClassRelationId;
+    const classNode = new RRP.ClassNodeModel(
+        nowClassModel,
+        nodeId,
+    );
+    RRP.classNodeObject[nodeId] = classNode
+    RRP.classNodeObject[resourceClassRelationId].children.push(classNode);
+
+    if(resourceClassRelationId == 0){
+        RRP.classNodeObjectForAtomModel[atomModelId].push(classNode)
+    }
+
+    ctx.body = {
+        message: '创建资源类成功',
+        data: {
+            resourceClassBase: newClassData,
+            resourceClassRelation: newClassRelationData
+        }
+    };
+});
 
 // @ 编辑资源类
 resourceClass.post('/editResourceClassItem', async (ctx, next) => {
-    const verif = EditResourceClassItemDTO(ctx.request.body)
+    const verif = EditResourceClassItemDTO(ctx.request.body);
     if (!verif.status) {
         return ctx.throw(400, { e: verif.error.map((i) => i.message) });
     }
-    ctx.body = 5
+    ctx.body = 5;
-})
+});
 
 // @ 删除资源类
 resourceClass.delete('/deleteResourceClassItem', async (ctx, next) => {
-    const verif = DeleteResourceClassItemDTO(ctx.query)
+    const verif = DeleteResourceClassItemDTO(ctx.query);
     if (!verif.status) {
         return ctx.throw(400, { e: verif.error.map((i) => i.message) });
     }
-    ctx.body = 6
+    ctx.body = 6;
-})
+});
 
 // @ 创建资源类关联
 resourceClass.post('/createResourceClassRelation', async (ctx, next) => {
-    const verif = CreateResourceClassRelationDTO(ctx.request.body)
+    const verif = CreateResourceClassRelationDTO(ctx.request.body);
     if (!verif.status) {
         return ctx.throw(400, { e: verif.error.map((i) => i.message) });
     }
-    ctx.body = 7
+    ctx.body = 7;
-})
+});
 
 // @ 删除资源类关联
 resourceClass.delete('/deleteResourceClassRelation', async (ctx, next) => {
-    const verif = DeleteResourceClassRelationDTO(ctx.query)
+    const verif = DeleteResourceClassRelationDTO(ctx.query);
     if (!verif.status) {
         return ctx.throw(400, { e: verif.error.map((i) => i.message) });
     }
-    ctx.body = 8
+    ctx.body = 8;
-})
+});
 
 // @ 获取资源类完整信息
 resourceClass.get('/getResourceClassCompleteInfo', async (ctx, next) => {
-    const verif = GetResourceClassCompleteInfoDTO(ctx.query)
+    const verif = GetResourceClassCompleteInfoDTO(ctx.query);
     if (!verif.status) {
         return ctx.throw(400, { e: verif.error.map((i) => i.message) });
     }
-    ctx.body = 9
+    const { resourceClassBaseId, resourceClassBaseIdentify } = ctx.query;
-})
+    const RRP = resourceCache.resourcePool;
+    let classId;
+    if (resourceClassBaseIdentify) {
+        RRP.classIdList.find((i) => {
+            if (
+                RRP.classModelObject[i].classIdentify ==
+                resourceClassBaseIdentify
+            ) {
+                classId = i.classId;
+            }
+        });
+        if (!classId) {
+            return ctx.throw(400, { e: '未找到该资源类' });
+        }
+    }
+    if (resourceClassBaseId) {
+        if (RRP.classIdList.includes(resourceClassBaseId)) {
+            classId = resourceClassBaseId;
+        } else {
+            return ctx.throw(400, { e: '未找到该资源类' });
+        }
+    }
+    ctx.body = RRP.classModelObject[classId].info;
+});
 
 // @ 创建资源类拓展字段
 resourceClass.post('/createResourceClassExpandFieldItem', async (ctx, next) => {
-    const verif = CreateResourceClassExpandFieldItemDTO(ctx.request.body)
+    const verif = CreateResourceClassExpandFieldItemDTO(ctx.request.body);
     if (!verif.status) {
         return ctx.throw(400, { e: verif.error.map((i) => i.message) });
     }
-    ctx.body = 10
+    ctx.body = 10;
-})
+});
 
 // @ 编辑资源类拓展字段
 resourceClass.post('/editResourceClassExpandFieldItem', async (ctx, next) => {
-    const verif = EditResourceClassExpandFieldItemDTO(ctx.request.body)
+    const verif = EditResourceClassExpandFieldItemDTO(ctx.request.body);
     if (!verif.status) {
         return ctx.throw(400, { e: verif.error.map((i) => i.message) });
     }
-    ctx.body = 11
+    ctx.body = 11;
-})
+});
 
 // @ 删除资源类拓展字段
-resourceClass.delete('/deleteResourceClassExpandFieldItem', async (ctx, next) => {
+resourceClass.delete(
-    const verif = DeleteResourceClassExpandFieldItemDTO(ctx.query)
+    '/deleteResourceClassExpandFieldItem',
-    if (!verif.status) {
+    async (ctx, next) => {
-        return ctx.throw(400, { e: verif.error.map((i) => i.message) });
+        const verif = DeleteResourceClassExpandFieldItemDTO(ctx.query);
-    }
+        if (!verif.status) {
-    ctx.body = 12
+            return ctx.throw(400, { e: verif.error.map((i) => i.message) });
-})
+        }
-
+        ctx.body = 12;
+    },
+);
 
-export default resourceClass
+export default resourceClass;