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-01-31 11:45:30 +08:00
parent 982b20f1ca
commit 773e56ff33
21 changed files with 1853 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
code/common/model/field.ts
View File

@ -1,10 +0,0 @@
export interface ICommon_Model_Field {
id:string,
type_id:string,
reserved:number,
description:string,
created_time:Date,
modified_time:Date,
name:string
}
export const Table_Field="field"

1
code/common/model/field_solution.ts
View File

@ -4,7 +4,6 @@ export interface ICommon_Model_Field_Solution {
id :string,
created_time :Date,
modified_time :Date ,
created_by :string,
name :string,
description :string
}

23
code/common/model/field_solution_workflow_node.ts
View File

@ -1,23 +0,0 @@
import { BaseModel } from "./base"
export interface ICommon_Model_Field_Solution_Workflow_Node {
id :string,
field_solution_id :string ,
workflow_node_id :string ,
field_type_id :string,
optional :number,
default_value :string,
name:string,
workflow_id:string,
workflow_solution_id:string,
issue_type_id:string,
description:string
}
export const Table_Field_Solution_Workflow_Node="field_solution_workflow_node"
class FieldSolutionWorkflowNodeModel extends BaseModel {
table=Table_Field_Solution_Workflow_Node
model=<ICommon_Model_Field_Solution_Workflow_Node>{}
}
export let fieldSolutionWorkflowNodeModel=new FieldSolutionWorkflowNodeModel

30
code/common/model/field_solution_workflow_node_field_type.ts Normal file
View File

@ -0,0 +1,30 @@
import { BaseModel } from "./base"
export enum ECommon_Model_Field_Solution_Workflow_Node_Field_Type_Label_Type {
USER,
RELEASE,
ISSUE,
MODULE,
TAG
}
export interface ICommon_Model_Field_Solution_Workflow_Node_Field_Type {
id :string,
field_solution_id :string ,
workflow_node_id :string ,
field_type_id :string,
optional :number,
default_value :string,
name:string,
workflow_id:string,
workflow_solution_id:string,
description:string,
sort:number,
label_type:ECommon_Model_Field_Solution_Workflow_Node_Field_Type_Label_Type
}
export const Table_Field_Solution_Workflow_Node_Field_Type="field_solution_workflow_node_field_type"
class FieldSolutionWorkflowNodeFieldTypeModel extends BaseModel {
table=Table_Field_Solution_Workflow_Node_Field_Type
model=<ICommon_Model_Field_Solution_Workflow_Node_Field_Type>{}
}
export let fieldSolutionWorkflowNodeFieldTypeModel=new FieldSolutionWorkflowNodeFieldTypeModel

14
code/common/model/field_type.ts
View File

@ -1,11 +1,23 @@
import { BaseModel } from "./base"
export enum ECommon_Model_Field_Type {
SWITCH,
MULTILABEL,
LABEL,
TEXT,
MULTITEXT,
SELECT,
MULTISELECT,
TIME,
DATE,
DATETIME
}
export interface ICommon_Model_Field_Type {
id :string,
name :string,
icon :string,
description :string,
multi :number,
type:ECommon_Model_Field_Type
}
export const Table_Field_Type="field_type"

15
code/common/model/workflow_solution_workflow.ts Normal file
View File

@ -0,0 +1,15 @@
import { BaseModel } from "./base"
export interface ICommon_Model_Workflow_Solution_Workflow {
id :string ,
workflow_solution_id:string,
workflow_id:string
}
export const Table_Workflow_Solution_Workflow="workflow_solution_workflow"
class WorkflowSolutionWorkflowModel extends BaseModel {
table=Table_Workflow_Solution_Workflow
model=<ICommon_Model_Workflow_Solution_Workflow>{}
}
export let workflowSolutionWorkflowModel=new WorkflowSolutionWorkflowModel

201
code/common/routes/field.ts Normal file
View File

@ -0,0 +1,201 @@
import { ECommon_Model_Field_Solution_Workflow_Node_Field_Type_Label_Type, ICommon_Model_Field_Solution_Workflow_Node_Field_Type } from '../model/field_solution_workflow_node_field_type';
import { ECommon_Services } from "../types";
import { ICommon_Model_Field_Solution } from './../model/field_solution';
import { ICommon_Model_Field_Type } from './../model/field_type';
import { ICommon_Model_Field_Type_Config_Value } from './../model/field_type_config_value';
import { ICommon_Route_Res_FieldSolution_Info, ICommon_Route_Res_listWorkflowNodeField } from "./response";
import { ECommon_HttpApi_Method } from "./types";
const api={
baseUrl:"/field",
service:ECommon_Services.Cooperation,
routes:{
typeList:{
method:ECommon_HttpApi_Method.GET,
path:"/type/list",
req:<{
}>{},
res:<ICommon_Model_Field_Type[]>{}
},
typeInfo:{
method:ECommon_HttpApi_Method.GET,
path:"/type/item",
req:<{
fieldTypeId:string
}>{},
res:<ICommon_Model_Field_Type>{}
},
solutionList:{
method:ECommon_HttpApi_Method.GET,
path:"/solution/list",
req:<{
}>{},
res:<ICommon_Model_Field_Solution[]>{}
},
solutionInfo:{
method:ECommon_HttpApi_Method.GET,
path:"/solution/item",
req:<{
fieldSolutionId:string
}>{},
res:<ICommon_Route_Res_FieldSolution_Info>{}
},
solutionCreate:{
method:ECommon_HttpApi_Method.POST,
path:"/solution/item",
req:<{
name:string,
description?:string
}>{},
res:<ICommon_Model_Field_Solution>{}
},
solutionEdit:{
method:ECommon_HttpApi_Method.PUT,
path:"/solution/item",
req:<{
fieldSolutionId:string
name?:string,
description?:string
}>{},
res:<ICommon_Model_Field_Solution>{}
},
solutionDelete:{
method:ECommon_HttpApi_Method.DELETE,
path:"/solution/item",
req:<{
fieldSolutionId:string
}>{},
res:{}
},
bindWorkflowSolution:{
method:ECommon_HttpApi_Method.PUT,
path:"/solution/bind",
req:<{
fieldSolutionId:string,
workflowSolutionId:string
}>{},
res:{}
},
unbindWorkflowSolution:{
method:ECommon_HttpApi_Method.PUT,
path:"/solution/unbind",
req:<{
fieldSolutionId:string,
workflowSolutionId:string
}>{},
res:{}
},
listWorkflowNodeField:{
method:ECommon_HttpApi_Method.GET,
path:"/solution/field/list",
req: <{
fieldSolutionId: string,
workflowNodeId: string,
workflowId: string,
workflowSolutionId: string
}>{},
res: <ICommon_Route_Res_listWorkflowNodeField[]>{}
},
addWorkflowNodeField:{
method:ECommon_HttpApi_Method.POST,
path:"/solution/field/item",
req: <{
fieldSolutionId: string,
workflowNodeId: string,
fieldTypeId: string,
optional: number,
defaultValue?: string,
name: string,
workflowId: string,
workflowSolutionId: string,
description?: string,
lable_type?:ECommon_Model_Field_Solution_Workflow_Node_Field_Type_Label_Type
}>{},
res: <ICommon_Model_Field_Solution_Workflow_Node_Field_Type>{}
},
editWorkflowNodeField:{
method:ECommon_HttpApi_Method.PUT,
path:"/solution/field/item",
req: <{
fieldSolutionWorkflowNodeFieldTypeId:string,
optional?: number,
defaultValue?: string,
name?: string,
description?: string,
lable_type?:ECommon_Model_Field_Solution_Workflow_Node_Field_Type_Label_Type
}>{},
res: <ICommon_Model_Field_Solution_Workflow_Node_Field_Type>{}
},
deleteWorkflowNodeField:{
method:ECommon_HttpApi_Method.DELETE,
path:"/solution/field/item",
req: <{
fieldSolutionWorkflowNodeFieldTypeId:string
}>{},
res: {}
},
moveWorkflowNodeField:{
method:ECommon_HttpApi_Method.PUT,
path:"/solution/field/sort",
req: <{
fieldSolutionWorkflowNodeFieldTypeId:string,
sort:number
}>{},
res: <ICommon_Model_Field_Solution_Workflow_Node_Field_Type>{}
},
listWorkflowNodeFieldConfig:{
method:ECommon_HttpApi_Method.GET,
path:"/solution/field/config/list",
req: <{
fieldSolutionWorkflowNodeFieldTypeId :string
}>{},
res: <ICommon_Model_Field_Type_Config_Value[]>{}
},
addWorkflowNodeFieldConfig:{
method:ECommon_HttpApi_Method.POST,
path:"/solution/field/config/item",
req: <{
fieldSolutionWorkflowNodeFieldTypeId :string,
value :string,
name :string,
selected :number,
}>{},
res: <ICommon_Model_Field_Type_Config_Value>{}
},
editWorkflowNodeFieldConfig:{
method:ECommon_HttpApi_Method.PUT,
path:"/solution/field/config/item",
req: <{
fieldTypeConfigValueId :string,
value? :string,
name? :string,
selected? :number
}>{},
res: <ICommon_Model_Field_Type_Config_Value>{}
},
deleteWorkflowNodeFieldConfig:{
method:ECommon_HttpApi_Method.DELETE,
path:"/solution/field/config/item",
req: <{
fieldTypeConfigValueId :string
}>{},
res: {}
},
workflowFieldsCopy:{
method:ECommon_HttpApi_Method.POST,
path:"/solution/workflow/copy",
req:<{
fieldSolutionId:string,
workflowSolutionId:string,
workflowId:string,
newFieldSolutionId:string,
newWorkflowSolutionId:string
}>{},
res:{}
}
}
}
export=api

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

@ -1,7 +1,11 @@
import { ICommon_Model_Field_Solution_Workflow_Node_Field_Type } from "../model/field_solution_workflow_node_field_type";
import { ICommon_Model_Field_Type } from "../model/field_type";
import { ICommon_Model_Field_Type_Config_Value } from "../model/field_type_config_value";
import { ICommon_Model_Issue_Type } from "../model/issue_type";
import { ICommon_Model_Project } from "../model/project";
import { ICommon_Model_Team } from '../model/team';
import { ICommon_Model_User } from '../model/user';
import { ICommon_Model_Field_Solution } from './../model/field_solution';
import { ICommon_Model_Issue_Type_Solution } from './../model/issue_type_solution';
import { ECommon_Model_Project_Member_Type } from './../model/project_member';
import { ICommon_Model_Workflow } from './../model/workflow';
@ -90,6 +94,11 @@ export interface ICommon_Route_Res_IssueTypeSolution_Info extends ICommon_Model_
export interface ICommon_Route_Res_Workflow_Info_Node {
node:ICommon_Model_Workflow_Node,
fields?:{
field:ICommon_Model_Field_Solution_Workflow_Node_Field_Type,
fieldType:ICommon_Model_Field_Type,
values?:ICommon_Model_Field_Type_Config_Value[]
}[]
actions:ICommon_Route_Res_Workflow_Info_Action[]
}
@ -110,4 +119,21 @@ export interface ICommon_Route_Res_WorkflowSolution_Info extends ICommon_Model_W
workflow:ICommon_Model_Workflow
}[]
}[]
}
}
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
}[]
}[]
}
export interface ICommon_Route_Res_listWorkflowNodeField {
field: ICommon_Model_Field_Solution_Workflow_Node_Field_Type,
fieldType: ICommon_Model_Field_Type,
values?: ICommon_Model_Field_Type_Config_Value[]
}

