expressgy
/
graphResource2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

优化树和node与resource的引用关系

Browse Source
main
expressgy 10 months ago
parent eaeedc0080
commit c35880b91e
5 changed files with 214 additions and 103 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 2
      development.env.js
  2. 2
      package.json
  3. 2
      production.env.js
  4. 304
      src/cache/index.js
  5. 5
      src/common/database/dataModels/resourceEntityStruct.dataModel.js

2
development.env.js
Unescape View File

@ -14,7 +14,7 @@
import prodConfig from "#root/production.env.js";
const config = {
port: 3000,
port: 5000,
}
const devConfig = {...prodConfig, ...config}

2
package.json
Unescape View File

@ -22,7 +22,7 @@
"format": "prettier --write \"src/**/*.js\"",
"start": "cross-env NODE_ENV=production node bootstrap.js",
"start:dev": "cross-env NODE_ENV=development nodemon --unhandled-rejections=throw bootstrap.js",
"test:dev": "cross-env NODE_ENV=development node bootstrap.js",
"start:testDev": "cross-env NODE_ENV=development node bootstrap.js",
"genmodel": "cd gen-Model && sequelize-auto -h 127.0.0.1 -d lauch -u root -x root -p 3306"
},
"keywords": [],

2
production.env.js
Unescape View File

