add

code/common/routes/field.ts

@@ -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,
+                data:{
-                name :string,
+                    value :string,
-                selected :number,
+                    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]
         }
     }
 }

code/common/routes/response.ts

@@ -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:{
+    workflowSolutionList:ICommon_Model_Workflow_Solution[]
-        workflowSolution:ICommon_Model_Workflow_Solution,
-        data:{
-            workflow:ICommon_Model_Workflow,
-            node:ICommon_Route_Res_Workflow_Info_Node
-        }[]
-    }[]
 }
 
 export interface ICommon_Route_Res_FieldSolution_ListWorkflowNodeField {

code/common/status/error.ts

@@ -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:{

code/server/common/http/http.ts

@@ -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 {

code/server/cooperation/http/field.ts

@@ -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("data") data:{
-    @DHttpReqParamRequired("name") name:string,
+        value :string,
-    @DHttpReqParamRequired("selected") selected:number): Promise<typeof fieldApi.routes.addWorkflowNodeFieldConfig.res> {
+        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;
+    }
+
 }

code/server/cooperation/mapper/field.ts

@@ -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

code/server/cooperation/mapper/workflow.ts

@@ -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
 

code/server/cooperation/service/field.ts

@@ -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)
+        if (isSelected && objFieldType.getItem().type==ECommon_Model_Field_Type.SELECT) {
-        return ret;
+            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;
     }

code/server/cooperation/service/workflow.ts

@@ -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()