aa

code/common/model/project_label.ts

@@ -1,6 +1,15 @@
+import { BaseModel } from "./base"
+
 export interface ICommon_Model_Project_Lable {
     id :string,
     name:string,
     project_id:string
 }
-export const Table_Project_Label="project_label"
+export const Table_Project_Label="project_label"
+
+class ProjectLabelModel extends BaseModel {
+    table=Table_Project_Label
+    model=<ICommon_Model_Project_Lable>{}
+  }
+  
+  export let projectLabelModel=new ProjectLabelModel

code/common/routes/project.ts

@@ -2,7 +2,7 @@ import { Permission_Types } from '../permission/permission';
 import { ICommon_Model_Project } from './../model/project';
 import { ICommon_Model_Project_Module } from './../model/project_module';
 import { ECommon_Services } from './../types';
-import { ECommon_Route_Res_Project_Member_Type, ICommon_Route_Res_Project_CreateModule_Data, ICommon_Route_Res_Project_Member } from './response';
+import { ECommon_Route_Res_Project_Member_Type, ICommon_RouteRes_Project_ListTag, ICommon_Route_Res_Project_CreateModule_Data, ICommon_Route_Res_Project_Member } from './response';
 import { ECommon_HttpApi_Method } from "./types";
 const api={
     baseUrl:"/project",
@@ -49,14 +49,7 @@ const api={
                 size:number,
                 keyword:string  
             }>{},
-            res:<{
-                totalPage:number,
-                page:number,
-                data:{
-                    id:string,
-                    name:string
-                }[]
-            }>{}
+            res:<ICommon_RouteRes_Project_ListTag>{}
         },
         createTag:{
             method:ECommon_HttpApi_Method.POST,

code/common/routes/response.ts

@@ -19,4 +19,13 @@ export type ICommon_Route_Res_Project_Member = {
         id:string,
         name:string
     }
+}
+
+export type ICommon_RouteRes_Project_ListTag = {
+    totalPage:number,
+    page:number,
+    data:{
+        id:string,
+        name:string
+    }[]
 }

code/common/status/error.ts