26
code/common/routes/workflow.ts
View File

@ -195,6 +195,32 @@ const api={
}>{},
res:<ICommon_Model_Workflow_Solution>{}
},
solutionListWorkflow:{
method:ECommon_HttpApi_Method.GET,
path:"/solution/workflow/list",
req:<{
workflowSolutionId:string,
}>{},
res:<ICommon_Model_Workflow[]>{}
},
solutionAddWorkflow:{
method:ECommon_HttpApi_Method.POST,
path:"/solution/workflow/item",
req:<{
workflowSolutionId:string,
workflowId:string
}>{},
res:{}
},
solutionRemoveWorkflow:{
method:ECommon_HttpApi_Method.DELETE,
path:"/solution/workflow/item",
req:<{
workflowSolutionId:string,
workflowId:string
}>{},
res:{}
},
}
}
export=api

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

@ -162,7 +162,53 @@ export namespace Err {
workflowSolutionNotBindIssueTypeSolution:{
code:3509,
msg:"workflow solution not bind issue type solution"
},
workflowNotInWorkflowSolution:{
code:3510,
msg:"workflow not in workflow solution"
},
workflowNodeNotInWorkflow:{
code:3511,
msg:"worflow node not in workflow"
},
workflowAlreadyInWorkflowSolution:{
code:3512,
msg:"workflow already in workflow solution"
},
issueTypeSolutionDuplicate:{
code:3513,
msg:"issue type solution duplicate"
}
},
Field:{
fieldTypeNotFound:{
code:3600,
msg:"field type not found"
},
fieldSolutionNotFound:{
code:3601,
msg:"field solution not found"
},
fieldSolutionWorkflowNodeFieldTypeNotFound:{
code:3602,
msg:"field solution workflow node field Type not found"
},
fieldTypeConfigValueIdNotFound:{
code:3603,
msg:"field type config value id not found"
},
workflowSolutionNotBind:{
code:3604,
msg:"workflow solution not bind"
},
workflowSolutionAlreadyBind:{
code:3605,
msg:"workflow solution already bind"
},
fieldTypeNotMatch:{
code:3606,
msg:"field type not match"
},
}
}
export let Team = {

7
code/server/common/entity/mapper.ts
View File

@ -63,7 +63,12 @@ export abstract class Mapper<T extends BaseModel> {
if(!ret) {
throw Err.Common.itemNotFound
}
delete ret.created_time,ret.modified_time,ret.id
delete ret.created_time;
delete ret.modified_time;
delete ret.id
if(ret.name) {
(ret as any).name+="(copy)"
}
await this.create(ret);
let obj=this.getById(ret.id)
return obj;

81
code/server/common/util/sql.ts
View File

@ -10,7 +10,7 @@ type EXPR={
}
type EXPRVALUEEXP ={
value?:string|number|boolean|string[]|[number,number]|string|Date,
exp?:"="|">="|"<="|">"|"<"|"<>"|"is null"|"in"|"is not null"|"between"|"%like"|"like%"|"%like%"
exp?:"="|">="|"<="|">"|"<"|"<>"|"is null"|"in"|"is not null"|"between"|"%like"|"like%"|"%like%"|"> <"|">= <="|">= <"|"> <="
}
type EXPRVALUE=string|number|boolean|string|Date|EXPRVALUEEXP|{
type:"and"|"or",
@ -31,8 +31,22 @@ function handleExp(key:string,value:EXPRVALUEEXP,arrExpr:string[]) {
if(!value.exp) {
value.exp="="
}
let val = typeof (value.value) == "number" ? value.value : typeof (value.value) == "boolean" ? (value.value ? 1 : 0) : ("'" + value.value + "'")
arrExpr.push(`${key}${value.exp}${val}`)
if(value.exp=="> <" || value.exp=="> <=" || value.exp==">= <" || value.exp==">= <=" ) {
let val1 = value.value[0]
let val2 = value.value[1]
if(value.exp=="> <") {
arrExpr.push(`${key}>${val1} and ${key}<${val2}`)
} else if(value.exp==">= <=") {
arrExpr.push(`${key}>=${val1} and ${key}<=${val2}`)
} else if(value.exp==">= <") {
arrExpr.push(`${key}>=${val1} and ${key}<${val2}`)
} else if(value.exp=="> <=") {
arrExpr.push(`${key}>${val1} and ${key}<=${val2}`)
}
} else {
let val = typeof (value.value) == "number" ? value.value : typeof (value.value) == "boolean" ? (value.value ? 1 : 0) : ("'" + value.value + "'")
arrExpr.push(`${key}${value.exp}${val}`)
}
} else if(value.exp=="is null") {
arrExpr.push(`${key} is null`)
} else if(value.exp=="in") {
@ -137,6 +151,35 @@ export function generateCreateSql<T extends BaseModel>(model:T,obj:{
}
}
export function generateBatchCreateSql<T extends BaseModel>(model:T,arr:{
[param in keyof T["model"]]?:EXPRVALUE
}[]):{
value:string,
type:T["model"]
} {
let arrKey:string[]=[]
for(let item of arr) {
for(let key in item) {
if(!arrKey.includes(key)) {
arrKey.push(key)
}
}
}
let keys=arrKey.join(","),arrValues:string[]=[]
for(let item of arr) {
let arrValue:string[]=[]
for(let key of arrKey) {
let value=item[key]
arrValue.push((value!==undefined)?(value===null?"null":("'"+value+"'")):"default")
}
arrValues.push("("+arrValue.join(",")+")")
}
return {
value:`insert into ${model.table} (${keys}) values ${arrValues.join(",")}`,
type:model.model
}
}
export function generateQuerySql<T extends BaseModel,K1 extends keyof T["model"]>(model:T,columns:K1[],objExpr?:{
[param in keyof T["model"]]?:EXPRVALUE
},exprMode?:"and"|"or",order?:{
@ -596,4 +639,36 @@ export function generateCountSql<T extends BaseModel>(model:T,objExpr?:{
value:`select count(1) from ${model.table}${expr?(" where "+expr):""}`,
type:model.model
}
}
export function generateMaxSql<T extends BaseModel,K1 extends keyof T["model"]>(model:T,columnMax:K1,objExpr?:{
[param in keyof T["model"]]?:EXPRVALUE
},exprMode?:"and"|"or"):{
value:string,
type:{
[key in Extract<keyof T["model"],K1>]:T["model"][key]
}
} {
let column=`max(${columnMax}) ${columnMax}`
let expr=generateExp(objExpr,exprMode);
return {
value:`select ${column} from ${model.table}${expr?(" where "+expr):""}`,
type:model.model
}
}
export function generateMinSql<T extends BaseModel,K1 extends keyof T["model"]>(model:T,columnMin:K1,objExpr?:{
[param in keyof T["model"]]?:EXPRVALUE
},exprMode?:"and"|"or"):{
value:string,
type:{
[key in Extract<keyof T["model"],K1>]:T["model"][key]
}
} {
let column=`min(${columnMin}) ${columnMin}`
let expr=generateExp(objExpr,exprMode);
return {
value:`select ${column} from ${model.table}${expr?(" where "+expr):""}`,
type:model.model
}
}

3
code/server/cooperation/app/app.ts
View File

@ -1,9 +1,10 @@
import Application from "../../common/app/app";
import "../http/field";
import "../http/issueType";
import "../http/module";
import "../http/project";
import "../http/tag";
import "../http/workflow"
import "../http/workflow";
export default class Cooperation extends Application {
override async config() {

220
code/server/cooperation/http/field.ts Normal file
View File

@ -0,0 +1,220 @@
import * as fieldApi from "../../../common/routes/field";
import { Err } from "../../../common/status/error";
import { DComponent } from "../../common/decorate/component";
import { DHttpApi, DHttpController, DHttpReqParam, DHttpReqParamRequired } from "../../common/http/http";
import FieldTypeService from "../service/field";
import { FieldSolutionService } from './../service/field';
@DComponent
@DHttpController(fieldApi)
class FieldController {
@DHttpApi(fieldApi.routes.typeList)
async typeList(): Promise<typeof fieldApi.routes.typeList.res> {
let ret = await FieldTypeService.list()
return ret;
}
@DHttpApi(fieldApi.routes.typeInfo)
async typeInfo(@DHttpReqParamRequired("fieldTypeId") fieldTypeId:string): Promise<typeof fieldApi.routes.typeInfo.res> {
let ret = await FieldTypeService.getItemById(fieldTypeId)
if(!ret) {
throw Err.Project.Field.fieldTypeNotFound
}
return ret.getItem();
}
@DHttpApi(fieldApi.routes.solutionList)
async solutionList(): Promise<typeof fieldApi.routes.solutionList.res> {
let ret = await FieldSolutionService.list()
return ret;
}
@DHttpApi(fieldApi.routes.solutionInfo)
async solutionInfo(@DHttpReqParamRequired("fieldSolutionId") fieldSolutionId:string): Promise<typeof fieldApi.routes.solutionInfo.res> {
let obj=await FieldSolutionService.getItemById(fieldSolutionId)
if(!obj) {
throw Err.Project.Field.fieldSolutionNotFound
}
let ret=await obj.info()
return ret;
}
@DHttpApi(fieldApi.routes.solutionCreate)
async solutionCreate(@DHttpReqParamRequired("name") name:string,@DHttpReqParam("description") description:string): Promise<typeof fieldApi.routes.solutionCreate.res> {
let service=new FieldSolutionService
service.assignItem({
name,
description
})
let ret=await service.create()
return ret;
}
@DHttpApi(fieldApi.routes.solutionEdit)
async solutionEdit(@DHttpReqParamRequired("fieldSolutionId") fieldSolutionId:string,@DHttpReqParam("name") name:string,@DHttpReqParam("description") description:string): Promise<typeof fieldApi.routes.solutionEdit.res> {
let obj=await FieldSolutionService.getItemById(fieldSolutionId)
if(!obj) {
throw Err.Project.Field.fieldSolutionNotFound
}
obj.assignItem({
name,
description
})
let ret=await obj.update()
return ret;
}
@DHttpApi(fieldApi.routes.solutionDelete)
async solutionDelete(@DHttpReqParamRequired("fieldSolutionId") fieldSolutionId:string): Promise<typeof fieldApi.routes.solutionDelete.res> {
let obj=await FieldSolutionService.getItemById(fieldSolutionId)
if(!obj) {
throw Err.Project.Field.fieldSolutionNotFound
}
await obj.delete()
return
}
@DHttpApi(fieldApi.routes.bindWorkflowSolution)
async bindWorkflowSolution(@DHttpReqParamRequired("fieldSolutionId") fieldSolutionId:string,@DHttpReqParamRequired("workflowSolutionId") workflowSolutionId:string): Promise<typeof fieldApi.routes.bindWorkflowSolution.res> {
let obj=await FieldSolutionService.getItemById(fieldSolutionId)
if(!obj) {
throw Err.Project.Field.fieldSolutionNotFound
}
await obj.bindWorkflowSolution(workflowSolutionId)
return
}
@DHttpApi(fieldApi.routes.unbindWorkflowSolution)
async unbindWorkflowSolution(@DHttpReqParamRequired("fieldSolutionId") fieldSolutionId:string,@DHttpReqParamRequired("workflowSolutionId") workflowSolutionId:string): Promise<typeof fieldApi.routes.unbindWorkflowSolution.res> {
let obj=await FieldSolutionService.getItemById(fieldSolutionId)
if(!obj) {
throw Err.Project.Field.fieldSolutionNotFound
}
await obj.unbindWorkflowSolution(workflowSolutionId)
return
}
@DHttpApi(fieldApi.routes.listWorkflowNodeField)
async listWorkflowNodeField(@DHttpReqParamRequired("fieldSolutionId") fieldSolutionId:string,@DHttpReqParamRequired("workflowSolutionId") workflowSolutionId:string,@DHttpReqParamRequired("workflowNodeId") workflowNodeId:string,@DHttpReqParamRequired("workflowId") workflowId:string): Promise<typeof fieldApi.routes.listWorkflowNodeField.res> {
let obj=await FieldSolutionService.getItemById(fieldSolutionId)
if(!obj) {
throw Err.Project.Field.fieldSolutionNotFound
}
let ret=await obj.listWorkflowNodeField(workflowNodeId,workflowId,workflowSolutionId)
return ret;
}
@DHttpApi(fieldApi.routes.addWorkflowNodeField)
async addWorkflowNodeField(@DHttpReqParamRequired("fieldSolutionId") fieldSolutionId:string,
@DHttpReqParamRequired("workflowSolutionId") workflowSolutionId:string,
@DHttpReqParamRequired("fieldTypeId") fieldTypeId:string,
@DHttpReqParamRequired("optional") optional:number,
@DHttpReqParam("defaultValue") defaultValue:string,
@DHttpReqParamRequired("name") name:string,
@DHttpReqParamRequired("workflowId") workflowId:string,
@DHttpReqParamRequired("workflowNodeId") workflowNodeId:string,
@DHttpReqParam("description") description:string,
@DHttpReqParam("lable_type") labelType:string): Promise<typeof fieldApi.routes.addWorkflowNodeField.res> {
let obj=await FieldSolutionService.getItemById(fieldSolutionId)
if(!obj) {
throw Err.Project.Field.fieldSolutionNotFound
}
let ret=await obj.addWorkflowNodeField(workflowNodeId,workflowId,workflowSolutionId,fieldTypeId,name,optional,defaultValue,description)
return ret;
}
@DHttpApi(fieldApi.routes.editWorkflowNodeField)
async editWorkflowNodeField(@DHttpReqParamRequired("fieldSolutionWorkflowNodeFieldTypeId") fieldSolutionWorkflowNodeFieldTypeId:string,
@DHttpReqParam("optional") optional:number,
@DHttpReqParam("defaultValue") defaultValue:string,
@DHttpReqParam("name") name:string,
@DHttpReqParam("description") description:string): Promise<typeof fieldApi.routes.editWorkflowNodeField.res> {
let obj=await FieldSolutionService.getObjByFieldSolutionWorkflowNodeFieldTypeId(fieldSolutionWorkflowNodeFieldTypeId)
if(!obj) {
throw Err.Project.Field.fieldSolutionNotFound
}
let ret=await obj.editWorkflowNodeField(fieldSolutionWorkflowNodeFieldTypeId,name,optional,defaultValue,description)
return ret;
}
@DHttpApi(fieldApi.routes.moveWorkflowNodeField)
async moveWorkflowNodeField(@DHttpReqParamRequired("fieldSolutionWorkflowNodeFieldTypeId") fieldSolutionWorkflowNodeFieldTypeId:string,@DHttpReqParamRequired("sort") sort:number): Promise<typeof fieldApi.routes.moveWorkflowNodeField.res> {
let obj=await FieldSolutionService.getObjByFieldSolutionWorkflowNodeFieldTypeId(fieldSolutionWorkflowNodeFieldTypeId)
if(!obj) {
throw Err.Project.Field.fieldSolutionNotFound
}
let ret=await obj.moveWorkflowNodeField(fieldSolutionWorkflowNodeFieldTypeId,sort)
return ret;
}
@DHttpApi(fieldApi.routes.deleteWorkflowNodeField)
async deleteWorkflowNodeField(@DHttpReqParamRequired("fieldSolutionWorkflowNodeFieldTypeId") fieldSolutionWorkflowNodeFieldTypeId:string): Promise<typeof fieldApi.routes.deleteWorkflowNodeField.res> {
let obj=await FieldSolutionService.getObjByFieldSolutionWorkflowNodeFieldTypeId(fieldSolutionWorkflowNodeFieldTypeId)
if(!obj) {
throw Err.Project.Field.fieldSolutionNotFound
}
await obj.deleteWorkflowNodeField(fieldSolutionWorkflowNodeFieldTypeId)
return
}
@DHttpApi(fieldApi.routes.listWorkflowNodeFieldConfig)
async listWorkflowNodeFieldConfig(@DHttpReqParamRequired("fieldSolutionWorkflowNodeFieldTypeId") fieldSolutionWorkflowNodeFieldTypeId:string): Promise<typeof fieldApi.routes.listWorkflowNodeFieldConfig.res> {
let obj=await FieldSolutionService.getObjByFieldSolutionWorkflowNodeFieldTypeId(fieldSolutionWorkflowNodeFieldTypeId)
if(!obj) {
throw Err.Project.Field.fieldSolutionNotFound
}
let ret=await obj.listWorkflowNodeFieldConfig(fieldSolutionWorkflowNodeFieldTypeId)
return ret;
}
@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> {
let obj=await FieldSolutionService.getObjByFieldSolutionWorkflowNodeFieldTypeId(fieldSolutionWorkflowNodeFieldTypeId)
if(!obj) {
throw Err.Project.Field.fieldSolutionNotFound
}
let ret=await obj.addWorkflowNodeFieldConfig(fieldSolutionWorkflowNodeFieldTypeId,value,name,selected)
return ret;
}
@DHttpApi(fieldApi.routes.editWorkflowNodeFieldConfig)
async editWorkflowNodeFieldConfig(@DHttpReqParamRequired("fieldTypeConfigValueId") fieldTypeConfigValueId:string,
@DHttpReqParam("value") value:string,
@DHttpReqParam("name") name:string,
@DHttpReqParam("selected") selected:number): Promise<typeof fieldApi.routes.editWorkflowNodeFieldConfig.res> {
let obj=await FieldSolutionService.getObjByFieldTypeConfigValueId(fieldTypeConfigValueId)
if(!obj) {
throw Err.Project.Field.fieldTypeConfigValueIdNotFound
}
let ret=await obj.editWorkflowNodeFieldConfig(fieldTypeConfigValueId,value,name,selected)
return ret;
}
@DHttpApi(fieldApi.routes.deleteWorkflowNodeFieldConfig)
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
}
await obj.deleteWorkflowNodeFieldConfig(fieldTypeConfigValueId)
return
}
@DHttpApi(fieldApi.routes.workflowFieldsCopy)
async workflowFieldsCopy(@DHttpReqParamRequired("fieldSolutionId") fieldSolutionId:string,
@DHttpReqParamRequired("workflowSolutionId") workflowSolutionId:string,
@DHttpReqParamRequired("workflowId") workflowId:string,
@DHttpReqParamRequired("newFieldSolutionId") newFieldSolutionId:string,
@DHttpReqParamRequired("newWorkflowSolutionId") newWorkflowSolutionId:string): Promise<typeof fieldApi.routes.workflowFieldsCopy.res> {
let obj=await FieldSolutionService.getItemById(fieldSolutionId)
if(!obj) {
throw Err.Project.Field.fieldTypeConfigValueIdNotFound
}
await obj.workflowFieldsCopy(workflowSolutionId,workflowId,newFieldSolutionId,newWorkflowSolutionId)
return
}
}

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

@ -164,7 +164,7 @@ class WorkflowController {
async solutionInfo(@DHttpReqParamRequired("workflowSolutionId") workflowSolutionId:string):Promise<typeof workflowApi.routes.solutionInfo.res> {
let obj=await WorkflowSolutionService.getItemById(workflowSolutionId);
if (!obj) {
throw Err.Project.Workflow.workflowActionNotFound
throw Err.Project.Workflow.workflowSolutionNotFound
}
let ret=await obj.info()
return ret;
@ -173,7 +173,7 @@ class WorkflowController {
async solutionAssign(@DHttpReqParamRequired("workflowSolutionId") workflowSolutionId:string,@DHttpReqParamRequired("issueTypeId") issueTypeId:string,@DHttpReqParamRequired("workflowId") workflowId:string,@DHttpReqParamRequired("issueTypeSolutionId") issueTypeSolutionId:string):Promise<typeof workflowApi.routes.solutionAssign.res> {
let obj=await WorkflowSolutionService.getItemById(workflowSolutionId);
if (!obj) {
throw Err.Project.Workflow.workflowActionNotFound
throw Err.Project.Workflow.workflowSolutionNotFound
}
await obj.assign(issueTypeId,workflowId,issueTypeSolutionId)
return
@ -192,7 +192,7 @@ class WorkflowController {
async solutionUpdate(@DHttpReqParamRequired("workflowSolutionId") workflowSolutionId:string,@DHttpReqParam("name") name:string,@DHttpReqParam("description") description:string):Promise<typeof workflowApi.routes.solutionUpdate.res> {
let obj=await WorkflowSolutionService.getItemById(workflowSolutionId);
if (!obj) {
throw Err.Project.Workflow.workflowActionNotFound
throw Err.Project.Workflow.workflowSolutionNotFound
}
obj.assignItem({
name,
@ -205,7 +205,7 @@ class WorkflowController {
async solutionDelete(@DHttpReqParamRequired("workflowSolutionId") workflowSolutionId:string):Promise<typeof workflowApi.routes.solutionDelete.res> {
let obj=await WorkflowSolutionService.getItemById(workflowSolutionId);
if (!obj) {
throw Err.Project.Workflow.workflowActionNotFound
throw Err.Project.Workflow.workflowSolutionNotFound
}
await obj.delete()
return
@ -214,7 +214,7 @@ class WorkflowController {
async solutionBind(@DHttpReqParamRequired("workflowSolutionId") workflowSolutionId:string,@DHttpReqParamRequired("issueTypeSolutionId") issueTypeSolutionId:string):Promise<typeof workflowApi.routes.solutionBind.res> {
let obj=await WorkflowSolutionService.getItemById(workflowSolutionId);
if (!obj) {
throw Err.Project.Workflow.workflowActionNotFound
throw Err.Project.Workflow.workflowSolutionNotFound
}
await obj.bindIssueTypeSolutions([issueTypeSolutionId])
return
@ -223,7 +223,7 @@ class WorkflowController {
async solutionUnBind(@DHttpReqParamRequired("workflowSolutionId") workflowSolutionId:string,@DHttpReqParamRequired("issueTypeSolutionId") issueTypeSolutionId:string):Promise<typeof workflowApi.routes.solutionUnBind.res> {
let obj=await WorkflowSolutionService.getItemById(workflowSolutionId);
if (!obj) {
throw Err.Project.Workflow.workflowActionNotFound
throw Err.Project.Workflow.workflowSolutionNotFound
}
await obj.unbindIssueTypeSolutions([issueTypeSolutionId])
return
@ -232,10 +232,46 @@ class WorkflowController {
async solutionCopy(@DHttpReqParamRequired("workflowSolutionId") workflowSolutionId:string):Promise<typeof workflowApi.routes.solutionCopy.res> {
let obj=await WorkflowSolutionService.getItemById(workflowSolutionId);
if (!obj) {
throw Err.Project.Workflow.workflowActionNotFound
throw Err.Project.Workflow.workflowSolutionNotFound
}
let ret=await obj.copy()
return ret.getItem()
}
@DHttpApi(workflowApi.routes.solutionListWorkflow)
async solutionListWorkflow(@DHttpReqParamRequired("workflowSolutionId") workflowSolutionId:string):Promise<typeof workflowApi.routes.solutionListWorkflow.res> {
let obj=await WorkflowSolutionService.getItemById(workflowSolutionId);
if (!obj) {
throw Err.Project.Workflow.workflowSolutionNotFound
}
let ret=await obj.listWorkflow()
return ret
}
@DHttpApi(workflowApi.routes.solutionAddWorkflow)
async solutionAddWorkflow(@DHttpReqParamRequired("workflowSolutionId") workflowSolutionId:string,@DHttpReqParamRequired("workflowId") workflowId:string):Promise<typeof workflowApi.routes.solutionAddWorkflow.res> {
let obj=await WorkflowSolutionService.getItemById(workflowSolutionId);
if (!obj) {
throw Err.Project.Workflow.workflowSolutionNotFound
}
let workflow=await WorkflowService.getItemById(workflowId)
if(workflow && workflow.getItem().reserved) {
throw Err.Project.Workflow.workflowSolutionForbidden
}
await obj.addWorkflow(workflowId)
return
}
@DHttpApi(workflowApi.routes.solutionRemoveWorkflow)
async solutionRemoveWorkflow(@DHttpReqParamRequired("workflowSolutionId") workflowSolutionId:string,@DHttpReqParamRequired("workflowId") workflowId:string):Promise<typeof workflowApi.routes.solutionRemoveWorkflow.res> {
let obj=await WorkflowSolutionService.getItemById(workflowSolutionId);
if (!obj) {
throw Err.Project.Workflow.workflowSolutionNotFound
}
let workflow=await WorkflowService.getItemById(workflowId)
if(workflow && workflow.getItem().reserved) {
throw Err.Project.Workflow.workflowSolutionForbidden
}
await obj.removeWorkflow(workflowId)
return
}
}

584
code/server/cooperation/mapper/field.ts Normal file
View File

@ -0,0 +1,584 @@
import { fieldSolutionModel } from '../../../common/model/field_solution';
import { fieldSolutionWorkflowNodeFieldTypeModel, 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 { ICommon_Model_Workflow_Solution, workflowSolutionModel } from '../../../common/model/workflow_solution';
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 { 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';
import { fieldTypeModel, ICommon_Model_Field_Type } from './../../../common/model/field_type';
import { fieldTypeConfigValueModel } from './../../../common/model/field_type_config_value';
class FieldTypeMapper extends Mapper<typeof fieldTypeModel> {
constructor() {
super(fieldTypeModel)
}
async list():Promise<ICommon_Model_Field_Type[]>
{
let mysql=getMysqlInstance()
let ret=await mysql.execute(generateQuerySql(fieldTypeModel,[],null,null,{
field:"name",
type:"asc"
}))
return ret;
}
}
export let fieldTypeMapper=new FieldTypeMapper
class FieldSolutionMapper extends Mapper<typeof fieldSolutionModel> {
constructor() {
super(fieldSolutionModel)
}
async list():Promise<ICommon_Model_Field_Solution[]>
{
let mysql=getMysqlInstance()
let ret=await mysql.execute(generateQuerySql(fieldSolutionModel,[],null,null,{
field:"name",
type:"asc"
}))
return ret;
}
async getBindWorkflowSolutionList(fieldSolutionId:string):Promise<ICommon_Model_Workflow_Solution[]> {
if(!fieldSolutionId) {
throw Err.Project.Field.fieldSolutionNotFound
}
let mysql=getMysqlInstance()
let sql=generateLeftJoinSql({
model:fieldSolutionWorkflowSolutionModel
},{
model:workflowSolutionModel,
columns:keys<ICommon_Model_Workflow_Solution>().map(item=>item.name),
expression:{
id:{
model:fieldSolutionWorkflowSolutionModel,
field:"workflow_solution_id"
}
}
},{
field_solution_id:{
model:fieldSolutionWorkflowSolutionModel,
value:fieldSolutionId
}
})
let ret=await mysql.execute(sql)
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,
values?:ICommon_Model_Field_Type_Config_Value[]
}[]> {
if(!fieldSolutionId) {
throw Err.Project.Field.fieldSolutionNotFound
} else if(!workflowNodeId) {
throw Err.Project.Workflow.workflowNodeNotFound
} else if(!workflowId) {
throw Err.Project.Workflow.workflowNotFound
} else if(!workflowSolutionId) {
throw Err.Project.Workflow.workflowSolutionNotFound
}
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"
},{
field_solution_id:{
model:fieldSolutionWorkflowNodeFieldTypeModel,
value:fieldSolutionId
},
workflow_id:{
model:fieldSolutionWorkflowNodeFieldTypeModel,
value:workflowId
},
workflow_node_id:{
model:fieldSolutionWorkflowNodeFieldTypeModel,
value:workflowNodeId
},
workflow_solution_id:{
model:fieldSolutionWorkflowNodeFieldTypeModel,
value:workflowSolutionId
}
},"and",{
model:fieldSolutionWorkflowNodeFieldTypeModel,
field:"sort",
type:"asc"
})
let arrField=await mysql.execute(sql)
let ret:{
field:ICommon_Model_Field_Solution_Workflow_Node_Field_Type,
fieldType:ICommon_Model_Field_Type,
values?:ICommon_Model_Field_Type_Config_Value[]
}[]=[]
for(let objField of arrField) {
let objFieldType=objField.fieldType
delete objField.fieldType
let obj:{
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
}))
obj.values=arrValues
ret.push(obj)
}
return ret;
}
async clearFieldSolution(fieldSolutionId:string) {
if(!fieldSolutionId) {
throw Err.Project.Field.fieldSolutionNotFound
}
let mysql=getMysqlInstance()
await mysql.execute(generateDeleteSql(fieldSolutionWorkflowSolutionModel,{
field_solution_id:fieldSolutionId
}))
let arrField=await mysql.execute(generateQuerySql(fieldSolutionWorkflowNodeFieldTypeModel,["id"],{
field_solution_id:fieldSolutionId
}))
await mysql.execute(generateDeleteSql(fieldSolutionWorkflowNodeFieldTypeModel,{
field_solution_id:fieldSolutionId
}))
if(arrField.length>0) {
await mysql.execute(generateDeleteSql(fieldTypeConfigValueModel,{
field_solution_workflow_node_field_type_id:{
exp:"in",
value:arrField.map(item=>item.id)
}
}))
}
}
async clearItemsByWorkflowId(workflowId:string) {
if(!workflowId) {
throw Err.Project.Workflow.workflowNotFound
}
let mysql=getMysqlInstance()
let arr=await mysql.execute(generateQuerySql(fieldSolutionWorkflowNodeFieldTypeModel,["id"],{
workflow_id:workflowId
}))
await mysql.execute(generateDeleteSql(fieldSolutionWorkflowNodeFieldTypeModel,{
workflow_id:workflowId
}))
if(arr.length>0) {
await mysql.execute(generateDeleteSql(fieldTypeConfigValueModel,{
field_solution_workflow_node_field_type_id:{
exp:"in",
value:arr.map(item=>item.id)
}
}))
}
}
async bindWorkflowSolution(fieldSolutionId:string,workflowSolutionId:string) {
if(!fieldSolutionId) {
throw Err.Project.Field.fieldSolutionNotFound
} else if(!workflowSolutionId) {
throw Err.Project.Workflow.workflowSolutionNotFound
}
let mysql=getMysqlInstance()
await mysql.execute(generateCreateSql(fieldSolutionWorkflowSolutionModel,{
id:await generateSnowId(),
field_solution_id:fieldSolutionId,
workflow_solution_id:workflowSolutionId
}))
}
async unbindWorkflowSolution(fieldSolutionId:string,workflowSolutionId:string) {
if(!fieldSolutionId) {
throw Err.Project.Field.fieldSolutionNotFound
} else if(!workflowSolutionId) {
throw Err.Project.Workflow.workflowSolutionNotFound
}
let mysql=getMysqlInstance()
await mysql.execute(generateDeleteSql(fieldSolutionWorkflowSolutionModel,{
field_solution_id:fieldSolutionId,
workflow_solution_id:workflowSolutionId
}))
let arrField=await mysql.execute(generateQuerySql(fieldSolutionWorkflowNodeFieldTypeModel,["id"],{
field_solution_id:fieldSolutionId,
workflow_solution_id:workflowSolutionId
}))
await mysql.execute(generateDeleteSql(fieldSolutionWorkflowNodeFieldTypeModel,{
field_solution_id:fieldSolutionId,
workflow_solution_id:workflowSolutionId
}))
if(arrField.length>0) {
await mysql.execute(generateDeleteSql(fieldTypeConfigValueModel,{
field_solution_workflow_node_field_type_id:{
exp:"in",
value:arrField.map(item=>item.id)
}
}))
}
}
async checkWorkflowSolution(fieldSolutionId:string,workflowSolutionId:string):Promise<boolean> {
if(!fieldSolutionId) {
throw Err.Project.Field.fieldSolutionNotFound
} else if(!workflowSolutionId) {
throw Err.Project.Workflow.workflowSolutionNotFound
}
let mysql=getMysqlInstance()
let ret=await mysql.executeOne(generateQuerySql(fieldSolutionWorkflowSolutionModel,["id"],{
field_solution_id:fieldSolutionId,
workflow_solution_id:workflowSolutionId
}))
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):Promise<ICommon_Model_Field_Solution_Workflow_Node_Field_Type> {
if(!fieldSolutionId) {
throw Err.Project.Field.fieldSolutionNotFound
} else if(!workflowNodeId) {
throw Err.Project.Workflow.workflowNodeNotFound
} else if(!workflowId) {
throw Err.Project.Workflow.workflowNotFound
} else if(!workflowSolutionId) {
throw Err.Project.Workflow.workflowSolutionNotFound
} else if(!fieldTypeId) {
throw Err.Project.Field.fieldTypeNotFound
}
let sort=0,mysql=getMysqlInstance()
let existSort=await mysql.executeOne(generateMaxSql(fieldSolutionWorkflowNodeFieldTypeModel,"sort",{
field_solution_id:fieldSolutionId,
workflow_node_id:workflowNodeId,
workflow_id:workflowId,
workflow_solution_id:workflowSolutionId
}))
if(existSort && existSort.sort) {
sort=existSort.sort+1
}
let id=await generateSnowId()
await mysql.execute(generateCreateSql(fieldSolutionWorkflowNodeFieldTypeModel,{
field_solution_id:fieldSolutionId,
workflow_node_id:workflowNodeId,
workflow_id:workflowId,
workflow_solution_id:workflowSolutionId,
id:id,
field_type_id:fieldTypeId,
name,
default_value:defaultValue,
optional,
description,
sort,
label_type:labelType
}))
let ret=await mysql.executeOne(generateQuerySql(fieldSolutionWorkflowNodeFieldTypeModel,[],{
id:id
}))
return ret;
}
async editWorkflowNodeField(fieldSolutionWorkflowNodeFieldTypeId:string,name?:string,optional?:number,defaultValue?:string,description?:string,labelType?:ECommon_Model_Field_Solution_Workflow_Node_Field_Type_Label_Type):Promise<ICommon_Model_Field_Solution_Workflow_Node_Field_Type> {
if(!fieldSolutionWorkflowNodeFieldTypeId) {
throw Err.Project.Field.fieldSolutionWorkflowNodeFieldTypeNotFound
}
let mysql=getMysqlInstance()
await mysql.execute(generateUpdateSql(fieldSolutionWorkflowNodeFieldTypeModel,{
name,
optional,
default_value:defaultValue,
description,
label_type:labelType
},{
id:fieldSolutionWorkflowNodeFieldTypeId
}))
let ret=await mysql.executeOne(generateQuerySql(fieldSolutionWorkflowNodeFieldTypeModel,[],{
id:fieldSolutionWorkflowNodeFieldTypeId
}))
return ret;
}
async deleteWorkflowNodeField(fieldSolutionWorkflowNodeFieldTypeId:string) {
if(!fieldSolutionWorkflowNodeFieldTypeId) {
throw Err.Project.Field.fieldSolutionWorkflowNodeFieldTypeNotFound
}
let mysql=getMysqlInstance()
let obj=await mysql.executeOne(generateQuerySql(fieldSolutionWorkflowNodeFieldTypeModel,[],{
id:fieldSolutionWorkflowNodeFieldTypeId
}))
if(obj) {
await mysql.execute(generateDeleteSql(fieldSolutionWorkflowNodeFieldTypeModel,{
id:fieldSolutionWorkflowNodeFieldTypeId
}))
await mysql.execute(generateDeleteSql(fieldTypeConfigValueModel,{
field_solution_workflow_node_field_type_id:fieldSolutionWorkflowNodeFieldTypeId
}))
await mysql.execute(generateUpdateSql(fieldSolutionWorkflowNodeFieldTypeModel,{
sort:{
exp:"-",
value:1
}
},{
field_solution_id:obj.field_solution_id,
workflow_node_id:obj.workflow_node_id,
workflow_id:obj.workflow_id,
workflow_solution_id:obj.workflow_solution_id,
sort:{
exp:">",
value:obj.sort
}
}))
}
}
async moveWorkflowNodeField(fieldSolutionWorkflowNodeFieldTypeId:string,sort:number) {
if(!fieldSolutionWorkflowNodeFieldTypeId) {
throw Err.Project.Field.fieldSolutionWorkflowNodeFieldTypeNotFound
}
let mysql=getMysqlInstance()
let obj=await mysql.executeOne(generateQuerySql(fieldSolutionWorkflowNodeFieldTypeModel,[],{
id:fieldSolutionWorkflowNodeFieldTypeId
}))
if(obj) {
if(sort>obj.sort) {
await mysql.execute(generateUpdateSql(fieldSolutionWorkflowNodeFieldTypeModel,{
sort:{
exp:"-",
value:1
}
},{
field_solution_id:obj.field_solution_id,
workflow_node_id:obj.workflow_node_id,
workflow_id:obj.workflow_id,
workflow_solution_id:obj.workflow_solution_id,
sort:{
exp:"> <=",
value:[obj.sort,sort]
}
}))
await mysql.executeOne(generateUpdateSql(fieldSolutionWorkflowNodeFieldTypeModel,{
sort
},{
id:fieldSolutionWorkflowNodeFieldTypeId
}))
} else if(sort<obj.sort) {
await mysql.execute(generateUpdateSql(fieldSolutionWorkflowNodeFieldTypeModel,{
sort:{
exp:"+",
value:1
}
},{
field_solution_id:obj.field_solution_id,
workflow_node_id:obj.workflow_node_id,
workflow_id:obj.workflow_id,
workflow_solution_id:obj.workflow_solution_id,
sort:{
exp:">= <",
value:[sort,obj.sort]
}
}))
await mysql.executeOne(generateUpdateSql(fieldSolutionWorkflowNodeFieldTypeModel,{
sort
},{
id:fieldSolutionWorkflowNodeFieldTypeId
}))
}
let ret=await mysql.executeOne(generateQuerySql(fieldSolutionWorkflowNodeFieldTypeModel,[],{
id:fieldSolutionWorkflowNodeFieldTypeId
}))
return ret;
} else {
return null;
}
}
async listWorkflowNodeFieldConfig(fieldSolutionWorkflowNodeFieldTypeId:string):Promise<ICommon_Model_Field_Type_Config_Value[]> {
if(!fieldSolutionWorkflowNodeFieldTypeId) {
throw Err.Project.Field.fieldSolutionWorkflowNodeFieldTypeNotFound
}
let mysql=getMysqlInstance()
let ret=await mysql.execute(generateQuerySql(fieldTypeConfigValueModel,[],{
field_solution_workflow_node_field_type_id:fieldSolutionWorkflowNodeFieldTypeId
},"and",{
field:"name",
type:"asc"
}))
return ret;
}
async addWorkflowNodeFieldConfig(fieldSolutionWorkflowNodeFieldTypeId :string,value :string,name :string,selected :number):Promise<ICommon_Model_Field_Type_Config_Value> {
if(!fieldSolutionWorkflowNodeFieldTypeId) {
throw Err.Project.Field.fieldSolutionWorkflowNodeFieldTypeNotFound
}
let mysql=getMysqlInstance()
let id=await generateSnowId()
await mysql.execute(generateCreateSql(fieldTypeConfigValueModel,{
id:id,
field_solution_workflow_node_field_type_id:fieldSolutionWorkflowNodeFieldTypeId,
value:value,
name:name,
selected:selected
}))
let ret=await mysql.executeOne(generateQuerySql(fieldTypeConfigValueModel,[],{
id
}))
return ret;
}
async getFieldByNodeFieldTypeId(fieldSolutionWorkflowNodeFieldTypeId :string) {
if(!fieldSolutionWorkflowNodeFieldTypeId) {
throw Err.Project.Field.fieldSolutionWorkflowNodeFieldTypeNotFound
}
let mysql=getMysqlInstance()
let ret=await mysql.executeOne(generateQuerySql(fieldSolutionWorkflowNodeFieldTypeModel,[],{
id:fieldSolutionWorkflowNodeFieldTypeId
}))
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
}
let mysql=getMysqlInstance()
await mysql.execute(generateUpdateSql(fieldTypeConfigValueModel,{
name,
value,
selected
},{
id:fieldTypeConfigValueId
}))
let ret=await mysql.executeOne(generateQuerySql(fieldTypeConfigValueModel,[],{
id:fieldTypeConfigValueId
}))
return ret;
}
async deleteWorkflowNodeFieldConfig(fieldTypeConfigValueId :string) {
if(!fieldTypeConfigValueId) {
throw Err.Project.Field.fieldTypeConfigValueIdNotFound
}
let mysql=getMysqlInstance()
await mysql.execute(generateDeleteSql(fieldTypeConfigValueModel,{
id:fieldTypeConfigValueId
}))
}
async getSolutionByFieldSolutionWorkflowNodeFieldTypeId(fieldSolutionWorkflowNodeFieldTypeId:string) {
if(!fieldSolutionWorkflowNodeFieldTypeId) {
throw Err.Project.Field.fieldSolutionWorkflowNodeFieldTypeNotFound
}
let mysql=getMysqlInstance()
let obj=await mysql.executeOne(generateQuerySql(fieldSolutionWorkflowNodeFieldTypeModel,[],{
id:fieldSolutionWorkflowNodeFieldTypeId
}))
if(!obj) {
throw Err.Project.Field.fieldSolutionWorkflowNodeFieldTypeNotFound
}
let ret=await mysql.executeOne(generateQuerySql(fieldSolutionModel,[],{
id:obj.field_solution_id
}))
return ret;
}
async getSolutionByFieldTypeConfigTypeId(fieldTypeConfigTypeId:string) {
if(!fieldTypeConfigTypeId) {
throw Err.Project.Field.fieldTypeConfigValueIdNotFound
}
let mysql=getMysqlInstance()
let obj=await mysql.executeOne(generateQuerySql(fieldTypeConfigValueModel,[],{
id:fieldTypeConfigTypeId
}))
if(!obj) {
throw Err.Project.Field.fieldTypeConfigValueIdNotFound
}
let obj1=await mysql.executeOne(generateQuerySql(fieldSolutionWorkflowNodeFieldTypeModel,[],{
id:obj.field_solution_workflow_node_field_type_id
}))
if(!obj1) {
throw Err.Project.Field.fieldSolutionWorkflowNodeFieldTypeNotFound
}
let ret=await mysql.executeOne(generateQuerySql(fieldSolutionModel,[],{
id:obj1.field_solution_id
}))
return ret;
}
async workflowFieldsCopy(fieldSolutionId:string,workflowSolutionId:string,workflowId:string,newFieldSolutionId:string,newWorkflowSolutionId:string) {
if(!fieldSolutionId) {
throw Err.Project.Field.fieldSolutionNotFound
} else if(!workflowSolutionId) {
throw Err.Project.Workflow.workflowSolutionNotFound
} else if(!workflowId) {
throw Err.Project.Workflow.workflowNotFound
} else if(!newFieldSolutionId) {
throw Err.Project.Field.fieldSolutionNotFound
} else if(!newWorkflowSolutionId) {
throw Err.Project.Workflow.workflowSolutionNotFound
}
let mysql=getMysqlInstance()
let arrFields=await mysql.execute(generateQuerySql(fieldSolutionWorkflowNodeFieldTypeModel,[],{
field_solution_id:fieldSolutionId,
workflow_solution_id:workflowSolutionId,
workflow_id:workflowId
}))
let arrConfigValues:ICommon_Model_Field_Type_Config_Value[]=[]
if(arrFields.length>0) {
arrConfigValues=await mysql.execute(generateQuerySql(fieldTypeConfigValueModel,[],{
field_solution_workflow_node_field_type_id:{
exp:"in",
value:arrFields.map(item=>item.id)
}
}))
}
let objConfigValue=<{
[param:string]:ICommon_Model_Field_Type_Config_Value[]
}>{}
for(let obj of arrConfigValues) {
obj.id=await generateSnowId()
if(objConfigValue[obj.field_solution_workflow_node_field_type_id]) {
objConfigValue[obj.field_solution_workflow_node_field_type_id].push(obj)
} else {
objConfigValue[obj.field_solution_workflow_node_field_type_id]=[obj]
}
}
for(let obj of arrFields) {
let id=obj.id
obj.id=await generateSnowId()
obj.workflow_id=workflowId
obj.workflow_solution_id=newWorkflowSolutionId
obj.field_solution_id=newFieldSolutionId
if(objConfigValue[id]) {
for(let o of objConfigValue[id]) {
o.field_solution_workflow_node_field_type_id=id
}
}
}
await mysql.execute(generateBatchCreateSql(fieldSolutionWorkflowNodeFieldTypeModel,arrFields))
let arr:ICommon_Model_Field_Type_Config_Value[]=[]
for(let id in objConfigValue) {
for(let obj of objConfigValue[id]) {
arr.push(obj)
}
}
if(arr.length>0) {
await mysql.execute(generateBatchCreateSql(fieldTypeConfigValueModel,arr))
}
}
}
export let fieldSolutionMapper=new FieldSolutionMapper

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

@ -1,6 +1,7 @@
import { ICommon_Model_Issue_Type } from "../../../common/model/issue_type";
import { workflowSolutionModel } from "../../../common/model/workflow_solution";
import { workflowSolutionIssueTypeSolutionModel } from "../../../common/model/workflow_solution_issue_type_solution";
import { workflowSolutionWorkflowModel } from "../../../common/model/workflow_solution_workflow";
import { workflowSolutionWorkflowIssueTypeModel } from "../../../common/model/workflow_solution_workflow_issue_type";
import { Err } from '../../../common/status/error';
import { keys } from "../../../common/transform";
@ -68,6 +69,34 @@ class WorkflowMapper extends Mapper<typeof workflowModel> {
}))
}
async checkNode(workflowId:string,workflowNodeId:string):Promise<boolean> {
if(!workflowId) {
throw Err.Project.Workflow.workflowNotFound
} else if(!workflowNodeId) {
throw Err.Project.Workflow.workflowNodeNotFound
}
let mysql=getMysqlInstance()
let ret=await mysql.executeOne(generateQuerySql(workflowNodeModel,["id"],{
workflow_id:workflowId,
id:workflowNodeId
}))
return ret!=null
}
async checkAction(workflowId:string,workflowActionId:string):Promise<boolean> {
if(!workflowId) {
throw Err.Project.Workflow.workflowNotFound
} else if(!workflowActionId) {
throw Err.Project.Workflow.workflowActionNotFound
}
let mysql=getMysqlInstance()
let ret=await mysql.executeOne(generateQuerySql(workflowActionModel,["id"],{
workflow_id:workflowId,
id:workflowActionId
}))
return ret!=null
}
}
export let workflowMapper=new WorkflowMapper
@ -129,7 +158,8 @@ class WorkflowSolutionMapper extends Mapper<typeof workflowSolutionModel> {
id:await generateSnowId(),
workflow_id:workflowId,
issue_type_id:obj.id,
issue_type_solution_id:issueTypeSolutionId
issue_type_solution_id:issueTypeSolutionId,
workflow_solution_id:workflowSolutionId
}))
}
}
@ -277,6 +307,9 @@ class WorkflowSolutionMapper extends Mapper<typeof workflowSolutionModel> {
await mysql.execute(generateDeleteSql(workflowSolutionWorkflowIssueTypeModel,{
workflow_solution_id:workflowSolutionId
}))
await mysql.execute(generateDeleteSql(workflowSolutionWorkflowModel,{
workflow_solution_id:workflowSolutionId
}))
}
async deleteIssueType(workflowSolutionId:string,issueTypeId:string,issueTypeSolutionId:string) {
@ -304,6 +337,90 @@ class WorkflowSolutionMapper extends Mapper<typeof workflowSolutionModel> {
issue_type_id:issueTypeId
}))
}
async addWorkflow(workflowSolutionId:string,workflowId:string) {
if(!workflowSolutionId) {
throw Err.Project.Workflow.workflowSolutionNotFound
} else if(!workflowId) {
throw Err.Project.Workflow.workflowNotFound
}
let mysql=getMysqlInstance()
let obj=await mysql.executeOne(generateQuerySql(workflowSolutionWorkflowModel,["id"],{
workflow_id:workflowId,
workflow_solution_id:workflowSolutionId
}))
if(!obj) {
await mysql.execute(generateCreateSql(workflowSolutionWorkflowModel,{
id:await generateSnowId(),
workflow_id:workflowId,
workflow_solution_id:workflowSolutionId
}))
}
}
async removeWorkflow(workflowSolutionId:string,workflowId:string) {
if(!workflowSolutionId) {
throw Err.Project.Workflow.workflowSolutionNotFound
} else if(!workflowId) {
throw Err.Project.Workflow.workflowNotFound
}
let mysql=getMysqlInstance()
await mysql.execute(generateDeleteSql(workflowSolutionWorkflowModel,{
workflow_id:workflowId,
workflow_solution_id:workflowSolutionId
}))
}
async listWorkflow(workflowSolutionId:string):Promise<ICommon_Model_Workflow[]> {
if(!workflowSolutionId) {
throw Err.Project.Workflow.workflowSolutionNotFound
}
let mysql=getMysqlInstance()
let sql=generateLeftJoinSql({
model:workflowSolutionWorkflowModel
},{
model:workflowModel,
columns:keys<ICommon_Model_Workflow>().map(item=>item.name),
expression:{
id:{
model:workflowSolutionWorkflowModel,
field:"workflow_id"
}
}
},{
workflow_solution_id:{
model:workflowSolutionWorkflowModel,
value:workflowSolutionId
}
})
let ret=await mysql.execute(sql)
return ret;
}
async checkWorkflow(workflowSolutionId:string,workflowId:string) {
if(!workflowSolutionId) {
throw Err.Project.Workflow.workflowSolutionNotFound
} else if(!workflowId) {
throw Err.Project.Workflow.workflowNotFound
}
let mysql=getMysqlInstance()
let ret=await mysql.executeOne(generateQuerySql(workflowSolutionWorkflowModel,["id"],{
workflow_id:workflowId,
workflow_solution_id:workflowSolutionId
}))
return ret!=null
}
async getItemsByIssueTypeSolutionId(issueTypeSolutionId:string) {
if(!issueTypeSolutionId) {
throw Err.Project.Issue.issueTypeSolutionNotFound
}
let mysql=getMysqlInstance()
let ret=await mysql.execute(generateQuerySql(workflowSolutionIssueTypeSolutionModel,[],{
issue_type_solution_id:issueTypeSolutionId
}))
return ret
}
}
export let workflowSolutionMapper=new WorkflowSolutionMapper

246
code/server/cooperation/service/field.ts Normal file
View File

@ -0,0 +1,246 @@
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 { ICommon_Route_Res_FieldSolution_Info } from './../../../common/routes/response';
import { fieldSolutionMapper, fieldTypeMapper } from './../mapper/field';
import WorkflowService, { WorkflowSolutionService } from './workflow';
export default class FieldType extends Entity<typeof fieldTypeModel,typeof fieldTypeMapper> {
constructor(){
super(fieldTypeMapper)
}
static async list(){
let ret=await fieldTypeMapper.list()
return ret;
}
}
export class FieldSolutionService extends Entity<typeof fieldSolutionModel,typeof fieldSolutionMapper> {
constructor(){
super(fieldSolutionMapper)
}
static async list(){
let ret=await fieldSolutionMapper.list()
return ret;
}
async info() :Promise<ICommon_Route_Res_FieldSolution_Info>{
let ret:ICommon_Route_Res_FieldSolution_Info={
data:[],
...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;
}
override async delete(eventPulish?: EServer_Common_Event_Types.Types): Promise<void> {
await super.delete()
await fieldSolutionMapper.clearFieldSolution(this.getId())
}
async bindWorkflowSolution(workflowSolutionId:string){
let objWorkflowSolution=await WorkflowSolutionService.getItemById(workflowSolutionId)
if(!objWorkflowSolution) {
throw Err.Project.Workflow.workflowSolutionNotFound
}
let isIn=await this.checkWorkflowSolution(workflowSolutionId)
if(isIn) {
throw Err.Project.Field.workflowSolutionAlreadyBind
}
await fieldSolutionMapper.bindWorkflowSolution(this.getId(),workflowSolutionId);
}
async unbindWorkflowSolution(workflowSolutionId:string) {
let objWorkflowSolution=await WorkflowSolutionService.getItemById(workflowSolutionId)
if(!objWorkflowSolution) {
throw Err.Project.Workflow.workflowSolutionNotFound
}
await fieldSolutionMapper.unbindWorkflowSolution(this.getId(),workflowSolutionId);
}
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) {
if(!workflowNodeId) {
throw Err.Project.Workflow.workflowNodeNotFound
} else if(!workflowId) {
throw Err.Project.Workflow.workflowNotFound
} else if(!workflowSolutionId) {
throw Err.Project.Workflow.workflowSolutionNotFound
} else if(!fieldTypeId) {
throw Err.Project.Field.fieldTypeNotFound
}
let isBind=await fieldSolutionMapper.checkWorkflowSolution(this.getId(),workflowSolutionId)
if(!isBind) {
throw Err.Project.Field.workflowSolutionNotBind
}
let workflowSolution=await WorkflowSolutionService.getItemById(workflowSolutionId)
if(!workflowSolution) {
throw Err.Project.Workflow.workflowSolutionNotFound
}
let isIn=await workflowSolution.checkWorkFlowAndNodeRelation(workflowId,workflowNodeId)
if(!isIn) {
throw Err.Project.Workflow.workflowNotInWorkflowSolution
}
let ret=await fieldSolutionMapper.addWorkflowNodeField(this.getId(),workflowNodeId,workflowId,workflowSolutionId,fieldTypeId,name,optional,defaultValue,description,labelType);
return ret;
}
async listWorkflowNodeField(workflowNodeId:string,workflowId:string,workflowSolutionId:string) {
if(!workflowNodeId) {
throw Err.Project.Workflow.workflowNodeNotFound
} else if(!workflowId) {
throw Err.Project.Workflow.workflowNotFound
} else if(!workflowSolutionId) {
throw Err.Project.Workflow.workflowSolutionNotFound
}
let workflowSolution=await WorkflowSolutionService.getItemById(workflowSolutionId)
if(!workflowSolution) {
throw Err.Project.Workflow.workflowSolutionNotFound
}
let isIn=await workflowSolution.checkWorkFlowAndNodeRelation(workflowId,workflowNodeId)
if(!isIn) {
throw Err.Project.Workflow.workflowNotInWorkflowSolution
}
let ret=await fieldSolutionMapper.getWorkflowNodeFieldList(this.getId(),workflowNodeId,workflowId,workflowSolutionId);
return ret;
}
static async clearItemsByWorkflowId(workflowId:string) {
if(!workflowId) {
throw Err.Project.Workflow.workflowNotFound
}
await fieldSolutionMapper.clearItemsByWorkflowId(workflowId)
}
static async getObjByFieldSolutionWorkflowNodeFieldTypeId(fieldSolutionWorkflowNodeFieldTypeId:string) {
let ret=new FieldSolutionService
let obj=await fieldSolutionMapper.getSolutionByFieldSolutionWorkflowNodeFieldTypeId(fieldSolutionWorkflowNodeFieldTypeId)
if(obj) {
ret.setItem(obj)
return ret;
}
return null
}
static async getObjByFieldTypeConfigValueId(fieldTypeConfigValueId:string) {
let ret=new FieldSolutionService
let obj=await fieldSolutionMapper.getSolutionByFieldTypeConfigTypeId(fieldTypeConfigValueId)
if(obj) {
ret.setItem(obj)
return ret;
}
return null
}
async editWorkflowNodeField(fieldSolutionWorkflowNodeFieldTypeId:string,name?:string,optional?:number,defaultValue?:string,description?:string,labelType?:ECommon_Model_Field_Solution_Workflow_Node_Field_Type_Label_Type) {
let ret=await fieldSolutionMapper.editWorkflowNodeField(fieldSolutionWorkflowNodeFieldTypeId,name,optional,defaultValue,description,labelType)
return ret;
}
async deleteWorkflowNodeField(fieldSolutionWorkflowNodeFieldTypeId:string) {
await fieldSolutionMapper.deleteWorkflowNodeField(fieldSolutionWorkflowNodeFieldTypeId);
}
async moveWorkflowNodeField(fieldSolutionWorkflowNodeFieldTypeId:string,sort:number) {
let ret=await fieldSolutionMapper.moveWorkflowNodeField(fieldSolutionWorkflowNodeFieldTypeId,sort)
return ret;
}
async listWorkflowNodeFieldConfig(fieldSolutionWorkflowNodeFieldTypeId:string) {
let ret=await fieldSolutionMapper.listWorkflowNodeFieldConfig(fieldSolutionWorkflowNodeFieldTypeId)
return ret;
}
async addWorkflowNodeFieldConfig(fieldSolutionWorkflowNodeFieldTypeId :string,value :string,name :string,selected :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().multi) {
throw Err.Project.Field.fieldTypeNotMatch
}
let ret=await fieldSolutionMapper.addWorkflowNodeFieldConfig(fieldSolutionWorkflowNodeFieldTypeId,value,name,selected)
return ret;
}
async editWorkflowNodeFieldConfig(fieldTypeConfigValueId :string,value? :string,name? :string,selected? :number) {
let ret=await fieldSolutionMapper.editWorkflowNodeFieldConfig(fieldTypeConfigValueId,value,name,selected)
return ret;
}
async deleteWorkflowNodeFieldConfig(fieldTypeConfigValueId :string) {
await fieldSolutionMapper.deleteWorkflowNodeFieldConfig(fieldTypeConfigValueId)
}
async checkWorkflowSolution(workflowSolutionId:string) {
let ret=await fieldSolutionMapper.checkWorkflowSolution(this.getId(),workflowSolutionId)
return ret;
}
async workflowFieldsCopy(workflowSolutionId:string,workflowId:string,newFieldSolutionId:string,newWorkflowSolutionId:string) {
let workflowSolution=await WorkflowSolutionService.getItemById(workflowSolutionId)
if(!workflowSolution) {
throw Err.Project.Workflow.workflowSolutionNotFound
}
let isIn=await workflowSolution.checkWorkflow(workflowId)
if(!isIn) {
throw Err.Project.Workflow.workflowNotInWorkflowSolution
}
isIn=await this.checkWorkflowSolution(workflowSolutionId)
if(!isIn) {
throw Err.Project.Field.workflowSolutionNotBind
}
let newFieldSolution=await FieldSolutionService.getItemById(newFieldSolutionId)
if(!newFieldSolution) {
throw Err.Project.Field.fieldSolutionNotFound
}
let newWorkflowSolution=await WorkflowSolutionService.getItemById(newWorkflowSolutionId)
if(!newWorkflowSolution) {
throw Err.Project.Workflow.workflowSolutionNotFound
}
isIn=await newWorkflowSolution.checkWorkflow(workflowId)
if(!isIn) {
throw Err.Project.Workflow.workflowNotInWorkflowSolution
}
isIn=await newFieldSolution.checkWorkflowSolution(newWorkflowSolutionId)
if(!isIn) {
throw Err.Project.Field.workflowSolutionNotBind
}
await fieldSolutionMapper.workflowFieldsCopy(this.getId(),workflowSolutionId,workflowId,newFieldSolutionId,newWorkflowSolutionId)
}
}

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

@ -1,6 +1,9 @@
import { ICommon_Model_Field_Solution_Workflow_Node_Field_Type } from "../../../common/model/field_solution_workflow_node_field_type";
import { ICommon_Model_Field_Type } from "../../../common/model/field_type";
import { ICommon_Model_Field_Type_Config_Value } from "../../../common/model/field_type_config_value";
import { workflowModel } from "../../../common/model/workflow";
import { workflowActionModel } from "../../../common/model/workflow_action";
import { workflowSolutionModel } from "../../../common/model/workflow_solution";
import { ICommon_Model_Workflow_Solution, workflowSolutionModel } from "../../../common/model/workflow_solution";
import { ICommon_Route_Res_Workflow_Info, ICommon_Route_Res_Workflow_Info_Action, ICommon_Route_Res_Workflow_Info_Node } from "../../../common/routes/response";
import { Err } from "../../../common/status/error";
import { Entity } from "../../common/entity/entity";
@ -8,6 +11,7 @@ import { EServer_Common_Event_Types } from "../../common/event/types";
import { ECommon_Model_Workflow_Node_Status, ICommon_Model_Workflow_Node, workflowNodeModel } from './../../../common/model/workflow_node';
import { ICommon_Route_Res_WorkflowSolution_Info } from './../../../common/routes/response';
import { workflowActionMapper, workflowMapper, workflowNodeMapper, workflowSolutionMapper } from './../mapper/workflow';
import { FieldSolutionService } from './field';
export default class Workflow extends Entity<typeof workflowModel,typeof workflowMapper> {
constructor(){
super(workflowMapper)
@ -22,15 +26,16 @@ export default class Workflow extends Entity<typeof workflowModel,typeof workflo
workflow.setItem(ret);
return workflow;
}
async info():Promise<ICommon_Route_Res_Workflow_Info> {
async accessNodesAndActions(fieldsCallback:(nodeId:string)=>Promise<{
field:ICommon_Model_Field_Solution_Workflow_Node_Field_Type,
fieldType:ICommon_Model_Field_Type,
values?:ICommon_Model_Field_Type_Config_Value[]
}[]>=null):Promise<ICommon_Route_Res_Workflow_Info_Node> {
let nodeList=await workflowMapper.nodeList(this.getId());
let actionList=await workflowMapper.actionList(this.getId());
let obj:ICommon_Route_Res_Workflow_Info={
...this.getItem(),
data: null
};
let arrNodeId:string[]=[];
function _accessNodesAndActions(node:ICommon_Route_Res_Workflow_Info_Node):ICommon_Route_Res_Workflow_Info_Node {
async function _exec(node:ICommon_Route_Res_Workflow_Info_Node):Promise<ICommon_Route_Res_Workflow_Info_Node> {
if(node==null) {
let firstNode:ICommon_Model_Workflow_Node;
for(let obj of nodeList) {
@ -44,8 +49,11 @@ export default class Workflow extends Entity<typeof workflowModel,typeof workflo
node:firstNode,
actions:[]
}
if(fieldsCallback) {
objNode.fields=await fieldsCallback(firstNode.id);
}
arrNodeId.push(firstNode.id)
_accessNodesAndActions(objNode)
await _exec(objNode)
return objNode;
}
} else {
@ -64,9 +72,12 @@ export default class Workflow extends Entity<typeof workflowModel,typeof workflo
node:obj1,
actions:[]
}
if(fieldsCallback) {
objAction.destNode.fields=await fieldsCallback(obj1.id);
}
if(!arrNodeId.includes(obj1.id)) {
arrNodeId.push(obj1.id)
_accessNodesAndActions(objAction.destNode)
await _exec(objAction.destNode)
}
}
}
@ -75,13 +86,33 @@ export default class Workflow extends Entity<typeof workflowModel,typeof workflo
}
}
}
obj.data=_accessNodesAndActions(null)
let ret=await _exec(null)
return ret;
}
async info():Promise<ICommon_Route_Res_Workflow_Info> {
let obj:ICommon_Route_Res_Workflow_Info={
...this.getItem(),
data: null
};
obj.data=await this.accessNodesAndActions()
return obj;
}
override async delete(eventPulish?: EServer_Common_Event_Types.Types): Promise<void> {
await super.delete()
await workflowMapper.revoke(this.getId())
await FieldSolutionService.clearItemsByWorkflowId(this.getId())
}
async checkNode(workflowNodeId:string) {
let ret=await workflowMapper.checkNode(this.getId(),workflowNodeId)
return ret;
}
async checkAction(workflowActionId:string) {
let ret=await workflowMapper.checkAction(this.getId(),workflowActionId)
return ret;
}
}
@ -106,11 +137,28 @@ export class WorkflowSolutionService extends Entity<typeof workflowSolutionModel
return obj;
}
async bindIssueTypeSolutions(issueTypeSolutionIds:string[]) {
for(let issueTypeSolutionId of issueTypeSolutionIds) {
let arr=await workflowSolutionMapper.getItemsByIssueTypeSolutionId(issueTypeSolutionId)
if(arr && arr.length>0) {
throw Err.Project.Workflow.issueTypeSolutionDuplicate
}
}
await workflowSolutionMapper.bindIssueTypeSolutionList(this.getId(),issueTypeSolutionIds)
}
async unbindIssueTypeSolutions(issueTypeSolutionIds:string[]=null) {
await workflowSolutionMapper.unbindIssueTypeSolution(this.getId(),issueTypeSolutionIds)
}
async getIssueTypeAndWorkflowList() {
let arr:ICommon_Route_Res_WorkflowSolution_Info["data"]=[]
let objIssueTypeSolutionList=await workflowSolutionMapper.getIssueTypeSolutionList(this.getId())
for(let obj of objIssueTypeSolutionList) {
arr.push({
issueTypeSolution:obj,
data:await workflowSolutionMapper.workflowIssueTypeList(this.getId(),obj.id)
})
}
return arr;
}
async info():Promise<ICommon_Route_Res_WorkflowSolution_Info> {
let info:ICommon_Route_Res_WorkflowSolution_Info={
...this.getItem(),
@ -130,14 +178,51 @@ export class WorkflowSolutionService extends Entity<typeof workflowSolutionModel
if(!workflow) {
throw Err.Project.Workflow.workflowNotFound
}
let isIn=await this.checkWorkflow(workflowId)
if(!isIn) {
throw Err.Project.Workflow.workflowNotInWorkflowSolution
}
await workflowSolutionMapper.assign(this.getId(),workflowId,issueTypeId,issueTypeSolutionId);
}
override async create(): Promise<ICommon_Model_Workflow_Solution> {
let ret=await super.create()
let obj=await workflowMapper.getReservedItem()
await workflowSolutionMapper.addWorkflow(this.getId(),obj.id)
return ret
}
override async copy(): Promise<this> {
let workflowList=await this.listWorkflow()
let obj=await super.copy()
for(let o of workflowList) {
await workflowSolutionMapper.addWorkflow(obj.getId(),o.id);
}
return obj;
}
async listWorkflow() {
let ret=await workflowSolutionMapper.listWorkflow(this.getId())
return ret;
}
async checkWorkflow(workflowId:string) {
let isIn=await workflowSolutionMapper.checkWorkflow(this.getId(),workflowId)
return isIn
}
async addWorkflow(workflowId:string) {
let isIn=await this.checkWorkflow(workflowId)
if(isIn) {
throw Err.Project.Workflow.workflowAlreadyInWorkflowSolution
}
await workflowSolutionMapper.addWorkflow(this.getId(),workflowId)
}
async removeWorkflow(workflowId:string) {
await workflowSolutionMapper.removeWorkflow(this.getId(),workflowId)
}
override async delete() {
await super.delete();
await workflowSolutionMapper.deleteItemsByWorkflowSolutionId(this.getId());
@ -150,6 +235,31 @@ export class WorkflowSolutionService extends Entity<typeof workflowSolutionModel
static async clearIssueType(issueTypeId:string) {
await workflowSolutionMapper.clearIssueType(issueTypeId);
}
async checkWorkFlowAndNodeRelation(workflowId:string,workflowNodeId:string) {
if(!workflowNodeId) {
throw Err.Project.Workflow.workflowNodeNotFound
} else if(!workflowId) {
throw Err.Project.Workflow.workflowNotFound
}
let workflowNode=await WorkflowNodeService.getItemById(workflowNodeId)
if(!workflowNode) {
return false
}
let workflow=await Workflow.getItemById(workflowId)
if(!workflow) {
return false
}
let isIn=await workflow.checkNode(workflowNodeId)
if(!isIn) {
return false
}
isIn=await this.checkWorkflow(workflowId)
if(!isIn) {
return false
}
return true
}
}
export class WorkflowNodeService extends Entity<typeof workflowNodeModel,typeof workflowNodeMapper> {

3
code/server/gateway/app/app.ts
View File

@ -4,6 +4,7 @@ import * as body from 'koa-bodyparser';
import * as koaStaticServer from "koa-static-server";
import { PassThrough } from "stream";
import { Permission_Base } from '../../../common/permission/permission';
import * as fieldApi from "../../../common/routes/field";
import * as fileApi from "../../../common/routes/file";
import * as issueTypeApi from "../../../common/routes/issueType";
import * as projectApi from "../../../common/routes/project";
@ -27,7 +28,7 @@ import userRpcApi from '../rpc/user';
import { handleImageFields, initSystem, parseFormData } from "../util/util";
import { ICommon_Version_Config } from './../../../common/model/version';
import { CacheService } from './../cache/service';
var apis:ICommon_HttpApi[]=[userApi,projectApi,teamApi,fileApi,issueTypeApi,workflowApi];
var apis:ICommon_HttpApi[]=[userApi,projectApi,teamApi,fileApi,issueTypeApi,workflowApi,fieldApi];
var app = new Koa();
var config=<ICommon_Version_Config>{}
var pipe = function (from, to): Promise<Buffer> {

77
code/server/gateway/util/util.ts
View File

@ -9,9 +9,14 @@ import { Table_Workflow_Solution_Workflow_Issue_Type, workflowSolutionWorkflowIs
import { Permission_Base, Permission_Types } from '../../../common/permission/permission';
import { getMysqlInstance } from "../../common/db/mysql";
import { getNacosInstance } from '../../common/nacos/nacos';
import { generateCreateSql, generateSnowId } from '../../common/util/sql';
import { generateBatchCreateSql, generateCreateSql, generateSnowId } from '../../common/util/sql';
import rpcFileApi from '../rpc/file';
import rpcUserApi from '../rpc/user';
import { Table_Field_Solution } from './../../../common/model/field_solution';
import { Table_Field_Solution_Workflow_Node_Field_Type } from './../../../common/model/field_solution_workflow_node_field_type';
import { Table_Field_Solution_Workflow_Solution } from './../../../common/model/field_solution_workflow_solution';
import { ECommon_Model_Field_Type, fieldTypeModel, Table_Field_Type } from './../../../common/model/field_type';
import { Table_Field_Type_Config_Value } from './../../../common/model/field_type_config_value';
import { Table_Issue_Type } from './../../../common/model/issue_type';
import { Table_Issue_Type_Solution } from './../../../common/model/issue_type_solution';
import { Table_Issue_Type_Solution_Issue_Type } from './../../../common/model/issue_type_solution_issue_type';
@ -30,6 +35,7 @@ import { Table_Workflow_Action } from './../../../common/model/workflow_action';
import { ECommon_Model_Workflow_Node_Status, Table_Workflow_Node } from './../../../common/model/workflow_node';
import { Table_Workflow_Solution } from './../../../common/model/workflow_solution';
import { Table_Workflow_Solution_Issue_Type_Solution, workflowSolutionIssueTypeSolutionModel } from './../../../common/model/workflow_solution_issue_type_solution';
import { Table_Workflow_Solution_Workflow, workflowSolutionWorkflowModel } from './../../../common/model/workflow_solution_workflow';
import { OBTPConfig } from './obtp';
export interface IServer_GateWay_FormData {
isFile:boolean,
@ -169,8 +175,14 @@ async function resetSystem(){
await mysql.execute(`delete from ${Table_Workflow_Solution}`)
await mysql.execute(`delete from ${Table_Workflow_Solution_Workflow_Issue_Type}`)
await mysql.execute(`delete from ${Table_Workflow_Solution_Issue_Type_Solution}`)
await mysql.execute(`delete from ${Table_Workflow_Solution_Workflow}`)
await mysql.execute(`delete from ${Table_Project_Module}`)
await mysql.execute(`delete from ${Table_Project_Label}`)
await mysql.execute(`delete from ${Table_Field_Solution}`)
await mysql.execute(`delete from ${Table_Field_Solution_Workflow_Node_Field_Type}`)
await mysql.execute(`delete from ${Table_Field_Type}`)
await mysql.execute(`delete from ${Table_Field_Type_Config_Value}`)
await mysql.execute(`delete from ${Table_Field_Solution_Workflow_Solution}`)
}
export async function initSystem() {
@ -187,6 +199,7 @@ export async function initSystem() {
await initProject(userId,projectRoleUserId)
let {issueTypeBugId,issueTypeSolutionId,issueTypeSolutionName,issueTypeTaskId,issueTypeTicketId}=await initIssueType()
await initWorkflow(issueTypeSolutionId,issueTypeSolutionName,issueTypeTaskId,issueTypeBugId,issueTypeTicketId)
await initField()
}
console.log("init finish")
}
@ -424,6 +437,11 @@ async function initWorkflow(issueTypeSolutionId:string,issueTypeSolutionName:str
reserved:1,
name:issueTypeSolutionName,
}))
await mysql.execute(generateCreateSql(workflowSolutionWorkflowModel,{
id:await generateSnowId(),
workflow_solution_id:workflowSolutionId,
workflow_id:workflowId
}))
await mysql.execute(generateCreateSql(workflowSolutionIssueTypeSolutionModel,{
id:await generateSnowId(),
workflow_solution_id:workflowSolutionId,
@ -450,4 +468,61 @@ async function initWorkflow(issueTypeSolutionId:string,issueTypeSolutionName:str
issue_type_id:issueTypeTicketId,
issue_type_solution_id:issueTypeSolutionId
}))
}
async function initField() {
let mysql = getMysqlInstance()
let fieldTypeLabelId=await generateSnowId()
let fieldTypeMultiLabelId=await generateSnowId()
let fieldTypeTextId=await generateSnowId()
let fieldTypeMultiTextId=await generateSnowId()
let fieldTypeSelectId=await generateSnowId()
let fieldTypeMultiSelectId=await generateSnowId()
let fieldTypeSwitchId=await generateSnowId()
let fieldTypeTimeId=await generateSnowId()
let fieldTypeDateId=await generateSnowId()
let fieldTypeDateTimeId=await generateSnowId()
await mysql.execute(generateBatchCreateSql(fieldTypeModel,[{
id:fieldTypeLabelId,
name:"label",
type:ECommon_Model_Field_Type.LABEL
},{
id:fieldTypeMultiLabelId,
name:"multi label",
multi:1,
type:ECommon_Model_Field_Type.MULTILABEL
},{
id:fieldTypeTextId,
name:"text",
type:ECommon_Model_Field_Type.TEXT
},{
id:fieldTypeMultiTextId,
name:"multi text",
type:ECommon_Model_Field_Type.MULTITEXT
},{
id:fieldTypeSelectId,
name:"select",
type:ECommon_Model_Field_Type.SELECT
},{
id:fieldTypeMultiSelectId,
name:"multi select",
multi:1,
type:ECommon_Model_Field_Type.MULTISELECT
},{
id:fieldTypeSwitchId,
name:"switch",
type:ECommon_Model_Field_Type.SWITCH
},{
id:fieldTypeTimeId,
name:"timepicker",
type:ECommon_Model_Field_Type.TIME
},{
id:fieldTypeDateId,
name:"datepicker",
type:ECommon_Model_Field_Type.DATE
},{
id:fieldTypeDateTimeId,
name:"datetimepicker",
type:ECommon_Model_Field_Type.DATETIME
}]))
}