github/Teamlinker
7
0
Fork 0
mirror of https://github.com/Teamlinker/Teamlinker.git synced 2025-06-03 03:00:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

add

Browse Source
This commit is contained in:
sx1989827 2022-03-16 08:23:12 +08:00
parent 853c271f54
commit 426d36924f
9 changed files with 339 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
code/common/routes/field.ts
View File

@ -109,6 +109,15 @@ const api={
res: <ICommon_Route_Res_FieldSolution_ListWorkflowNodeField[]>{},
permission:[Permission_Types.Admin.ADMIN]
},
workflowNodeFieldInfo:{
method:ECommon_HttpApi_Method.GET,
path:"/solution/field/item",
req: <{
fieldSolutionWorkflowNodeFieldTypeId: string
}>{},
res: <ICommon_Route_Res_FieldSolution_ListWorkflowNodeField>{},
permission:[Permission_Types.Admin.ADMIN]
},
addWorkflowNodeField:{
method:ECommon_HttpApi_Method.POST,
path:"/solution/field/item",
@ -122,12 +131,21 @@ const api={
workflowId: string,
workflowSolutionId: string,
description?: string,
lable_type?:ECommon_Model_Field_Solution_Workflow_Node_Field_Type_Label_Type,
weight?:number
}>{},
res: <ICommon_Model_Field_Solution_Workflow_Node_Field_Type>{},
permission:[Permission_Types.Admin.ADMIN]
},
editWorkflowNodeFieldLabelType:{
method:ECommon_HttpApi_Method.PUT,
path:"/solution/field/item/label",
req: <{
fieldSolutionWorkflowNodeFieldTypeId: string,
labelType:ECommon_Model_Field_Solution_Workflow_Node_Field_Type_Label_Type
}>{},
res: {},
permission:[Permission_Types.Admin.ADMIN]
},
editWorkflowNodeField:{
method:ECommon_HttpApi_Method.PUT,
path:"/solution/field/item",
@ -176,11 +194,13 @@ const api={
path:"/solution/field/config/item",
req: <{
fieldSolutionWorkflowNodeFieldTypeId :string,
value :string,
name :string,
selected :number,
data:{
value :string,
name :string,
selected :number
}[]
}>{},
res: <ICommon_Model_Field_Type_Config_Value>{},
res: <ICommon_Model_Field_Type_Config_Value[]>{},
permission:[Permission_Types.Admin.ADMIN]
},
editWorkflowNodeFieldConfig:{
@ -216,6 +236,26 @@ const api={
}>{},
res:{},
permission:[Permission_Types.Admin.ADMIN]
},
workflowCanCopyedList:{
method:ECommon_HttpApi_Method.GET,
path:"/solution/workflow/copy/list",
req:<{
fieldSolutionId:string,
workflowSolutionId:string,
workflowId:string
}>{},
res:<{
workflowSolution:{
id:string,
name:string
},
fieldSolution:{
id:string,
name:string
}
}[]>{},
permission:[Permission_Types.Admin.ADMIN]
}
}
}

8
code/common/routes/response.ts
View File