@@ -7,6 +7,14 @@ export namespace Err {
         mysqlError:{
             code:2,
             msg:"mysql error"
+        },
+        itemNotFound:{
+            code:3,
+            msg:"item not found"
+        },
+        itemExists:{
+            code:4,
+            msg:"item exists"
         }
     }
     export let User = {

code/server/common/entity/entity.ts

@@ -1,5 +1,14 @@
-export abstract class Entity<T> {
-    protected item:T;
+import { BaseModel } from '../../../common/model/base';
+import { Err } from '../../../common/status/error';
+import { EServer_Common_Event_Types } from '../event/types';
+import { emitServiceEvent } from '../rpc/rpc';
+import { Mapper } from './mapper';
+export abstract class Entity<T extends BaseModel,M extends Mapper<T>> {
+    protected item:T["model"];
+    protected mapper:M
+    constructor(mapper:M) {
+        this.mapper=mapper
+    }
     getId():string{
         if(this.item) {
             return (<any>this.item).id
@@ -7,10 +16,10 @@ export abstract class Entity<T> {
             return null;
         }
     }
-    setItem(item:T) {
+    setItem(item:T["model"]) {
         this.item=item
     }
-    assignItem(item:Partial<T>) {
+    assignItem(item:Partial<T["model"]>) {
         if(typeof(item)=="object") {
             if(!this.item) {
                 this.item=<T>{}
@@ -20,11 +29,49 @@ export abstract class Entity<T> {
             }
         }
     }
-    getItem():T {
+    getItem():T["model"] {
         return this.item;
     }
-    abstract create():Promise<T>;
-    abstract update():Promise<T>;
-    abstract delete();
-    abstract loadItem():Promise<T>;
+    async create():Promise<T["model"]> {
+        if(!this.item) {
+            throw  Err.Common.itemNotFound;
+        } else if(this.item.id) {
+            throw  Err.Common.itemExists;
+        }
+        await this.mapper.create(this.item)
+        await this.loadItem();
+        return this.item;
+    }
+    async update():Promise<T["model"]>{
+        if(!this.item || !this.item.id) {
+            throw  Err.Common.itemNotFound;
+        }
+        await this.mapper.update(this.item)
+        return this.item;
+    }
+    async delete(eventPulish?:EServer_Common_Event_Types.Types){
+        await this.mapper.delete(this.item.id);
+        if(eventPulish) {
+            emitServiceEvent(eventPulish,this.item.id);
+        }
+        
+    }
+    async loadItem():Promise<T["model"]>{
+        if(!this.item || !this.item.id) {
+            throw  Err.Common.itemNotFound;
+        }
+        let obj = await this.mapper.getById(this.item.id);
+        this.item=obj;
+        return this.item;
+    } 
+    static async getItemById<Type>(this:{new():Type},id:string):Promise<Type>{
+        let user = new this() as any;
+        let obj = await user.mapper.getById(id);
+        if(obj) {
+            user.setItem(obj);
+            return user;
+        } else {
+            return null;
+        }
+    }
 }

code/server/common/entity/mapper.ts

@@ -0,0 +1,55 @@
+import { BaseModel } from "../../../common/model/base";
+import { Err } from "../../../common/status/error";
+import { getMysqlInstance } from "../db/mysql";
+import { generateCreateSql, generateDeleteSql, generateQuerySql, generateSnowId, generateUpdateSql } from "../util/sql";
+
+export abstract class Mapper<T extends BaseModel> {
+    private model:T
+    constructor(model:T){
+        this.model=model
+    }
+    async createConfig(info:T["model"]){}
+    async create(info:T["model"]):Promise<void> {
+        if(!info || info.id){
+            throw  Err.Common.paramError
+        }
+        await this.createConfig(info);
+        info.id=await generateSnowId();
+        var mysql=getMysqlInstance() 
+        await mysql.execute(generateCreateSql(this.model,info))
+    }
+ 
+    async getById(id:string):Promise<T["model"]> {
+        if(!id) {
+            throw  Err.Common.itemNotFound
+        }
+        var mysql=getMysqlInstance();
+        let ret=await mysql.executeOne(generateQuerySql(this.model,[],{id}))
+        return ret
+    }
+    async updateConfig(info:T["model"]){}
+    async update(info:T["model"]):Promise<void> {
+        if(!info.id) {
+            throw  Err.Common.itemNotFound
+        }
+        var mysql=getMysqlInstance();
+        await this.updateConfig(info)
+        let id=info.id;
+        delete info.id
+        if(info.created_time) {
+            delete info.created_time
+        }
+        if(info.modified_time) {
+            delete info.modified_time
+        }
+        await mysql.execute(generateUpdateSql(this.model,info,{id}))
+    }
+
+    async delete(id):Promise<void> {
+        if(!id) {
+            throw  Err.Common.itemNotFound
+        }
+        var mysql=getMysqlInstance();
+        await mysql.execute(generateDeleteSql(this.model,{id}))
+    }
+}

code/server/common/tsconfig.json

@@ -11,6 +11,9 @@
     "emitDecoratorMetadata": true,
     "noImplicitOverride": true,
     "baseUrl": "./",
+    "plugins": [
+      { "transform": "../../common/transform/transformer.js" }
+    ]
   },
   "include": [
     "./**/*",

code/server/common/util/sql.ts

@@ -134,7 +134,7 @@ export function generateCreateSql<T extends BaseModel>(model:T,obj:{
 
 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"):{
+},exprMode?:"and"|"or",limit?:number,size?:number):{
     value:string,
     type:{
         [key in Extract<keyof T["model"],K1>]:T["model"][key]
@@ -148,7 +148,7 @@ export function generateQuerySql<T extends BaseModel,K1 extends keyof T["model"]
     }
     let expr=generateExp(objExpr,exprMode);
     return {
-        value:`select ${column} from ${model.table}${expr?(" where "+expr):""}`,
+        value:`select ${column} from ${model.table}${expr?(" where "+expr):""}${limit!==undefined?` limit ${limit},${size}`:""}`,
         type:model.model
     }
 }

code/server/cooperation/app/app.ts

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

code/server/cooperation/http/project.ts

@@ -2,19 +2,19 @@ import * as projectApi from "../../../common/routes/project";
 import { Err } from "../../../common/status/error";
 import { DHttpApi, DHttpReqParam, DHttpReqParamRequired, DHttpUser } from "../../common/http/http";
 import { IUserSession } from "../../common/rpc/api/user";
-import projectService from "../service/project";
+import ProjectService from "../service/project";
 
 
 class ProjectController {
     @DHttpApi(projectApi.routes.basic)
     async projectInfo(@DHttpReqParamRequired("projectId") projectId:string):Promise<typeof projectApi.routes.basic.res>{
-        let obj=await projectService.getItemById(projectId);
+        let obj=await ProjectService.getItemById(projectId);
         return obj.getItem();
     }
 
     @DHttpApi(projectApi.routes.create)
     async createProject(@DHttpReqParamRequired("name") name:string,@DHttpReqParamRequired("keyword") keyword:string,@DHttpReqParam("image") image:string,@DHttpReqParam("description") description:string,@DHttpUser user:IUserSession):Promise<typeof projectApi.routes.create.res>{
-        let obj=new projectService()
+        let obj=new ProjectService()
         obj.assignItem({
             keyword:keyword,
             name:name,
@@ -28,7 +28,7 @@ class ProjectController {
 
     @DHttpApi(projectApi.routes.edit)
     async editProject(@DHttpReqParam("name") name:string,@DHttpReqParam("keyword") keyword:string,@DHttpReqParam("image") image:string,@DHttpReqParam("description") description:string,@DHttpReqParam("projectId") projectId:string):Promise<typeof projectApi.routes.edit.res>{
-        let obj=await projectService.getItemById(projectId);
+        let obj=await ProjectService.getItemById(projectId);
         if(!obj) {
             throw Err.Project.projectNotFound
         }

code/server/cooperation/http/tag.ts

@@ -0,0 +1,12 @@
+import { DComponent } from "../../common/decorate/component";
+import { DHttpApi, DHttpReqParam, DHttpReqParamRequired } from "../../common/http/http";
+import * as projectApi from "../../../common/routes/project";
+
+
+@DComponent
+class TagController {
+     @DHttpApi(projectApi.routes.listTag)
+     async listTag(@DHttpReqParamRequired("projectId") projectId:string,@DHttpReqParamRequired("page") page:number,@DHttpReqParamRequired("size") size:number,@DHttpReqParam("keyword") keyword:string) {
+         
+     }
+}

code/server/cooperation/mapper/project.ts

@@ -1,42 +1,9 @@
-import { ICommon_Model_Project, projectModel } from '../../../common/model/project';
-import { Err } from "../../../common/status/error";
-import { getMysqlInstance } from "../../common/db/mysql";
-import { generateCreateSql, generateDeleteSql, generateQuerySql, generateSnowId, generateUpdateSql } from "../../common/util/sql";
-export namespace projectMapper {
-    
-    export async function createProject(info:ICommon_Model_Project):Promise<void> {
-        if(!info || !info.name || !info.keyword || info.id){
-            throw  Err.Common.paramError
-        }
-        info.id=await generateSnowId();
-        var mysql=getMysqlInstance() 
-        await mysql.execute(generateCreateSql(projectModel,info))
+import { projectModel } from '../../../common/model/project';
+import { Mapper } from "../../common/entity/mapper";
+;
+class ProjectMapper extends Mapper<typeof projectModel>{
+    constructor(){
+        super(projectModel)
     }
- 
-    export async function getProjecById(id:string):Promise<ICommon_Model_Project> {
-        if(!id) {
-            throw  Err.Project.userIdNotExists
-        }
-        var mysql=getMysqlInstance();
-        let ret=await mysql.executeOne(generateQuerySql(projectModel,[],{id}))
-        return ret
-    }
-
-    export async function updateProject(info:ICommon_Model_Project):Promise<void> {
-        if(!info.id) {
-            throw  Err.Project.userIdNotExists
-        }
-        var mysql=getMysqlInstance();
-        let id=info.id;
-        delete info.id,info.created_time,info.modified_time
-        await mysql.execute(generateUpdateSql(projectModel,info,{id}))
-    }
-
-    export async function deleteProject(id):Promise<void> {
-        if(!id) {
-            throw  Err.Project.userIdNotExists
-        }
-        var mysql=getMysqlInstance();
-        await mysql.execute(generateDeleteSql(projectModel,{id}))
-    }
-}
+}
+export let projectMapper=new ProjectMapper

code/server/cooperation/mapper/tag.ts

@@ -0,0 +1,36 @@
+import { ICommon_RouteRes_Project_ListTag } from "../../../common/routes/response";
+import { Err } from "../../../common/status/error";
+import { getMysqlInstance } from "../../common/db/mysql";
+import { DComponent } from "../../common/decorate/component";
+import { Mapper } from "../../common/entity/mapper";
+import { generateQuerySql } from '../../common/util/sql';
+import { projectLabelModel, Table_Project_Label } from './../../../common/model/project_label';
+class TagMapper extends Mapper<typeof projectLabelModel> {
+    constructor() {
+        super(projectLabelModel)
+    }
+    async listTag(projectId:string,page:number,size:number,keyword:string):Promise<ICommon_RouteRes_Project_ListTag> {
+        if(!projectId || page===undefined || page<0 || size===undefined || size<=0) {
+            throw Err.Common.paramError
+        }
+        let mysql=getMysqlInstance()
+        let ret:Pick<typeof projectLabelModel["model"],"id"|"name">[]=[]
+        let count=await mysql.executeOne<number>(`select count(1) from ${Table_Project_Label} where project_id='${projectId}'${keyword?` and name like %${keyword}%`:""}`)
+        if(count>0) {
+            ret=await mysql.execute(generateQuerySql(projectLabelModel,["id","name"],{
+                project_id:projectId,
+                ...(keyword && {
+                    name:{
+                        exp:"%like%",
+                        value:keyword
+                }})
+            }))
+        }
+        return {
+            totalPage:count,
+            page:page,
+            data:ret
+        }
+    }
+}
+export let tagMapper=new TagMapper

code/server/cooperation/service/project.ts

@@ -1,47 +1,8 @@
+import { Entity } from "../../common/entity/entity";
 import { projectMapper } from '../mapper/project';
-import { ICommon_Model_Project } from '../../../common/model/project';
-import { Err } from '../../../common/status/error';
-import {Entity} from "../../common/entity/entity"
-import { EServer_Common_Event_Types } from '../../common/event/types';
-import { emitServiceEvent } from '../../common/rpc/rpc';
-export default class Project extends Entity<ICommon_Model_Project> {
-    async create():Promise<ICommon_Model_Project> {
-        if(!this.item) {
-            throw  Err.Project.projectNotFound;
-        } else if(this.item.id) {
-            throw  Err.Project.projectExists;
-        }
-        await projectMapper.createProject(this.item)
-        await this.loadItem();
-        return this.item;
+import { projectModel } from './../../../common/model/project';
+export default class Project extends Entity<typeof projectModel,typeof projectMapper> {
+    constructor(){
+        super(projectMapper)
     }
-    async update():Promise<ICommon_Model_Project>{
-        if(!this.item || !this.item.id) {
-            throw  Err.Project.projectNotFound;
-        }
-        await projectMapper.updateProject(this.item)
-        return this.item;
-    }
-    async delete(){
-        await projectMapper.deleteProject(this.item.id);
-        emitServiceEvent(EServer_Common_Event_Types.Project.DELETE,this.item.id);
-    }
-    async loadItem():Promise<ICommon_Model_Project>{
-        if(!this.item || !this.item.id) {
-            throw  Err.Project.projectNotFound;
-        }
-        let obj = await projectMapper.getProjecById(this.item.id);
-        this.item=obj;
-        return this.item;
-    }
-    static async getItemById(id:string):Promise<InstanceType<typeof Project>>{
-        let obj = await projectMapper.getProjecById(id);
-        if(obj) {
-            let user = new Project;
-            user.setItem(obj);
-            return user;
-        } else {
-            return null;
-        }
-    } 
 }

code/server/cooperation/service/tag.ts

@@ -0,0 +1,6 @@
+import { Entity } from "../../common/entity/entity";
+import { projectLabelModel } from './../../../common/model/project_label';
+import { tagMapper } from './../mapper/tag';
+export default class ProjectTag extends Entity<typeof projectLabelModel,typeof tagMapper> {
+    
+}

code/server/user/http/team.ts

@@ -1,6 +1,7 @@
 import * as teamApi from "../../../common/routes/team";
 import { Err } from '../../../common/status/error';
 import { DComponent } from "../../common/decorate/component";
+import { EServer_Common_Event_Types } from "../../common/event/types";
 import { DHttpApi, DHttpReqParamRequired, DHttpUser } from "../../common/http/http";
 import { IUserSession } from '../../common/rpc/api/user';
 import { EServer_Common_User_Type } from '../../common/types/user';
@@ -46,7 +47,7 @@ class TeamController {
         if(!team) {
             throw Err.Team.teamNotFound
         }
-        await team.delete()
+        await team.delete(EServer_Common_Event_Types.Team.DELETE)
     }
     
     @DHttpApi(teamApi.routes.roles)

code/server/user/http/user.ts

@@ -1,10 +1,11 @@
-import { IUserSession } from './../../common/rpc/api/user';
-import { DHttpApi, DHttpContext, DHttpReqParam, DHttpReqParamFile,DHttpContent, DHttpReqParamRequired, DHttpUser } from "../../common/http/http"
-import * as userApi from "../../../common/routes/user"
-import HttpContext from "../../common/http/context"
-import UserService from "../service/user"
-import { Err } from "../../../common/status/error"
+import * as userApi from "../../../common/routes/user";
+import { Err } from "../../../common/status/error";
 import { DComponent } from '../../common/decorate/component';
+import { EServer_Common_Event_Types } from '../../common/event/types';
+import HttpContext from "../../common/http/context";
+import { DHttpApi, DHttpContent, DHttpContext, DHttpReqParamRequired, DHttpUser } from "../../common/http/http";
+import UserService from "../service/user";
+import { IUserSession } from './../../common/rpc/api/user';
 @DComponent
 class UserController {
     @DHttpApi(userApi.routes.create)
@@ -80,7 +81,7 @@ class UserController {
         if(!user) {
             throw Err.User.userNotFound
         }
-        await user.delete()
+        await user.delete(EServer_Common_Event_Types.User.DELETE)
     }
 
     @DHttpApi(userApi.routes.active)

code/server/user/mapper/admin.ts

@@ -1,47 +1,19 @@
 import { Err } from "../../../common/status/error";
 import { getMysqlInstance } from "../../common/db/mysql";
-import { generateCreateSql, generateDeleteSql, generateQuerySql, generateSnowId, generateUpdateSql } from "../../common/util/sql";
-import { userModel, ICommon_Model_User } from './../../../common/model/user';
-export namespace adminMapper {
-    
-    export async function createUser(info:ICommon_Model_User):Promise<void> {
-        if(!info || !info.username || !info.password ||info.id){
-            throw  Err.Common.paramError
-        }
-        info.id=await generateSnowId()
+import { Mapper } from "../../common/entity/mapper";
+import { generateQuerySql } from "../../common/util/sql";
+import { ICommon_Model_User, userModel } from './../../../common/model/user';
+class AdminMapper extends Mapper<typeof userModel> {
+    constructor(){
+        super(userModel)
+    }
+    override async createConfig(info:ICommon_Model_User) {
         info.admin=1
-        var mysql=getMysqlInstance() 
-        await mysql.execute(generateCreateSql(userModel,info))
     }
- 
-    export async function getUserById(id:string):Promise<ICommon_Model_User> {
-        if(!id) {
-            throw  Err.User.userIdNotExists
-        }
-        var mysql=getMysqlInstance();
-        let ret=await mysql.executeOne(generateQuerySql(userModel,[],{id}))
-        return ret
+    override async updateConfig(info:ICommon_Model_User) {
+        info.admin=1
     }
-
-    export async function updateUser(info:ICommon_Model_User):Promise<void> {
-        if(!info.id) {
-            throw  Err.User.userIdNotExists
-        }
-        var mysql=getMysqlInstance();
-        let id=info.id;
-        delete info.id,info.created_time,info.modified_time
-        await mysql.execute(generateUpdateSql(userModel,info,{id}))
-    }
-
-    export async function deleteUser(id):Promise<void> {
-        if(!id) {
-            throw  Err.User.userIdNotExists
-        }
-        var mysql=getMysqlInstance();
-        await mysql.execute(generateDeleteSql(userModel,{id}))
-    }
-
-    export async function getUserByName(name:string):Promise<ICommon_Model_User> {
+    async getUserByName(name:string):Promise<ICommon_Model_User> {
         if(!name) {
             throw  Err.User.userNameNotExists
         }
@@ -50,3 +22,4 @@ export namespace adminMapper {
         return ret
     }
 }
+export let adminMapper=new AdminMapper

code/server/user/mapper/team.ts

@@ -4,9 +4,13 @@ import { teamUserModel } from '../../../common/model/team_user';
 import { userModel } from '../../../common/model/user';
 import { Err } from "../../../common/status/error";
 import { getMysqlInstance } from "../../common/db/mysql";
+import { Mapper } from '../../common/entity/mapper';
 import { generateCreateSql, generateDeleteSql, generateLeftJoin2Sql, generateQuerySql, generateSnowId, generateUpdateSql } from "../../common/util/sql";
-export namespace teamMapper {
-    export async function checkTeam(name:string):Promise<boolean> {
+class TeamMapper extends Mapper<typeof teamModel> {
+    constructor(){
+        super(teamModel)
+    }
+    async checkTeam(name:string):Promise<boolean> {
         if(!name) {
             throw Err.Common.paramError
         }
@@ -15,48 +19,14 @@ export namespace teamMapper {
         return !!ret;
     }
 
-    
-    export async function createTeam(info:ICommon_Model_Team):Promise<void> {
-        if(!info || !info.name  ||info.id){
-            throw  Err.Common.paramError
-        }
-        let isExists=await checkTeam(info.name);
+    override async createConfig(info:ICommon_Model_Team) {
+        let isExists=await this.checkTeam(info.name);
         if(isExists) {
             throw Err.Team.teamExists
         }
-        info.id=await generateSnowId()
-        var mysql=getMysqlInstance() 
-        await mysql.execute(generateCreateSql(teamModel,info))
-    }
- 
-    export async function getTeamById(id:string):Promise<ICommon_Model_Team> {
-        if(!id) {
-            throw  Err.Team.teamNotFound
-        }
-        var mysql=getMysqlInstance();
-        let ret=await mysql.executeOne(generateQuerySql(teamModel,[],{id}))
-        return ret
     }
 
-    export async function updateTeam(info:ICommon_Model_Team):Promise<void> {
-        if(!info.id) {
-            throw  Err.Team.teamNotFound
-        }
-        var mysql=getMysqlInstance();
-        let id=info.id;
-        delete info.id,info.created_time,info.modified_time
-        await mysql.execute(generateUpdateSql(teamModel,info,{id}))
-    }
-
-    export async function deleteTeam(id:string):Promise<void> {
-        if(!id) {
-            throw  Err.Team.teamNotFound
-        }
-        var mysql=getMysqlInstance();
-        await mysql.execute(generateDeleteSql(teamModel,{id}))
-    }
-
-    export async function getRoles(teamId:string):Promise<ICommon_Model_Team_Role[]> {
+    async getRoles(teamId:string):Promise<ICommon_Model_Team_Role[]> {
         if(!teamId) {
             throw  Err.Team.teamNotFound
         }
@@ -70,7 +40,7 @@ export namespace teamMapper {
         return ret
     }
 
-    export async function members(teamId:string):Promise<{
+    async members(teamId:string):Promise<{
         id:string,
         name:string,
         photo:string,
@@ -115,7 +85,7 @@ export namespace teamMapper {
         return ret;
     }
 
-    export async function addMember(teamId:string,userId:string,roleId:string) {
+    async addMember(teamId:string,userId:string,roleId:string) {
         if(!teamId) {
             throw  Err.Team.teamNotFound
         } else if(!userId) {
@@ -145,7 +115,7 @@ export namespace teamMapper {
         }))
     }
 
-    export async function removeMember(teamId:string,userId:string) {
+    async removeMember(teamId:string,userId:string) {
         if(!teamId) {
             throw  Err.Team.teamNotFound
         } else if(!userId) {
@@ -158,7 +128,7 @@ export namespace teamMapper {
         }))
     }
 
-    export async function changeRole(teamId:string,userId:string,roleId:string) {
+    async changeRole(teamId:string,userId:string,roleId:string) {
         if(!teamId) {
             throw  Err.Team.teamNotFound
         } else if(!userId) {
@@ -188,3 +158,5 @@ export namespace teamMapper {
         }))
     }
 }
+
+export let teamMapper=new TeamMapper()

code/server/user/mapper/user.ts

@@ -1,9 +1,13 @@
 import { Err } from "../../../common/status/error";
 import { getMysqlInstance } from "../../common/db/mysql";
-import { generateCreateSql, generateDeleteSql, generateQuerySql, generateSnowId, generateUpdateSql } from "../../common/util/sql";
+import { Mapper } from "../../common/entity/mapper";
+import { generateQuerySql, generateUpdateSql } from "../../common/util/sql";
 import { ICommon_Model_User, userModel } from './../../../common/model/user';
-export namespace userMapper {
-    export async function checkUserValid(username:string):Promise<boolean> {
+class UserMapper extends Mapper<typeof userModel> {
+    constructor(){
+        super(userModel)
+    }
+    async checkUserValid(username:string):Promise<boolean> {
         if(!username){
             return false
         }
@@ -14,25 +18,7 @@ export namespace userMapper {
         return !!ret
     }
     
-    export async function createUser(info:ICommon_Model_User):Promise<void> {
-        if(!info || !info.username || !info.password ||info.id){
-            throw  Err.Common.paramError
-        }
-        info.id=await generateSnowId()
-        var mysql=getMysqlInstance() 
-        await mysql.execute(generateCreateSql(userModel,info))
-    }
- 
-    export async function getUserById(id:string):Promise<ICommon_Model_User> {
-        if(!id) {
-            throw  Err.User.userIdNotExists
-        }
-        var mysql=getMysqlInstance();
-        let ret=await mysql.executeOne(generateQuerySql(userModel,[],{id}))
-        return ret
-    }
-
-    export async function getUserByName(name:string):Promise<ICommon_Model_User> {
+    async getUserByName(name:string):Promise<ICommon_Model_User> {
         if(!name) {
             throw  Err.User.userNameNotExists
         }
@@ -41,25 +27,8 @@ export namespace userMapper {
         return ret
     }
 
-    export async function updateUser(info:ICommon_Model_User):Promise<void> {
-        if(!info.id) {
-            throw  Err.User.userIdNotExists
-        }
-        var mysql=getMysqlInstance();
-        let id=info.id;
-        delete info.id,info.created_time,info.modified_time,info.active
-        await mysql.execute(generateUpdateSql(userModel,info,{id}))
-    }
 
-    export async function deleteUser(id):Promise<void> {
-        if(!id) {
-            throw  Err.User.userIdNotExists
-        }
-        var mysql=getMysqlInstance();
-        await mysql.execute(generateDeleteSql(userModel,{id}))
-    }
-
-    export async function active(id:string,active:number) {
+    async active(id:string,active:number) {
         if(!id) {
             throw  Err.User.userIdNotExists
         }
@@ -67,3 +36,4 @@ export namespace userMapper {
         await mysql.execute(generateUpdateSql(userModel,{active},{id}))
     }
 }
+export let userMapper=new UserMapper()

code/server/user/service/admin.ts

@@ -3,56 +3,13 @@ import { Err } from '../../../common/status/error';
 import { REDIS_USER } from "../../common/cache/keys/user";
 import { Entity } from "../../common/entity/entity";
 import { getNacosInstance } from '../../common/nacos/nacos';
-import { adminMapper } from '../mapper/admin';
-import { ICommon_Model_User } from './../../../common/model/user';
+import { userModel } from './../../../common/model/user';
 import { EServer_Common_User_Type } from './../../common/types/user';
-export default class Admin extends Entity<ICommon_Model_User> {
-    
-    async create():Promise<ICommon_Model_User>{
-        if(!this.item) {
-            throw  Err.User.userNotFound;
-        } else if(this.item.id) {
-            throw  Err.User.userExists;
-        }
-        await adminMapper.createUser(this.item)
-        await this.loadItem();
-        return this.item;
+import { adminMapper } from './../mapper/admin';
+export default class Admin extends Entity<typeof userModel,typeof adminMapper> {
+    constructor(){
+        super(adminMapper)
     }
-    async update():Promise<ICommon_Model_User>{
-        if(!this.item || !this.item.id) {
-            throw  Err.User.userNotFound;
-        }
-        await adminMapper.updateUser(this.item)
-        return this.item;
-    }
-    async delete(){
-        await adminMapper.deleteUser(this.item.id);
-    }
-    async loadItem():Promise<ICommon_Model_User> {
-        if(!this.item || !this.item.id) {
-            throw  Err.User.userNotFound;
-        }
-        let obj = await adminMapper.getUserById(this.item.id);
-        this.item=obj;
-        let session=REDIS_USER.adminInfo(this.item.id);
-        await session.set(obj)
-        return this.item;
-    }
-    static async getItemById(id:string,reload:boolean=false):Promise<InstanceType<typeof Admin>>{
-        let session=REDIS_USER.adminInfo(id);
-        let obj=await session.get();
-        if(!obj || reload) {
-            obj = await adminMapper.getUserById(id);
-            if(!obj) {
-                return null
-            }
-            await session.set(obj)
-        } 
-        let user = new Admin;
-        user.setItem(obj);
-        return user;
-    }
-
     static async getItemByName(name:string):Promise<InstanceType<typeof Admin>>{
         let obj = await adminMapper.getUserByName(name);
         if(obj) {

code/server/user/service/team.ts

@@ -1,3 +1,4 @@
+import { teamModel } from './../../../common/model/team';
 import { ICommon_Model_Team } from '../../../common/model/team';
 import { ICommon_Model_Team_Role } from '../../../common/model/team_role';
 import { Err } from '../../../common/status/error';
@@ -5,45 +6,9 @@ import { Entity } from "../../common/entity/entity";
 import { EServer_Common_Event_Types } from '../../common/event/types';
 import { emitServiceEvent } from '../../common/rpc/rpc';
 import { teamMapper } from '../mapper/team';
-export default class Team extends Entity<ICommon_Model_Team> {
-    
-    async create():Promise<ICommon_Model_Team>{
-        if(!this.item) {
-            throw  Err.Team.teamNotFound;
-        } else if(this.item.id) {
-            throw  Err.Team.teamExists;
-        }
-        await teamMapper.createTeam(this.item)
-        await this.loadItem();
-        return this.item;
-    }
-    async update():Promise<ICommon_Model_Team>{
-        if(!this.item || !this.item.id) {
-            throw  Err.Team.teamNotFound;
-        }
-        await teamMapper.updateTeam(this.item)
-        return this.item;
-    }
-    async delete(){
-        await teamMapper.deleteTeam(this.item.id);
-        emitServiceEvent(EServer_Common_Event_Types.Team.DELETE,this.item.id);
-    }
-    async loadItem():Promise<ICommon_Model_Team> {
-        if(!this.item || !this.item.id) {
-            throw  Err.Team.teamNotFound;
-        }
-        let obj = await teamMapper.getTeamById(this.item.id);
-        this.item=obj;
-        return this.item;
-    }
-    static async getItemById(id:string,reload:boolean=false):Promise<InstanceType<typeof Team>>{
-        let obj = await teamMapper.getTeamById(id);
-        if (!obj) {
-            return null
-        }
-        let team = new Team;
-        team.setItem(obj);
-        return team;
+export default class Team extends Entity<typeof teamModel,typeof teamMapper> {
+    constructor(){
+        super(teamMapper)
     }
 
     async getRoles():Promise<ICommon_Model_Team_Role[]>{

code/server/user/service/user.ts

@@ -6,56 +6,11 @@ import { EServer_Common_Event_Types } from '../../common/event/types';
 import { getNacosInstance } from '../../common/nacos/nacos';
 import { emitServiceEvent } from '../../common/rpc/rpc';
 import { userMapper } from '../mapper/user';
-import { ICommon_Model_User } from './../../../common/model/user';
+import { ICommon_Model_User, userModel } from './../../../common/model/user';
 import { EServer_Common_User_Type } from './../../common/types/user';
-export default class User extends Entity<ICommon_Model_User> {
-    
-    async create():Promise<ICommon_Model_User>{
-        if(!this.item) {
-            throw  Err.User.userNotFound;
-        } else if(this.item.id) {
-            throw  Err.User.userExists;
-        }
-        await userMapper.createUser(this.item)
-        await this.loadItem();
-        return this.item;
-    }
-    async update():Promise<ICommon_Model_User>{
-        if(!this.item || !this.item.id) {
-            throw  Err.User.userNotFound;
-        }
-        await userMapper.updateUser(this.item)
-        await this.loadItem();
-        return this.item;
-    }
-    async delete(){
-        await userMapper.deleteUser(this.item.id);
-        await this.clearCache()
-        emitServiceEvent(EServer_Common_Event_Types.User.DELETE,this.item.id);
-    }
-    async loadItem():Promise<ICommon_Model_User> {
-        if(!this.item || !this.item.id) {
-            throw  Err.User.userNotFound;
-        }
-        let obj = await userMapper.getUserById(this.item.id);
-        this.item=obj;
-        let session=REDIS_USER.info(this.item.id);
-        await session.set(obj)
-        return this.item;
-    }
-    static async getItemById(id:string,reload:boolean=false):Promise<InstanceType<typeof User>>{
-        let session=REDIS_USER.info(id);
-        let obj=await session.get();
-        if(!obj || reload) {
-            obj = await userMapper.getUserById(id);
-            if(!obj) {
-                return null
-            }
-            await session.set(obj)
-        } 
-        let user = new User;
-        user.setItem(obj);
-        return user;
+export default class User extends Entity<typeof userModel,typeof userMapper> {
+    constructor(){
+        super(userMapper)
     }
 
     static async getItemByName(name:string):Promise<InstanceType<typeof User>>{