add

code/server/common/rpc/api/user.ts

@@ -15,6 +15,7 @@ export default interface IServer_Common_RPC_User {
     initAdmin?():Promise<string[]>
     initUser?():Promise<string[]>
     initOrganization?(adminIds:string[],userIds:string[]):Promise<string>
+    initTeam?(userId:string,groupRoleUserId:string,organizationId:string)
 }
 
 export type IUserSession=IServer_Common_RPC_User_CheckSession

code/server/common/util/common.ts

@@ -97,4 +97,10 @@ export default class CommonUtil {
             return false;
         }
     }
+
+    static async sleep(ms:number) {
+        return new Promise((resolve)=>{
+            setTimeout(resolve,ms)
+        })
+    }
 }

code/server/cooperation/rpc/cooperation.ts

@@ -1,4 +1,3 @@
-import { ECommon_Model_Project_Member_Type } from "../../../common/model/project_member";
 import { Err } from "../../../common/status/error";
 import IServer_Common_RPC_Cooperation from "../../common/rpc/api/cooperation";
 import { DRPCRecieve } from "../../common/rpc/rpc";
@@ -55,7 +54,6 @@ class RpcCooperationApi implements IServer_Common_RPC_Cooperation {
             created_by:userId
         })
         await objProject.create()
-        objProject.addMember(userId,ECommon_Model_Project_Member_Type.USER,projectRoleUserId)
         return objProject.getId();
     }
 

code/server/cooperation/service/issueType.ts

@@ -76,7 +76,9 @@ export class IssueTypeSolutionService extends Entity<typeof issueTypeSolutionMod
     override async create():Promise<ICommon_Model_Issue_Type_Solution> {
         let ret=await super.create();
         let objWorkflowReserved=await WorkflowSolutionService.getReservedItem(ret.organization_id)
-        objWorkflowReserved.bindIssueTypeSolutions([this.getId()])
+        if(objWorkflowReserved) {
+            objWorkflowReserved.bindIssueTypeSolutions([this.getId()])
+        }
         return ret;
     }
 
@@ -148,6 +150,9 @@ export class IssueTypeSolutionService extends Entity<typeof issueTypeSolutionMod
 
     static async getReservedItem(organizationId:string) {
         let obj=await issueTypeSolutionMapper.getReservedItem(organizationId)
+        if(!obj) {
+            return null;
+        }
         let ret=new IssueTypeSolutionService
         ret.setItem(obj)
         return ret;

code/server/cooperation/service/project.ts

@@ -36,7 +36,9 @@ export default class Project extends Entity<typeof projectModel,typeof projectMa
             await projectMapper.addMember(this.getId(),this.getItem().created_by,ECommon_Model_Project_Member_Type.USER,role.id)
         }
         let issueTypeSolution=await IssueTypeSolutionService.getReservedItem(ret.organization_id)
-        await issueTypeSolution.bindProject(this.getId())
+        if(issueTypeSolution) {
+            await issueTypeSolution.bindProject(this.getId())
+        }
         return ret;
     }
 

code/server/cooperation/service/workflow.ts