@ -128,13 +128,7 @@ export interface ICommon_Route_Res_WorkflowSolution_Info extends ICommon_Model_W
}
export interface ICommon_Route_Res_FieldSolution_Info extends ICommon_Model_Field_Solution {
data:{
workflowSolution:ICommon_Model_Workflow_Solution,
data:{
workflow:ICommon_Model_Workflow,
node:ICommon_Route_Res_Workflow_Info_Node
}[]
}[]
workflowSolutionList:ICommon_Model_Workflow_Solution[]
}
export interface ICommon_Route_Res_FieldSolution_ListWorkflowNodeField {

4
code/common/status/error.ts
View File

@ -233,6 +233,10 @@ export namespace Err {
code:3606,
msg:"field type not match"
},
fieldConfigValueAlreadySelected: {
code:3607,
msg:"field config value already selected"
}
},
ProjectIssue:{
projectIssueNotFound:{

2
code/server/common/http/http.ts
View File

@ -200,7 +200,7 @@ export async function handleHttpCall(obj:IServer_Common_Http_Structure,ctx:IServ
value=false
}
}
else if(obj.type=="Object")
else if(obj.type=="Object" || obj.type=="Array")
{
if(typeof(value)=="string") {
try {

50
code/server/cooperation/http/field.ts
View File

@ -104,6 +104,16 @@ class FieldController {
return ret;
}
@DHttpApi(fieldApi.routes.workflowNodeFieldInfo)
async workflowNodeFieldInfo(@DHttpReqParamRequired("fieldSolutionWorkflowNodeFieldTypeId") fieldSolutionWorkflowNodeFieldTypeId:string): Promise<typeof fieldApi.routes.workflowNodeFieldInfo.res> {
let obj=await FieldSolutionService.getObjByFieldSolutionWorkflowNodeFieldTypeId(fieldSolutionWorkflowNodeFieldTypeId)
if(!obj) {
throw Err.Project.Field.fieldSolutionNotFound
}
let ret=await obj.workflowNodeFieldInfo(fieldSolutionWorkflowNodeFieldTypeId)
return ret;
}
@DHttpApi(fieldApi.routes.addWorkflowNodeField)
async addWorkflowNodeField(@DHttpReqParamRequired("fieldSolutionId") fieldSolutionId:string,
@DHttpReqParamRequired("workflowSolutionId") workflowSolutionId:string,
@ -114,7 +124,6 @@ class FieldController {
@DHttpReqParamRequired("workflowId") workflowId:string,
@DHttpReqParamRequired("workflowNodeId") workflowNodeId:string,
@DHttpReqParam("description") description:string,
@DHttpReqParam("lable_type") labelType:string,
@DHttpReqParam("weight") weight:number): Promise<typeof fieldApi.routes.addWorkflowNodeField.res> {
let obj=await FieldSolutionService.getItemById(fieldSolutionId)
if(!obj) {
@ -124,6 +133,17 @@ class FieldController {
return ret;
}
@DHttpApi(fieldApi.routes.editWorkflowNodeFieldLabelType)
async editWorkflowNodeFieldLabelType(@DHttpReqParamRequired("fieldSolutionWorkflowNodeFieldTypeId") fieldSolutionWorkflowNodeFieldTypeId:string,
@DHttpReqParamRequired("labelType") labelType:number): Promise<typeof fieldApi.routes.editWorkflowNodeFieldLabelType.res> {
let obj=await FieldSolutionService.getObjByFieldSolutionWorkflowNodeFieldTypeId(fieldSolutionWorkflowNodeFieldTypeId)
if(!obj) {
throw Err.Project.Field.fieldSolutionNotFound
}
await obj.editWorkflowNodeFieldLableType(fieldSolutionWorkflowNodeFieldTypeId,labelType)
return;
}
@DHttpApi(fieldApi.routes.editWorkflowNodeField)
async editWorkflowNodeField(@DHttpReqParamRequired("fieldSolutionWorkflowNodeFieldTypeId") fieldSolutionWorkflowNodeFieldTypeId:string,
@DHttpReqParam("optional") optional:number,
@ -171,14 +191,16 @@ class FieldController {
@DHttpApi(fieldApi.routes.addWorkflowNodeFieldConfig)
async addWorkflowNodeFieldConfig(@DHttpReqParamRequired("fieldSolutionWorkflowNodeFieldTypeId") fieldSolutionWorkflowNodeFieldTypeId:string,
@DHttpReqParamRequired("value") value:string,
@DHttpReqParamRequired("name") name:string,
@DHttpReqParamRequired("selected") selected:number): Promise<typeof fieldApi.routes.addWorkflowNodeFieldConfig.res> {
@DHttpReqParamRequired("data") data:{
value :string,
name :string,
selected :number
}[]): Promise<typeof fieldApi.routes.addWorkflowNodeFieldConfig.res> {
let obj=await FieldSolutionService.getObjByFieldSolutionWorkflowNodeFieldTypeId(fieldSolutionWorkflowNodeFieldTypeId)
if(!obj) {
throw Err.Project.Field.fieldSolutionNotFound
}
let ret=await obj.addWorkflowNodeFieldConfig(fieldSolutionWorkflowNodeFieldTypeId,value,name,selected)
let ret=await obj.addWorkflowNodeFieldConfigs(fieldSolutionWorkflowNodeFieldTypeId,data)
return ret;
}
@ -189,7 +211,7 @@ class FieldController {
@DHttpReqParam("selected") selected:number): Promise<typeof fieldApi.routes.editWorkflowNodeFieldConfig.res> {
let obj=await FieldSolutionService.getObjByFieldTypeConfigValueId(fieldTypeConfigValueId)
if(!obj) {
throw Err.Project.Field.fieldTypeConfigValueIdNotFound
throw Err.Project.Field.fieldSolutionNotFound
}
let ret=await obj.editWorkflowNodeFieldConfig(fieldTypeConfigValueId,value,name,selected)
return ret;
@ -199,7 +221,7 @@ class FieldController {
async deleteWorkflowNodeFieldConfig(@DHttpReqParamRequired("fieldTypeConfigValueId") fieldTypeConfigValueId:string): Promise<typeof fieldApi.routes.deleteWorkflowNodeFieldConfig.res> {
let obj=await FieldSolutionService.getObjByFieldTypeConfigValueId(fieldTypeConfigValueId)
if(!obj) {
throw Err.Project.Field.fieldTypeConfigValueIdNotFound
throw Err.Project.Field.fieldSolutionNotFound
}
await obj.deleteWorkflowNodeFieldConfig(fieldTypeConfigValueId)
return
@ -213,10 +235,22 @@ class FieldController {
@DHttpReqParamRequired("newWorkflowSolutionId") newWorkflowSolutionId:string): Promise<typeof fieldApi.routes.workflowFieldsCopy.res> {
let obj=await FieldSolutionService.getItemById(fieldSolutionId)
if(!obj) {
throw Err.Project.Field.fieldTypeConfigValueIdNotFound
throw Err.Project.Field.fieldSolutionNotFound
}
await obj.workflowFieldsCopy(workflowSolutionId,workflowId,newFieldSolutionId,newWorkflowSolutionId)
return
}
@DHttpApi(fieldApi.routes.workflowCanCopyedList)
async workflowCanCopyedList(@DHttpReqParamRequired("fieldSolutionId") fieldSolutionId:string,
@DHttpReqParamRequired("workflowSolutionId") workflowSolutionId:string,
@DHttpReqParamRequired("workflowId") workflowId:string): Promise<typeof fieldApi.routes.workflowCanCopyedList.res> {
let obj=await FieldSolutionService.getItemById(fieldSolutionId)
if(!obj) {
throw Err.Project.Field.fieldSolutionNotFound
}
let ret=await obj.getIfCopyedWorkflowList(workflowId,workflowSolutionId)
return ret;
}
}

130
code/server/cooperation/mapper/field.ts
View File

@ -6,7 +6,7 @@ import { Err } from '../../../common/status/error';
import { keys } from '../../../common/transform';
import { getMysqlInstance } from '../../common/db/mysql';
import { Mapper } from "../../common/entity/mapper";
import { generateBatchCreateSql, generateCreateSql, generateDeleteSql, generateLeftJoinSql, generateMaxSql, generateQuerySql, generateSnowId, generateUpdateSql } from '../../common/util/sql';
import { generateBatchCreateSql, generateCreateSql, generateDeleteSql, generateLeftJoin2Sql, generateLeftJoinSql, generateMaxSql, generateQuerySql, generateSnowId, generateUpdateSql } from '../../common/util/sql';
import { ICommon_Model_Field_Solution } from './../../../common/model/field_solution';
import { ECommon_Model_Field_Solution_Workflow_Node_Field_Type_Label_Type } from './../../../common/model/field_solution_workflow_node_field_type';
import { fieldSolutionWorkflowSolutionModel } from './../../../common/model/field_solution_workflow_solution';
@ -69,6 +69,53 @@ class FieldSolutionMapper extends Mapper<typeof fieldSolutionModel> {
return ret;
}
async workflowNodeFieldInfo(fieldSolutionWorkflowNodeFieldTypeId:string):Promise<{
field:ICommon_Model_Field_Solution_Workflow_Node_Field_Type,
fieldType:ICommon_Model_Field_Type,
values?:ICommon_Model_Field_Type_Config_Value[]
}> {
if(!fieldSolutionWorkflowNodeFieldTypeId) {
throw Err.Project.Field.fieldSolutionWorkflowNodeFieldTypeNotFound
}
let mysql=getMysqlInstance()
let sql=generateLeftJoinSql({
model:fieldSolutionWorkflowNodeFieldTypeModel,
columns:keys<ICommon_Model_Field_Solution_Workflow_Node_Field_Type>().map(item=>item.name),
},{
model:fieldTypeModel,
columns:keys<ICommon_Model_Field_Type>().map(item=>item.name),
expression:{
id:{
model:fieldSolutionWorkflowNodeFieldTypeModel,
field:"field_type_id"
}
},
aggregation:"fieldType"
},{
id:{
model:fieldSolutionWorkflowNodeFieldTypeModel,
value:fieldSolutionWorkflowNodeFieldTypeId
}
})
let objField=await mysql.executeOne(sql)
let objFieldType = objField.fieldType
delete objField.fieldType
let ret=<{
field:ICommon_Model_Field_Solution_Workflow_Node_Field_Type,
fieldType:ICommon_Model_Field_Type,
values?:ICommon_Model_Field_Type_Config_Value[]
}>{
field: objField,
fieldType: objFieldType,
values: []
}
let arrValues = await mysql.execute(generateQuerySql(fieldTypeConfigValueModel, [], {
field_solution_workflow_node_field_type_id: objField.id
}))
ret.values = arrValues
return ret;
}
async getWorkflowNodeFieldList(fieldSolutionId:string,workflowNodeId:string,workflowId:string,workflowSolutionId:string):Promise<{
field:ICommon_Model_Field_Solution_Workflow_Node_Field_Type,
fieldType:ICommon_Model_Field_Type,
@ -342,7 +389,7 @@ class FieldSolutionMapper extends Mapper<typeof fieldSolutionModel> {
return ret!=null
}
async addWorkflowNodeField(fieldSolutionId:string,workflowNodeId:string,workflowId:string,workflowSolutionId:string,fieldTypeId:string,name:string,optional:number,defaultValue?:string,description?:string,labelType?:ECommon_Model_Field_Solution_Workflow_Node_Field_Type_Label_Type,weight?:number):Promise<ICommon_Model_Field_Solution_Workflow_Node_Field_Type> {
async addWorkflowNodeField(fieldSolutionId:string,workflowNodeId:string,workflowId:string,workflowSolutionId:string,fieldTypeId:string,name:string,optional:number,defaultValue?:string,description?:string,weight?:number):Promise<ICommon_Model_Field_Solution_Workflow_Node_Field_Type> {
if(!fieldSolutionId) {
throw Err.Project.Field.fieldSolutionNotFound
} else if(!workflowNodeId) {
@ -377,7 +424,6 @@ class FieldSolutionMapper extends Mapper<typeof fieldSolutionModel> {
optional,
description,
sort,
label_type:labelType,
weight
}))
let ret=await mysql.executeOne(generateQuerySql(fieldSolutionWorkflowNodeFieldTypeModel,[],{
@ -386,6 +432,18 @@ class FieldSolutionMapper extends Mapper<typeof fieldSolutionModel> {
return ret;
}
async editWorkflowNodeFieldLableType(fieldSolutionWorkflowNodeFieldTypeId:string,labelType:number) {
if(!fieldSolutionWorkflowNodeFieldTypeId) {
throw Err.Project.Field.fieldSolutionWorkflowNodeFieldTypeNotFound
}
let mysql=getMysqlInstance()
await mysql.execute(generateUpdateSql(fieldSolutionWorkflowNodeFieldTypeModel,{
label_type:labelType
},{
id:fieldSolutionWorkflowNodeFieldTypeId
}))
}
async editWorkflowNodeField(fieldSolutionWorkflowNodeFieldTypeId:string,name?:string,optional?:number,defaultValue?:string,description?:string,labelType?:ECommon_Model_Field_Solution_Workflow_Node_Field_Type_Label_Type,weight?:number):Promise<ICommon_Model_Field_Solution_Workflow_Node_Field_Type> {
if(!fieldSolutionWorkflowNodeFieldTypeId) {
throw Err.Project.Field.fieldSolutionWorkflowNodeFieldTypeNotFound
@ -545,6 +603,35 @@ class FieldSolutionMapper extends Mapper<typeof fieldSolutionModel> {
return ret;
}
async getFieldByFieldTypeConfigId(fieldTypeConfigValueId :string) {
if(!fieldTypeConfigValueId) {
throw Err.Project.Field.fieldTypeConfigValueIdNotFound
}
let mysql=getMysqlInstance()
let obj = await mysql.executeOne(generateQuerySql(fieldTypeConfigValueModel,[],{
id:fieldTypeConfigValueId
}))
if(!obj) {
throw Err.Project.Field.fieldTypeConfigValueIdNotFound
}
let ret=await mysql.executeOne(generateQuerySql(fieldSolutionWorkflowNodeFieldTypeModel,[],{
id:obj.field_solution_workflow_node_field_type_id
}))
return ret;
}
async checkFieldConfigValueSelectedExist(fieldSolutionWorkflowNodeFieldTypeId:string) {
if(!fieldSolutionWorkflowNodeFieldTypeId) {
throw Err.Project.Field.fieldSolutionWorkflowNodeFieldTypeNotFound
}
let mysql=getMysqlInstance()
let ret=await mysql.executeOne(generateQuerySql(fieldTypeConfigValueModel,[],{
field_solution_workflow_node_field_type_id:fieldSolutionWorkflowNodeFieldTypeId,
selected:1
}))
return !!ret;
}
async editWorkflowNodeFieldConfig(fieldTypeConfigValueId :string,value? :string,name? :string,selected? :number):Promise<ICommon_Model_Field_Type_Config_Value> {
if(!fieldTypeConfigValueId) {
throw Err.Project.Field.fieldTypeConfigValueIdNotFound
@ -709,6 +796,43 @@ class FieldSolutionMapper extends Mapper<typeof fieldSolutionModel> {
let arr=await mysql.execute(sql)
return arr;
}
async getFieldSolutionWorkflowSolutionListByWorkflowSolutionIds(workflowSolutionIds:string[]) {
let mysql=getMysqlInstance()
let sql=generateLeftJoin2Sql({
model:fieldSolutionWorkflowSolutionModel
},{
model:fieldSolutionModel,
columns:["id","name"],
expression:{
id:{
model:fieldSolutionWorkflowSolutionModel,
field:"field_solution_id"
}
},
aggregation:"fieldSolution"
},{
model:workflowSolutionModel,
columns:["id","name"],
expression:{
id:{
model:fieldSolutionWorkflowSolutionModel,
field:"workflow_solution_id"
}
},
aggregation:"workflowSolution"
},{
workflow_solution_id:{
model:fieldSolutionWorkflowSolutionModel,
value:{
exp:"in",
value:workflowSolutionIds
}
}
})
let ret=await mysql.execute(sql)
return ret;
}
}
export let fieldSolutionMapper=new FieldSolutionMapper

26
code/server/cooperation/mapper/workflow.ts
View File

@ -459,6 +459,32 @@ class WorkflowSolutionMapper extends Mapper<typeof workflowSolutionModel> {
}))
return ret
}
async getItemsByWorkflowId(workflowId:string) {
if(!workflowId) {
throw Err.Project.Workflow.workflowNotFound
}
let mysql=getMysqlInstance()
let sql=generateLeftJoinSql({
model:workflowSolutionWorkflowModel
},{
model:workflowSolutionModel,
columns:keys<ICommon_Model_Workflow_Solution>().map(item=>item.name),
expression:{
id:{
model:workflowSolutionWorkflowModel,
field:"workflow_solution_id"
}
},
},{
workflow_id:{
model:workflowSolutionWorkflowModel,
value:workflowId
}
})
let ret=await mysql.execute(sql)
return ret;
}
}
export let workflowSolutionMapper=new WorkflowSolutionMapper

124
code/server/cooperation/service/field.ts
View File

@ -1,14 +1,13 @@
import { fieldSolutionModel } from "../../../common/model/field_solution";
import { ICommon_Model_Field_Solution_Workflow_Node_Field_Type } from "../../../common/model/field_solution_workflow_node_field_type";
import { ICommon_Model_Field_Type_Config_Value } from "../../../common/model/field_type_config_value";
import { Err } from "../../../common/status/error";
import { Entity } from "../../common/entity/entity";
import { EServer_Common_Event_Types } from "../../common/event/types";
import { ECommon_Model_Field_Solution_Workflow_Node_Field_Type_Label_Type } from './../../../common/model/field_solution_workflow_node_field_type';
import { fieldTypeModel, ICommon_Model_Field_Type } from './../../../common/model/field_type';
import { ECommon_Model_Field_Type, fieldTypeModel } from './../../../common/model/field_type';
import { ICommon_Route_Res_FieldSolution_Info } from './../../../common/routes/response';
import { fieldSolutionMapper, fieldTypeMapper } from './../mapper/field';
import WorkflowService, { WorkflowSolutionService } from './workflow';
import { WorkflowSolutionService } from './workflow';
export default class FieldType extends Entity<typeof fieldTypeModel,typeof fieldTypeMapper> {
constructor(){
@ -32,36 +31,9 @@ export class FieldSolutionService extends Entity<typeof fieldSolutionModel,typeo
async info() :Promise<ICommon_Route_Res_FieldSolution_Info>{
let ret:ICommon_Route_Res_FieldSolution_Info={
data:[],
workflowSolutionList:await fieldSolutionMapper.getBindWorkflowSolutionList(this.getId()),
...this.getItem()
}
let workflowSolutionList=await fieldSolutionMapper.getBindWorkflowSolutionList(this.getId())
for(let objWorkflowSolution of workflowSolutionList) {
let workflowSolution=await WorkflowSolutionService.getItemById(objWorkflowSolution.id)
let workflowList=await workflowSolution.listWorkflow()
let arr:ICommon_Route_Res_FieldSolution_Info["data"][0]["data"]=[]
for (let obj of workflowList) {
let workflowService = await WorkflowService.getItemById(obj.id)
let node = await workflowService.accessNodesAndActions(async (nodeId: string): Promise<{
field: ICommon_Model_Field_Solution_Workflow_Node_Field_Type,
fieldType: ICommon_Model_Field_Type,
values?: ICommon_Model_Field_Type_Config_Value[]
}[]> => {
let ret = await fieldSolutionMapper.getWorkflowNodeFieldList(this.getId(), nodeId, obj.id, workflowSolution.getId())
return ret;
})
let objTemp: ICommon_Route_Res_FieldSolution_Info["data"][0]["data"][0] = {
workflow: obj,
node: node
}
arr.push(objTemp)
}
let obj:ICommon_Route_Res_FieldSolution_Info["data"][0]={
workflowSolution:objWorkflowSolution,
data:arr
}
ret.data.push(obj)
}
return ret;
}
@ -107,7 +79,7 @@ export class FieldSolutionService extends Entity<typeof fieldSolutionModel,typeo
}
async addWorkflowNodeField(workflowNodeId:string,workflowId:string,workflowSolutionId:string,fieldTypeId:string,name:string,optional:number,defaultValue?:string,description?:string,labelType?:ECommon_Model_Field_Solution_Workflow_Node_Field_Type_Label_Type,weight?:number) {
async addWorkflowNodeField(workflowNodeId:string,workflowId:string,workflowSolutionId:string,fieldTypeId:string,name:string,optional:number,defaultValue?:string,description?:string,weight?:number) {
if(!workflowNodeId) {
throw Err.Project.Workflow.workflowNodeNotFound
} else if(!workflowId) {
@ -129,10 +101,24 @@ export class FieldSolutionService extends Entity<typeof fieldSolutionModel,typeo
if(!isIn) {
throw Err.Project.Workflow.workflowNotInWorkflowSolution
}
let ret=await fieldSolutionMapper.addWorkflowNodeField(this.getId(),workflowNodeId,workflowId,workflowSolutionId,fieldTypeId,name,optional,defaultValue,description,labelType,weight);
let ret=await fieldSolutionMapper.addWorkflowNodeField(this.getId(),workflowNodeId,workflowId,workflowSolutionId,fieldTypeId,name,optional,defaultValue,description,weight);
return ret;
}
async editWorkflowNodeFieldLableType(fieldSolutionWorkflowNodeFieldTypeId:string,labelType:number) {
let obj=await fieldSolutionMapper.getFieldByNodeFieldTypeId(fieldSolutionWorkflowNodeFieldTypeId);
if(!obj) {
throw Err.Project.Field.fieldSolutionWorkflowNodeFieldTypeNotFound
}
let objFieldType=await FieldType.getItemById(obj.field_type_id)
if(!objFieldType) {
throw Err.Project.Field.fieldTypeNotFound
} else if(objFieldType.getItem().type!=ECommon_Model_Field_Type.LABEL && objFieldType.getItem().type!=ECommon_Model_Field_Type.MULTILABEL) {
throw Err.Project.Field.fieldTypeNotMatch
}
await fieldSolutionMapper.editWorkflowNodeFieldLableType(obj.id,labelType);
}
async listWorkflowNodeField(workflowNodeId:string,workflowId:string,workflowSolutionId:string) {
if(!workflowNodeId) {
throw Err.Project.Workflow.workflowNodeNotFound
@ -153,6 +139,27 @@ export class FieldSolutionService extends Entity<typeof fieldSolutionModel,typeo
return ret;
}
async workflowNodeFieldInfo(fieldSolutionWorkflowNodeFieldTypeId:string) {
if(!fieldSolutionWorkflowNodeFieldTypeId) {
throw Err.Project.Field.fieldSolutionWorkflowNodeFieldTypeNotFound
}
let ret=await fieldSolutionMapper.workflowNodeFieldInfo(fieldSolutionWorkflowNodeFieldTypeId)
return ret;
}
async getIfCopyedWorkflowList(workflowId:string,workflowSolutionId:string) {
let ret=await WorkflowSolutionService.getItemListByWorkflowId(workflowId)
let workflowSolutionIds=ret.map(item=>item.id)
let arr=await fieldSolutionMapper.getFieldSolutionWorkflowSolutionListByWorkflowSolutionIds(workflowSolutionIds)
return arr.filter(obj=>{
if(obj.workflowSolution.id==workflowSolutionId && obj.fieldSolution.id==this.getId()) {
return false
} else {
return true
}
})
}
static async clearItemsByWorkflowId(workflowId:string) {
if(!workflowId) {
throw Err.Project.Workflow.workflowNotFound
@ -222,7 +229,24 @@ export class FieldSolutionService extends Entity<typeof fieldSolutionModel,typeo
return ret;
}
async addWorkflowNodeFieldConfig(fieldSolutionWorkflowNodeFieldTypeId :string,value :string,name :string,selected :number) {
async addWorkflowNodeFieldConfigs(fieldSolutionWorkflowNodeFieldTypeId :string,data:{
value :string,
name :string,
selected :number
}[]) {
if(data.length==0) {
return []
}
let isSelected = false
for(let o of data) {
if(o.selected) {
if(!isSelected) {
isSelected=true
} else {
throw Err.Project.Field.fieldConfigValueAlreadySelected
}
}
}
let obj=await fieldSolutionMapper.getFieldByNodeFieldTypeId(fieldSolutionWorkflowNodeFieldTypeId)
if(!obj) {
throw Err.Project.Field.fieldSolutionWorkflowNodeFieldTypeNotFound
@ -230,14 +254,40 @@ export class FieldSolutionService extends Entity<typeof fieldSolutionModel,typeo
let objFieldType=await FieldType.getItemById(obj.field_type_id)
if(!objFieldType) {
throw Err.Project.Field.fieldTypeNotFound
} else if(!objFieldType.getItem().multi) {
} else if(objFieldType.getItem().type!=ECommon_Model_Field_Type.SELECT && objFieldType.getItem().type!=ECommon_Model_Field_Type.MULTISELECT) {
throw Err.Project.Field.fieldTypeNotMatch
}
let ret=await fieldSolutionMapper.addWorkflowNodeFieldConfig(fieldSolutionWorkflowNodeFieldTypeId,value,name,selected)
return ret;
if (isSelected && objFieldType.getItem().type==ECommon_Model_Field_Type.SELECT) {
let isExist = await fieldSolutionMapper.checkFieldConfigValueSelectedExist(fieldSolutionWorkflowNodeFieldTypeId)
if(isExist) {
throw Err.Project.Field.fieldConfigValueAlreadySelected
}
}
let arr:ICommon_Model_Field_Type_Config_Value[]=[];
for(let obj of data) {
let ret=await fieldSolutionMapper.addWorkflowNodeFieldConfig(fieldSolutionWorkflowNodeFieldTypeId,obj.value,obj.name,obj.selected)
arr.push(ret)
}
return arr;
}
async editWorkflowNodeFieldConfig(fieldTypeConfigValueId :string,value? :string,name? :string,selected? :number) {
let obj=await fieldSolutionMapper.getFieldByFieldTypeConfigId(fieldTypeConfigValueId)
if(!obj) {
throw Err.Project.Field.fieldSolutionWorkflowNodeFieldTypeNotFound
}
let objFieldType=await FieldType.getItemById(obj.field_type_id)
if(!objFieldType) {
throw Err.Project.Field.fieldTypeNotFound
} else if(objFieldType.getItem().type!=ECommon_Model_Field_Type.SELECT && objFieldType.getItem().type!=ECommon_Model_Field_Type.MULTISELECT) {
throw Err.Project.Field.fieldTypeNotMatch
}
if(selected && objFieldType.getItem().type==ECommon_Model_Field_Type.SELECT) {
let isExist = await fieldSolutionMapper.checkFieldConfigValueSelectedExist(obj.id)
if(isExist) {
throw Err.Project.Field.fieldConfigValueAlreadySelected
}
}
let ret=await fieldSolutionMapper.editWorkflowNodeFieldConfig(fieldTypeConfigValueId,value,name,selected)
return ret;
}

6
code/server/cooperation/service/workflow.ts
View File

@ -158,6 +158,12 @@ export class WorkflowSolutionService extends Entity<typeof workflowSolutionModel
}
}
static async getItemListByWorkflowId(workflowId:string) {
let ret=await workflowSolutionMapper.getItemsByWorkflowId(workflowId)
return ret;
}
static async getReservedItem () {
let ret=await workflowSolutionMapper.getReservedItem()
let obj=new WorkflowSolutionService()