@ -14,7 +14,7 @@
const prodConfig = {
appName: 'graphResource2',
port: 3000,
port: 5000,
zip: true,
upfile:{
maxFileSize: 200 * 1024 * 1024,

304
src/cache/index.js vendored
Unescape View File

@ -236,9 +236,16 @@ async function makeResourceCache(sequelize) {
// @ RBP - Object - 描述：字典缓存池
const RBP = resourceCache.baseDictPool;
// ! 获取资源类信息 =============================================================================
console.time('获取资源类信息');
// region 获取资源类信息
const classList =
await sequelize.models.ResourceClassBase.findAll(sequelizeFindAllType);
const classList = await sequelize.models.ResourceClassBase.findAll({
...sequelizeFindAllType,
where: {
isDelete: {
[Op.is]: null,
},
},
});
// @ classIdList - Array[number] - 描述：资源类ID列表
const classIdList = [];
// @ classObject - Object[resourceClassBase] - 描述：资源类对象
@ -268,7 +275,9 @@ async function makeResourceCache(sequelize) {
// console.log(classIdList)
// console.log(classObject)
// endregion
console.timeEnd('获取资源类信息');
// ! 获取拓展字段信息 ===========================================================================
console.time('获取拓展字段信息');
// region 获取拓展字段信息
const classExpandList =
await sequelize.models.ResourceClassExpandField.findAll(
@ -278,8 +287,8 @@ async function makeResourceCache(sequelize) {
const classExpandIdList = [];
// @ classExpandObject - Object[resourceClassExpandField] - 描述：资源类拓展字段对象
const classExpandObject = {};
// @ classExpandForClassIdObject - Object - 描述：基于资源类ID的资源拓展字段对象集合
const classExpandForClassIdObject = {};
// @ classExpandForClassBaseObject - Object - 描述：基于资源类ID的资源拓展字段对象集合
const classExpandForClassBaseObject = {};
for (let i = 0; i < classExpandList.length; i++) {
const expandField = classExpandList[i];
if (expandField.isDelete) {
@ -306,19 +315,21 @@ async function makeResourceCache(sequelize) {
classExpandObject[expandFieldId] = expandField;
// 拓展字段中的资源类ID
const classId = expandField.resourceClassBase;
if (classExpandForClassIdObject[classId] === undefined) {
classExpandForClassIdObject[classId] = {
if (classExpandForClassBaseObject[classId] === undefined) {
classExpandForClassBaseObject[classId] = {
[expandField.resourceClassExpandFieldIdentify]: expandField,
};
} else {
classExpandForClassIdObject[classId][
classExpandForClassBaseObject[classId][
expandField.resourceClassExpandFieldIdentify
] = expandField;
}
}
// console.log(classExpandForClassIdObject)
// console.log(classExpandForClassBaseObject)
// endregion
console.timeEnd('获取拓展字段信息');
// ! 获取实体结构表 =============================================================================
console.time('获取实体结构表');
// region 获取实体结构表
const entityStructList =
await sequelize.models.ResourceEntityStruct.findAll(
@ -356,7 +367,9 @@ async function makeResourceCache(sequelize) {
}
}
// endregion
console.timeEnd('获取实体结构表');
// ! 获取资源类关系表 ===========================================================================
console.time('获取资源类关系表');
// region 获取资源类关系表
const classRelationList =
await sequelize.models.ResourceClassRelation.findAll(
@ -381,67 +394,54 @@ async function makeResourceCache(sequelize) {
}
}
// endregion
console.timeEnd('获取资源类关系表');
// | 这里生成基础数据模型 =============================================================================================
console.time('==生成资源类基础数据模型==');
// region 这里生成基础数据模型
class makeClass {
// 基础数据
classId;
classIdentify;
atomModel;
className;
classBase;
classExpand;
entityStruct;
sequelizeModel;
// ! 资源类
class ClassModel {
constructor(classItem) {
// 设置基础信息值
const classId = classItem.resourceClassBaseId;
this.classId = classId;
const classIdentify = classItem.resourceClassBaseIdentify;
this.classIdentify = classIdentify;
const atomModel = classItem.atomModel;
this.atomModel = atomModel;
const className = classItem.resourceClassBaseName;
this.className = className;
this.classBase = classItem;
this.classExpand = classExpandForClassIdObject[classId];
if (this.classExpand === undefined) {
this.classExpand = {};
}
this.entityStruct = entityStructForClassBaseObject[classId];
if (this.entityStruct === undefined) {
this.entityStruct = {};
}
this.classRelationList = classRelationObjectForTargetClass[classId];
if (this.classRelationList == undefined) {
this.classRelationList = [];
}
this.#createCLassRelationIdentify();
this.#createSequelizeModel();
this.resourceClass = classItem;
}
get classId() {
return this.classId;
return this.resourceClass.resourceClassBaseId;
}
get classIdentify() {
return this.classIdentify;
return this.resourceClass.resourceClassBaseIdentify;
}
get atomModel() {
return this.atomModel;
return this.resourceClass.atomModel;
}
get className() {
return this.className;
}
get classBase() {
return this.classBase;
return this.resourceClass.resourceClassBaseName;
}
get classExpand() {
return this.classExpand;
let classExpand = classExpandForClassBaseObject[this.classId];
if (classExpand === undefined) {
classExpand = {};
}
return classExpand;
}
get entityStruct() {
return this.entityStruct;
let entityStruct = entityStructForClassBaseObject[this.classId];
if (entityStruct === undefined) {
entityStruct = {};
}
return entityStruct;
}
get classRelationList() {
if (classRelationObjectForTargetClass[this.classId] === undefined) {
return [];
} else {
return classRelationObjectForTargetClass[this.classId];
}
#createSequelizeModel() {
}
get classRelationIdList() {
return this.classRelationList.map((i) => i.resourceClassRelationId);
}
async createSequelizeModel() {
class resourceEntity extends Model {}
// 定义资源实体名称字段
const entityName = {
@ -449,12 +449,13 @@ async function makeResourceCache(sequelize) {
allowNull: false,
comment: '资源实体名称',
};
const entityStruct = this.entityStruct;
// 定义资源实体名称字段在数据库的备注
if (this.entityStruct.entityName !== undefined) {
if (entityStruct.entityName !== undefined) {
entityName.comment =
this.entityStruct.entityName.resourceEntityStructName +
entityStruct.entityName.resourceEntityStructName +
'-' +
this.entityStruct.entityName.resourceEntityStructDescribe;
entityStruct.entityName.resourceEntityStructDescribe;
}
// 定义字段
const defineField = {
@ -543,18 +544,21 @@ async function makeResourceCache(sequelize) {
}
resourceEntity.init(defineField, defineTable);
// 同步数据库
resourceEntity.sync(); // {alter: true}是修改，现在是如果存在就不更改表，后面修改表明，字段名，字段长度会在更新操作时添加
await resourceEntity.sync(); // {alter: true}是修改，现在是如果存在就不更改表，后面修改表明，字段名，字段长度会在更新操作时添加
this.sequelizeModel = resourceEntity;
}
#createCLassRelationIdentify() {
this.relationIdList = [];
if (this.classRelationList.length != 0) {
for (let classRelationItem of this.classRelationList) {
this.relationIdList.push(
classRelationItem.resourceClassRelationId,
);
get zeroInfo(){
return {
resourceClassBaseId: this.resourceClass.resourceClassBaseId,
resourceClassBaseName: this.resourceClass.resourceClassBaseName,
}
}
get info(){
return{
...this.resourceClass,
resourceClassExpandField: this.classExpand,
resourceEntityStruct: this.entityStruct,
resourceClassRelation: this.classRelationList
}
}
}
@ -565,9 +569,11 @@ async function makeResourceCache(sequelize) {
// 排除删除的
continue;
}
classModelObject[classId] = new makeClass(classObject[classId]);
classModelObject[classId] = new ClassModel(classObject[classId]);
console.time(' 初始化资源实体表'+ classModelObject[classId].classIdentify)
await classModelObject[classId].createSequelizeModel();
console.timeEnd(' 初始化资源实体表'+ classModelObject[classId].classIdentify)
}
// console.log(classModelObject)
// console.log((await sequelize.models.omencust.create({
// entityId: 'omencust' + crypto.randomUUID(),
// originNode: '0-0-1',
@ -577,64 +583,135 @@ async function makeResourceCache(sequelize) {
// project: '1'
// })).dataValues)
// endregion
console.timeEnd('==生成资源类基础数据模型==');
// | 这里生成关系节点数据模型 ==========================================================================================
console.time('==生成类关系节点数据模型==');
// region 这里生成关系节点数据模型
// 给每个类生成关联列表
// @ classNodeObject - Object - 描述：类关系节点数据模型集合
const classNodeObject = {
0: {
classModel:{},
nodeId:0,
children:[],
father: null
}
classModel: {},
nodeId: 0,
children: [],
father: null,
},
};
class makeClassNode {
// ! 资源类节点
class ClassNodeModel {
constructor(classModel, classRelationId) {
this.classModel = classModel;
this.children = []
this.nodeId =classRelationId;
this.father = classRelationObject[classRelationId].resourceClassRelationFather
this.nodeId = classRelationId;
this.fatherId =
classRelationObject[
classRelationId
].resourceClassRelationFather;
this.children = [];
this.classData = classModel;
}
get classId() {
return this.classData.classId;
}
get classIdentify() {
return this.classData.classIdentify;
}
get atomModel() {
return this.classData.atomModel;
}
get className() {
return this.classData.className;
}
get classExpand() {
return this.classData.classExpand;
}
get entityStruct() {
return this.classData.entityStruct;
}
get classRelationList() {
return this.classData.classRelationList;
}
get classRelationIdList() {
return this.classData.classRelationIdList;
}
get nodeZeroInfo(){
return {
...this.classData.zeroInfo,
nodeId: this.nodeId,
fatherId: this.fatherId,
children: this.children.map(i => i.nodeZeroInfo)
}
}
}
// @ 生成类关系节点
for (let classId of Object.keys(classModelObject)) {
const classModel = classModelObject[classId];
const relationIdList = classModel.relationIdList
if(relationIdList.length == 0){
const nowClassModel = classModelObject[classId];
const nowRelationIdList = nowClassModel.classRelationIdList;
if (nowRelationIdList.length == 0) {
// @ 在数据库添加这条关系
const newClassRelation = await sequelize.models.ResourceClassRelation.create({
const newClassRelation =
await sequelize.models.ResourceClassRelation.create({
resourceClassRelationFather: 0,
resourceClassRelationTarget: classId
})
resourceClassRelationTarget: classId,
});
const newClassRelationData = newClassRelation.dataValues;
const newClassRelationDataId = newClassRelationData.resourceClassRelationId
classRelationIdList.push(newClassRelationData)
classRelationObject[newClassRelationDataId] = newClassRelationData
classRelationObjectForTargetClass[classId] = newClassRelationData
relationIdList.push(newClassRelationDataId)
classNodeObject[newClassRelationDataId] = new makeClassNode(
classModel,
const newClassRelationDataId =
newClassRelationData.resourceClassRelationId;
classRelationIdList.push(newClassRelationData);
classRelationObject[newClassRelationDataId] = newClassRelationData;
classRelationObjectForTargetClass[classId] = [newClassRelationData];
classNodeObject[newClassRelationDataId] = new ClassNodeModel(
nowClassModel,
newClassRelationDataId,
);
}
for(let i = 0; i< relationIdList.length; i++){
const classRelationId = relationIdList[i];
classNodeObject[classRelationId] = new makeClassNode(
classModel,
for (let i = 0; i < nowRelationIdList.length; i++) {
const classRelationId = nowRelationIdList[i];
classNodeObject[classRelationId] = new ClassNodeModel(
nowClassModel,
classRelationId,
);
}
}
};
// @ 构建类关系
for(let i = 0; i < classRelationIdList.length; i++){
for (let i = 0; i < classRelationIdList.length; i++) {
const nodeId = classRelationIdList[i].resourceClassRelationId;
const classNode = classNodeObject[nodeId]
const fatherId = classNodeObject[nodeId].father
classNodeObject[fatherId].children.push(classNode)
}
console.log(classNodeObject)
const classNode = classNodeObject[nodeId];
const fatherId = classNodeObject[nodeId].fatherId;
classNodeObject[fatherId].children.push(classNode);
}
// console.log(classNodeObject)
// @ 根据关联元/模型分类资源类节点
// @ classNodeObjectForAtomModel - String - 描述：关联元/模型下的根节点
const classNodeObjectForAtomModel = {};
// 根据元分类/模型创建根节点的空数组
for (let i = 0; i < RAP.normalData.length; i++) {
classNodeObjectForAtomModel[RAP.normalData[i].atomModelId] = [];
}
// 将根节点放入 分类/模型创建根节点的空数组 中
for (let i = 0; i < classNodeObject[0].children.length; i++) {
const nodeModel = classNodeObject[0].children[i];
const atomModelId = nodeModel.atomModel;
if (classNodeObjectForAtomModel[atomModelId] === undefined) {
logger.warn('存在未找到元分类/模型的资源类:' + nodeModel.classId);
} else {
classNodeObjectForAtomModel[atomModelId].push(nodeModel);
}
}
// console.time('GET TREE')
// global.test = classNodeObjectForAtomModel[1][0].nodeZeroInfo
// console.timeEnd('GET TREE')
// console.time('GET TREE JSON')
// global.test2 = JSON.stringify(global.test, null, 3)
// console.timeEnd('GET TREE JSON')
// console.time('GET TREE JSON CONSOLE')
// console.log(global.test)
// console.timeEnd('GET TREE JSON CONSOLE')
console.timeEnd('==生成类关系节点数据模型==');
// endregion
// ! 获取资源实体 ===============================================================================
console.time('获取资源实体');
// region 获取资源实体
// @ entityListForClassId - Object[Array[Object[entity]]] - 描述：实体列表根据资源类ID区分的对象
const entityListForClassId = {};
@ -644,6 +721,7 @@ async function makeResourceCache(sequelize) {
const classModel = classModelObject[i];
const classId = classModel.classId;
const classIdentify = classModel.classIdentify;
console.time(' 获取资源实体表信息' + classModel.classIdentify);
const entityList = await classModel.sequelizeModel.findAll({
...sequelizeFindAllType,
where: {
@ -652,9 +730,37 @@ async function makeResourceCache(sequelize) {
},
},
});
console.timeEnd(' 获取资源实体表信息' + classModel.classIdentify);
entityListForClassId[classId] = entityList;
entityListForClassIdentify[classIdentify] = entityList;
}
// endregion
console.timeEnd('获取资源实体');
// ! 获取资源实体关系
return {
createtime: new Date().getTime(),
updatetime: new Date().getTime(),
// 资源类
classList,
classIdList,
classObject,
// 资源类拓展字段
classExpandList,
classExpandIdList,
classExpandObject,
classExpandForClassBaseObject,
// 资源实体结构
entityStructList,
entityStructIdList,
entityStructObject,
entityStructForClassBaseObject,
// 资源类模型
ClassModel,
classModelObject,
// 资源类节点模型
classNodeObject,
ClassNodeModel,
classNodeObjectForAtomModel,
}
}

5
src/common/database/dataModels/resourceEntityStruct.dataModel.js
Unescape View File

@ -78,6 +78,11 @@ export function mountResourceEntityStruct(sequelize, DataTypes) {
comment: '资源实体字段是否采集（0是采集、1是不采集）',
defaultValue: 0,
},
resourceEntityStructIsRequired: {
type: DataTypes.BOOLEAN,
allowNull: true,
comment: "是否必填"
},
resourceEntityStructAppIsShow:{
type: DataTypes.BOOLEAN,
allowNull: false,

Write Preview
Loading…
Cancel
Save