@@ -175,6 +175,9 @@ export class WorkflowSolutionService extends Entity<typeof workflowSolutionModel
 
     static async getReservedItem (organizationId:string) {
         let ret=await workflowSolutionMapper.getReservedItem(organizationId)
+        if(!ret) {
+            return null;
+        }
         let obj=new WorkflowSolutionService()
         obj.setItem(ret)
         return obj;

code/server/gateway/app/app.ts

@@ -33,7 +33,7 @@ var apis:ICommon_HttpApi[]=[userApi,projectApi,teamApi,fileApi,issueTypeApi,work
 export default class GateWay extends Application {
     override async config(app: Koa<Koa.DefaultState, Koa.DefaultContext>) {
         let cacheService=new CacheService()
-        cacheService.start()
+        await cacheService.start()
         await checkIfNeedInit()
         let apiMap=<{
             [param:string]:{

code/server/gateway/cache/service.ts

@@ -1,5 +1,8 @@
+import { ECommon_Services } from "../../../common/types";
 import { REDIS_GATEWAY } from "../../common/cache/keys/gateway";
+import { getRedisInstance } from "../../common/cache/redis";
 import { getConfigInstance } from '../../common/config/config';
+import CommonUtil from "../../common/util/common";
 
 export class CacheService {
     private timer:NodeJS.Timeout
@@ -12,11 +15,17 @@ export class CacheService {
     constructor(){
         this.config=getConfigInstance();
     }
-    start(){
-        this.handle()
+    async start(){
+        let redis=getRedisInstance()
+        await redis.flush();
+        await this.handle()
     }
     private async handle(){
         let ret=await this.config.getInstances()
+        while(Object.keys(ret).length<Object.keys(ECommon_Services).length) {
+            await CommonUtil.sleep(100)
+            ret=await this.config.getInstances()
+        }
         this.instanceMap={}
         for(let key in ret) {
             let obj=ret[key]

code/server/gateway/rpc/cooperation.ts

@@ -0,0 +1,21 @@
+import { ECommon_Services } from "../../../common/types";
+import IServer_Common_RPC_Cooperation from "../../common/rpc/api/cooperation";
+import { DRPCSend } from "../../common/rpc/rpc";
+class RpcCooperationApi implements IServer_Common_RPC_Cooperation {
+    @DRPCSend(ECommon_Services.Cooperation)
+    async initIssueTypeWorkflowAndSolution(organizationId: string,projectId?:string) {
+        return null;
+    }
+
+    @DRPCSend(ECommon_Services.Cooperation)
+    async initProject(userId: string, projectRoleUserId: string, organizationId: string): Promise<string> {
+        return null;
+    }
+
+    @DRPCSend(ECommon_Services.Cooperation)
+    async initField() {
+        return null;
+    }
+    
+}
+export default new RpcCooperationApi;

code/server/gateway/rpc/user.ts

@@ -10,5 +10,24 @@ class RpcUserApi implements IServer_Common_RPC_User {
     async getUsersInfo(userIds: string[],organizationId:string): Promise<{ id: string; username: string; photo?: string;nickname?:string }[]> {
         return null;
     }
+
+    @DRPCSend(ECommon_Services.User)
+    async initAdmin(): Promise<string[]> {
+        return null
+    }
+
+    @DRPCSend(ECommon_Services.User)
+    async initUser(): Promise<string[]> {
+        return null
+    }
+
+    @DRPCSend(ECommon_Services.User)
+    async initOrganization(adminIds: string[], userIds: string[]): Promise<string> {
+        return null;
+    }
+    @DRPCSend(ECommon_Services.User)
+    async initTeam(userId: string, groupRoleUserId: string, organizationId: string) {
+        return null;
+    }
 }
 export default new RpcUserApi

code/server/gateway/util/util.ts

@@ -3,37 +3,34 @@ import * as Importer from "mysql2-import";
 import * as path from "path";
 import { Table_Project } from '../../../common/model/project';
 import { Table_Project_Issue } from "../../../common/model/project_issue";
-import { Table_Workflow, workflowModel } from "../../../common/model/workflow";
-import { workflowActionModel } from "../../../common/model/workflow_action";
-import { workflowNodeModel } from "../../../common/model/workflow_node";
-import { workflowSolutionModel } from "../../../common/model/workflow_solution";
-import { Table_Workflow_Solution_Workflow_Issue_Type, workflowSolutionWorkflowIssueTypeModel } from "../../../common/model/workflow_solution_workflow_issue_type";
+import { Table_Workflow } from "../../../common/model/workflow";
+import { Table_Workflow_Solution_Workflow_Issue_Type } from "../../../common/model/workflow_solution_workflow_issue_type";
 import { Permission_Base, Permission_Types } from '../../../common/permission/permission';
 import Application, { ECommon_Application_Mode } from '../../common/app/app';
-import { getRedisInstance } from "../../common/cache/redis";
 import { getConfigInstance } from '../../common/config/config';
 import { getMysqlInstance } from "../../common/db/mysql";
 import CommonUtil from "../../common/util/common";
-import { generateBatchCreateSql, generateCreateSql, generateQuerySql, generateSnowId, generateUpdateSql } from '../../common/util/sql';
+import { generateQuerySql, generateSnowId, generateUpdateSql } from '../../common/util/sql';
+import rpcCooperationApi from "../rpc/cooperation";
 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 } 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';
-import { organizationModel, Table_Organization } from './../../../common/model/organization';
-import { ECommon_Organization_User_Role, organizationUserModel, Table_Organization_User } from './../../../common/model/organization_user';
+import { Table_Organization } from './../../../common/model/organization';
+import { Table_Organization_User } from './../../../common/model/organization_user';
 import { Table_Permission } from './../../../common/model/permission';
 import { Table_Project_Issue_Description } from './../../../common/model/project_issue_description';
 import { Table_Project_Issue_Field_Value } from './../../../common/model/project_issue_field_value';
 import { Table_Project_Issue_Parent } from './../../../common/model/project_issue_parent';
 import { Table_Project_Issue_Process } from './../../../common/model/project_issue_process';
 import { Table_Project_Issue_Related } from './../../../common/model/project_issue_related';
-import { projectIssueTypeSolutionModel, Table_Project_Issue_Solution } from './../../../common/model/project_issue_type_solution';
+import { Table_Project_Issue_Solution } from './../../../common/model/project_issue_type_solution';
 import { Table_Project_Label } from './../../../common/model/project_label';
 import { Table_Project_Label_Issue } from './../../../common/model/project_label_issue';
 import { Table_Project_Member } from './../../../common/model/project_member';
@@ -47,14 +44,12 @@ import { Table_Team_User } from './../../../common/model/team_user';
 import { Table_User } from './../../../common/model/user';
 import { Table_Version, versionModel } from './../../../common/model/version';
 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_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 { Table_Workflow_Solution_Issue_Type_Solution } from './../../../common/model/workflow_solution_issue_type_solution';
+import { Table_Workflow_Solution_Workflow } from './../../../common/model/workflow_solution_workflow';
 import { OBTPConfig } from './obtp';
 
-
-
 export async function handleImageFields(data:object,organizationId:string){
     let arrImage=<{
         object:object,
@@ -160,11 +155,6 @@ async function resetSystem(){
     
 }
 
-async function flushRedis() {
-    let redis=getRedisInstance()
-    await redis.flush()
-}
-
 export async function checkIfNeedInit() {
     if(Application.mode!=ECommon_Application_Mode.MICRO) {
         let mysql=getMysqlInstance()
@@ -194,7 +184,6 @@ export async function checkIfNeedInit() {
         } else {
             await checkIfNeedPatch()
             if(Application.needReset) {
-                await flushRedis()
                 await resetSystem()
             }
         }
@@ -258,90 +247,25 @@ async function checkIfNeedPatch() {
 
 export async function initSystem() {
     if(Application.needReset) {
-        await flushRedis()
         await resetSystem()
     }
     let mysql=getMysqlInstance()
     let ret=await mysql.execute<any[]>(`select * from ${Table_Version}`)
     if(ret===null || ret.length==0){
-        let adminIds=await initAdmin()
-        let userIds=await initUser()
-        let organizationId=await initOrganization(adminIds,userIds);
+        let adminIds=await rpcUserApi.initAdmin();
+        let userIds=await rpcUserApi.initUser()
+        let organizationId=await rpcUserApi.initOrganization(adminIds,userIds);
         await initVersion()
         let objPermission=await initPermission()
         let {projectRoleUserId,groupRoleUserId}=await initRole(objPermission);
-        await initTeam(userIds[0],groupRoleUserId,organizationId);
-        let projectId=await initProject(userIds[0],projectRoleUserId,organizationId)
-        let {issueTypeBugId,issueTypeSolutionId,issueTypeSolutionName,issueTypeTaskId,issueTypeTicketId}=await initIssueType(projectId,organizationId)
-        await initWorkflow(issueTypeSolutionId,issueTypeSolutionName,issueTypeTaskId,issueTypeBugId,issueTypeTicketId,organizationId)
-        await initField()
+        await rpcUserApi.initTeam(userIds[0],groupRoleUserId,organizationId);
+        let projectId=await rpcCooperationApi.initProject(userIds[0],projectRoleUserId,organizationId)
+        await rpcCooperationApi.initIssueTypeWorkflowAndSolution(organizationId,projectId)
+        await rpcCooperationApi.initField()
     }
     console.log("init finish")
 }
 
-async function initOrganization(adminIds:string[],userIds:string[]):Promise<string> {
-    let mysql=getMysqlInstance()
-    let id=await generateSnowId()
-    await mysql.executeOne(generateCreateSql(organizationModel,{
-        id,
-        name:"default",
-        user_id:adminIds[0]
-    }))
-    let i=0;
-    for(let adminId of adminIds) {
-        await mysql.execute(generateCreateSql(organizationUserModel,{
-            id:await generateSnowId(),
-            nickname:"test"+(i++),
-            organization_id:id,
-            role:ECommon_Organization_User_Role.ADMIN,
-            user_id:adminId
-        }))
-    }
-    for(let userId of userIds) {
-        await mysql.execute(generateCreateSql(organizationUserModel,{
-            id:await generateSnowId(),
-            nickname:"test"+(i++),
-            organization_id:id,
-            role:ECommon_Organization_User_Role.USER,
-            user_id:userId
-        }))
-    }
-    return id;
-}
-
-async function initUser():Promise<string[]> {
-    let mysql=getMysqlInstance()
-    let userIds=[await generateSnowId(),await generateSnowId(),await generateSnowId()]
-    await mysql.execute(`insert into ${Table_User} (id,username,password) values ('${userIds[0]}','sx','sx')`)
-    await mysql.execute(`insert into ${Table_User} (id,username,password) values ('${userIds[1]}','wgq','wgq')`)
-    await mysql.execute(`insert into ${Table_User} (id,username,password) values ('${userIds[2]}','hxx','hxx')`)
-    return userIds
-}
-
-async function initAdmin():Promise<string[]> {
-    let mysql=getMysqlInstance()
-    let adminIds=[await generateSnowId(),await generateSnowId(),await generateSnowId()]
-    await mysql.execute(`insert into ${Table_User} (id,username,password,role) values ('${adminIds[0]}','teamlinker','teamlinker',1)`)
-    await mysql.execute(`insert into ${Table_User} (id,username,password,role) values ('${adminIds[1]}','wgq_admin','123456',1)`)
-    await mysql.execute(`insert into ${Table_User} (id,username,password,role) values ('${adminIds[2]}','hxx_admin','123456',1)`)
-    return adminIds
-}
-
-async function initTeam(userId:string,groupRoleUserId:string,organizationId:string) {
-    let mysql=getMysqlInstance()
-    let groupId=await generateSnowId()
-    await mysql.execute(`insert into ${Table_Team} (id,name,created_by,organization_id) values ('${groupId}','test_group','${userId}','${organizationId}')`)
-    await mysql.execute(`insert into ${Table_Team_User} (id,role_id,team_id,user_id) values ('${await generateSnowId()}','${groupRoleUserId}','${groupId}','${userId}')`)
-}
-
-async function initProject(userId:string,projectRoleUserId:string,organizationId:string):Promise<string> {
-    let mysql=getMysqlInstance()
-    let projectId=await generateSnowId()
-    await mysql.execute(`insert into ${Table_Project} (id,name,keyword,created_by,organization_id) values ('${projectId}','test','test','${userId}','${organizationId}')`)
-    await mysql.execute(`insert into ${Table_Project_Member} (id,role_id,project_id,member_id,type) values ('${await generateSnowId()}','${projectRoleUserId}','${projectId}','${userId}',0)`)
-    return projectId
-}
-
 async function initVersion() {
     let mysql=getMysqlInstance()
     await mysql.execute(`insert into ${Table_Version} (version) values ('${getConfigInstance().version}')`)
@@ -413,222 +337,4 @@ async function initRole(objPermission:{
         projectRoleUserId,
         groupRoleUserId
     }
-}
-
-async function initIssueType(projectId:string,organizationId:string) {
-    let mysql = getMysqlInstance()
-    let taskId=await generateSnowId()
-    let bugId=await generateSnowId()
-    let ticketId=await generateSnowId()
-    let solutionId=await generateSnowId()
-    await mysql.execute(`insert into ${Table_Issue_Type} (id,name,reserved,organization_id) values ('${taskId}','Task',1,'${organizationId}')`)
-    await mysql.execute(`insert into ${Table_Issue_Type} (id,name,reserved,organization_id) values ('${bugId}','Bug',1,'${organizationId}')`)
-    await mysql.execute(`insert into ${Table_Issue_Type} (id,name,reserved,organization_id) values ('${ticketId}','Ticket',1,'${organizationId}')`)
-    await mysql.execute(`insert into ${Table_Issue_Type_Solution} (id,name,description,reserved,organization_id) values ('${solutionId}','Default','Default',1,'${organizationId}')`)
-    await mysql.execute(`insert into ${Table_Issue_Type_Solution_Issue_Type} (id,issue_type_id,issue_type_solution_id) values ('${await generateSnowId()}','${taskId}','${solutionId}')`)
-    await mysql.execute(`insert into ${Table_Issue_Type_Solution_Issue_Type} (id,issue_type_id,issue_type_solution_id) values ('${await generateSnowId()}','${bugId}','${solutionId}')`)
-    await mysql.execute(`insert into ${Table_Issue_Type_Solution_Issue_Type} (id,issue_type_id,issue_type_solution_id) values ('${await generateSnowId()}','${ticketId}','${solutionId}')`)
-    await mysql.execute(generateCreateSql(projectIssueTypeSolutionModel,{
-        id:await generateSnowId(),
-        project_id:projectId,
-        issue_type_solution_id:solutionId
-    }))
-    return {
-        issueTypeTaskId:taskId,
-        issueTypeBugId:bugId,
-        issueTypeTicketId:ticketId,
-        issueTypeSolutionId:solutionId,
-        issueTypeSolutionName:"Default"
-    }
-}
-
-async function initWorkflow(issueTypeSolutionId:string,issueTypeSolutionName:string,issueTypeTaskId:string,issueTypeBugId:string,issueTypeTicketId:string,organizationId:string) {
-    let mysql = getMysqlInstance()
-    let workflowId=await generateSnowId()
-    await mysql.execute(generateCreateSql(workflowModel,{
-        id:workflowId,
-        name:"default",
-        description:"",
-        reserved:1,
-        organization_id:organizationId
-    }))
-    let workflowNodeOpenId=await generateSnowId()
-    let workflowNodeProgressId=await generateSnowId()
-    let workflowNodeClosedId=await generateSnowId()
-    let workflowNodeResolvedId=await generateSnowId()
-    await mysql.execute(generateCreateSql(workflowNodeModel,{
-        id:workflowNodeOpenId,
-        name:"open",
-        status:ECommon_Model_Workflow_Node_Status.NOTSTART,
-        workflow_id:workflowId,
-        x:50,
-        y:45
-    }))
-    await mysql.execute(generateCreateSql(workflowNodeModel,{
-        id:workflowNodeProgressId,
-        name:"in progress",
-        status:ECommon_Model_Workflow_Node_Status.INPROGRESS,
-        workflow_id:workflowId,
-        x:281,
-        y:177
-    }))
-    await mysql.execute(generateCreateSql(workflowNodeModel,{
-        id:workflowNodeClosedId,
-        name:"closed",
-        status:ECommon_Model_Workflow_Node_Status.DONE,
-        workflow_id:workflowId,
-        x:59,
-        y:502
-    }))
-    await mysql.execute(generateCreateSql(workflowNodeModel,{
-        id:workflowNodeResolvedId,
-        name:"resolved",
-        status:ECommon_Model_Workflow_Node_Status.DONE,
-        workflow_id:workflowId,
-        x:507,
-        y:503
-    }))
-    let actionOpenToProgressId=await generateSnowId()
-    let actionProgressToOpenId=await generateSnowId()
-    let actionOpenToClosedId=await generateSnowId()
-    let actionClosedToOpenId=await generateSnowId()
-    let actionProgressToResolvedId=await generateSnowId()
-    let actionResolvedToProgressId=await generateSnowId()
-    await mysql.execute(generateCreateSql(workflowActionModel,{
-        id:actionOpenToProgressId,
-        name:"open to progress",
-        workflow_id:workflowId,
-        source_node_id:workflowNodeOpenId,
-        dest_node_id:workflowNodeProgressId
-    }))
-    await mysql.execute(generateCreateSql(workflowActionModel,{
-        id:actionProgressToOpenId,
-        name:"progress to open",
-        workflow_id:workflowId,
-        source_node_id:workflowNodeProgressId,
-        dest_node_id:workflowNodeOpenId
-    }))
-    await mysql.execute(generateCreateSql(workflowActionModel,{
-        id:actionOpenToClosedId,
-        name:"open to close",
-        workflow_id:workflowId,
-        source_node_id:workflowNodeOpenId,
-        dest_node_id:workflowNodeClosedId
-    }))
-    await mysql.execute(generateCreateSql(workflowActionModel,{
-        id:actionClosedToOpenId,
-        name:"closed to open",
-        workflow_id:workflowId,
-        source_node_id:workflowNodeClosedId,
-        dest_node_id:workflowNodeOpenId
-    }))
-    await mysql.execute(generateCreateSql(workflowActionModel,{
-        id:actionProgressToResolvedId,
-        name:"progress to resolved",
-        workflow_id:workflowId,
-        source_node_id:workflowNodeProgressId,
-        dest_node_id:workflowNodeResolvedId
-    }))
-    await mysql.execute(generateCreateSql(workflowActionModel,{
-        id:actionResolvedToProgressId,
-        name:"resolved to progress",
-        workflow_id:workflowId,
-        source_node_id:workflowNodeResolvedId,
-        dest_node_id:workflowNodeProgressId
-    }))
-    let workflowSolutionId=await generateSnowId()
-    await mysql.execute(generateCreateSql(workflowSolutionModel,{
-        id:workflowSolutionId,
-        reserved:1,
-        name:issueTypeSolutionName,
-        organization_id:organizationId
-    }))
-    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,
-        issue_type_solution_id:issueTypeSolutionId
-    }))
-    await mysql.execute(generateCreateSql(workflowSolutionWorkflowIssueTypeModel,{
-        id:await generateSnowId(),
-        workflow_solution_id:workflowSolutionId,
-        workflow_id:workflowId,
-        issue_type_id:issueTypeTaskId,
-        issue_type_solution_id:issueTypeSolutionId
-    }))
-    await mysql.execute(generateCreateSql(workflowSolutionWorkflowIssueTypeModel,{
-        id:await generateSnowId(),
-        workflow_solution_id:workflowSolutionId,
-        workflow_id:workflowId,
-        issue_type_id:issueTypeBugId,
-        issue_type_solution_id:issueTypeSolutionId
-    }))
-    await mysql.execute(generateCreateSql(workflowSolutionWorkflowIssueTypeModel,{
-        id:await generateSnowId(),
-        workflow_solution_id:workflowSolutionId,
-        workflow_id:workflowId,
-        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
-    }]))
 }

code/server/user/rpc/user.ts

@@ -4,6 +4,7 @@ import { getConfigInstance } from '../../common/config/config';
 import IServer_Common_RPC_User, { IServer_Common_RPC_User_CheckSession } from "../../common/rpc/api/user";
 import { DRPCRecieve } from "../../common/rpc/rpc";
 import AdminService from "../service/admin";
+import TeamService from "../service/team";
 import UserService from "../service/user";
 import { OrganizationService } from './../service/organization';
 import rpcFileApi from "./file";
@@ -121,5 +122,17 @@ class RpcUserApi implements IServer_Common_RPC_User {
         let ret=await OrganizationService.init(adminIds,userIds)
         return ret;
     }
+
+    @DRPCRecieve
+    async initTeam(userId: string, groupRoleUserId: string, organizationId: string) {
+        let team=new TeamService;
+        team.assignItem({
+            name:"test_group",
+            created_by:userId,
+            organization_id:organizationId
+        })
+        await team.create()
+        await team.addMemeber(userId,groupRoleUserId);
+    }
 }
 export default new RpcUserApi;