add

code/common/model/project.ts

@@ -1,6 +1,8 @@
+import { BaseModel } from "./base"
+
 export interface ICommon_Model_Project {
     id :string,
-  key :string,
+  keyword :string,
   name :string,
   created_time :Date,
   modified_time :Date,
@@ -8,4 +10,9 @@ export interface ICommon_Model_Project {
   created_by :string ,
   description :string,
 }
-export const Table_Project="project"
+export const Table_Project="project"
+
+export class ProjectModel extends BaseModel {
+  table=Table_Project
+  model=<ICommon_Model_Project>{}
+}

code/common/routes/project.ts

@@ -13,8 +13,7 @@ const api={
                 projectId:string                
             }>{},
             res:<ICommon_Model_Project>{},
-            permission:[Permission_Types.Project.READ],
+            permission:[Permission_Types.Project.READ]
-            ignoreValidate:true
         },
     }
 }

code/common/status/error.ts

@@ -45,10 +45,20 @@ export namespace Err {
             msg:"over file size"
         }
     }
-    
+    export let Project = {
-
+        userIdNotExists:{
-    
+            code:3000,
-
+            msg:"project id not exists"
+        },
+        projectNotFound:{
+            code:3001,
+            msg:"project not found"
+        },
+        projectExists:{
+            code:3002,
+            msg:"project exists"
+        },
+    }
 
 }
 

code/server/common/event/types.ts

@@ -1,6 +1,9 @@
 export namespace EServer_Common_Event_Types {
-    export type Types= User
+    export type Types= User|Project
     export enum User {
         DELETE="delete user"  //userId:string
     }
+    export enum Project {
+        DELETE="delete project"  //userId:string
+    }
 }

code/server/common/permission/base.ts

@@ -30,10 +30,12 @@ export async function processPermission (arrPermission:Permission_Base[],objCont
                     if (!isExists) {
                         value = await objPermission.create(objContent)
                         if (value !== null) {
-                            await getRedisInstance().set(key, value)
+                            await getRedisInstance().set(key, value,3600*6)
                         } else {
                             return false
                         }
+                    } else {
+                        value =await getRedisInstance().get(key,{})
                     }
                     keyMap[key] = value;
                 }
@@ -50,6 +52,7 @@ export async function processPermission (arrPermission:Permission_Base[],objCont
         }
         return true
     } catch (err) {
+        console.error(err)
         return false
     }
     

code/server/common/permission/project/relation.ts

@@ -31,7 +31,7 @@ export class PermissionProjectRead extends PermissionBase<IPermission_Project_Ca
         let arr:string[]=[]
         for(let obj of arrRolePermission) {
             let objPermission = await mysql.executeOne(generateQuerySql(new PermissionModel,[],{
-                id:obj.role_id
+                id:obj.permission_id
             }))
             if(objPermission) {
                 arr.push(objPermission.value)
@@ -40,7 +40,7 @@ export class PermissionProjectRead extends PermissionBase<IPermission_Project_Ca
         return arr;
     }
     check(obj:IPermission_Project_CacheValue):boolean {
-        return obj.includes[Permission_Types.Project.READ.value];
+        return obj.includes(Permission_Types.Project.READ.value);
     }
     getKey({userId,projectId}) {
         if(StringUtil.isEmpty(userId) || StringUtil.isEmpty(projectId)) {

code/server/cooperation/http/cooperation.ts

@@ -0,0 +1,17 @@
+
+
+import { DHttpApi, DHttpContext, DHttpReqParam, DHttpReqParamFile,DHttpContent, DHttpReqParamRequired, DHttpUser } from "../../common/http/http"
+import * as projectApi from "../../../common/routes/project"
+import HttpContext from "../../common/http/context"
+import { Err } from "../../../common/status/error"
+import { IUserSession } from "../../common/rpc/api/user"
+import Project from "../service/project"
+class UserController {
+    @DHttpApi(projectApi.routes.basic)
+    async projectBasicInfo(@DHttpReqParamRequired("projectId") projectId:string):Promise<typeof projectApi.routes.basic.res>{
+        let obj=await Project.getItemById(projectId);
+        return obj.getItem();
+    }
+
+}
+export default new UserController

code/server/cooperation/index.ts

@@ -1,5 +1,5 @@
 import Cooperation from "./app/app";
-
+import "./http/cooperation"
 var application = new Cooperation()
 application.start();
 

code/server/cooperation/mapper/project.ts

@@ -0,0 +1,42 @@
+import { Table_Project, ICommon_Model_Project, ProjectModel } from '../../../common/model/project';
+import { getMysqlInstance } from "../../common/db/mysql"
+import {Err} from "../../../common/status/error"
+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(new ProjectModel,info))
+    }
+ 
+    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(new 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(new ProjectModel,info,{id}))
+    }
+
+    export async function deleteProject(id):Promise<void> {
+        if(!id) {
+            throw  Err.Project.userIdNotExists
+        }
+        var mysql=getMysqlInstance();
+        await mysql.execute(generateDeleteSql(new ProjectModel,{id}))
+    }
+}

code/server/cooperation/service/project.ts

@@ -0,0 +1,47 @@
+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;
+    }
+    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/gateway/app/app.ts

@@ -8,6 +8,7 @@ import { getNacosInstance } from "../../common/nacos/nacos";
 import { CacheService } from './../cache/service';
 import {generateHttpErrorResponse} from "../../common/util/http"
 import * as userApi from "../../../common/routes/user"
+import * as projectApi from "../../../common/routes/project"
 import { ICommon_HttpApi } from "../../../common/routes/types";
 import {  EServer_Common_Http_Body_Type, IServer_Common_Http_Proxy, IServer_Common_Http_Req_File } from "../../common/types/http";
 import { parseFormData } from "../util/util";
@@ -20,7 +21,7 @@ import {getComponent} from "../../common/decorate/component"
 import { Permission_Base } from '../../../common/permission/permission';
 import { processPermission } from '../../common/permission/base';
 import { EServer_Common_User_Type } from '../../common/types/user';
-var apis:ICommon_HttpApi[]=[userApi];
+var apis:ICommon_HttpApi[]=[userApi,projectApi];
 var app = new Koa();
 var pipe=function (from,to) :Promise<string>{
     return new Promise(function (resolve) {
@@ -44,7 +45,7 @@ export default class GateWay extends Application {
     override async config() {
         let cacheService=new CacheService()
         cacheService.start()
-        await initSystem()
+        //await initSystem()
         await this.initKoa();
     }
     async initKoa() {
@@ -160,9 +161,15 @@ export default class GateWay extends Application {
                     if (ctx.state.formData) {
                         obj.bodyType = EServer_Common_Http_Body_Type.FORMDATA
                     }
-                    if(permission && permission.length>0 && (ctx.state.user && ctx.state.user.type==EServer_Common_User_Type.USER)) {
+                    if(permission && permission.length>0) {
-                        let isCheck = processPermission(permission,Object.assign({},obj.data,{userId:ctx.state.user?ctx.state.user.userId:undefined}))
+                        if(ctx.state.user) {
-                        if(!isCheck) {
+                            if(ctx.state.user.type==EServer_Common_User_Type.USER) {
+                                let isCheck =await processPermission(permission,Object.assign({},obj.data,{userId:ctx.state.user?ctx.state.user.userId:undefined}))
+                                if(!isCheck) {
+                                    throw Err.User.accessDenied
+                                }
+                            }
+                        } else {
                             throw Err.User.accessDenied
                         }
                     }

code/server/gateway/util/util.ts

@@ -1,3 +1,5 @@
+import { Table_Project_User } from './../../../common/model/project_user';
+import { Table_User } from './../../../common/model/user';
 import { Table_Role_Permission } from './../../../common/model/role_permission';
 import { Table_Project_Role } from './../../../common/model/project_role';
 import { Table_Permission } from './../../../common/model/permission';
@@ -8,6 +10,7 @@ import { Permission_Base, Permission_Types } from '../../../common/permission/pe
 import { generateSnowId } from '../../common/util/sql';
 import { OBTPConfig } from './obtp';
 import { getNacosInstance } from '../../common/nacos/nacos';
+import { Table_Project } from '../../../common/model/project';
 export interface IServer_GateWay_FormData {
     isFile:boolean,
     name:string,
@@ -53,6 +56,9 @@ async function resetSystem(){
     await mysql.execute(`delete from ${Table_Permission}`) 
     await mysql.execute(`delete from ${Table_Project_Role}`) 
     await mysql.execute(`delete from ${Table_Role_Permission}`) 
+    await mysql.execute(`delete from ${Table_User}`) 
+    await mysql.execute(`delete from ${Table_Project}`) 
+    await mysql.execute(`delete from ${Table_Project_User}`) 
 }
 
 export async function initSystem() {
@@ -64,7 +70,11 @@ export async function initSystem() {
             [param:number]:string
         }>{}
         let adminId=await generateSnowId()
+        let userId=await generateSnowId()
+        let projectId=await generateSnowId()
         await mysql.execute(`insert into ${Table_Admin} (id,name,password) values ('${adminId}','teamlinker','teamlinker')`)
+        await mysql.execute(`insert into ${Table_User} (id,username,password) values ('${userId}','sx','sx')`)
+        await mysql.execute(`insert into ${Table_Project} (id,name,keyword,created_by) values ('${projectId}','test','test','${userId}')`)
         for(let key in Permission_Types) {
             let value=Permission_Types[key]
             let type=key
@@ -80,10 +90,13 @@ export async function initSystem() {
                 }
             }
         }
-        let objProjectRole=OBTPConfig.Role.Project_Role
+        let objProjectRole=OBTPConfig.Role.Project_Role,projectRoleUserId;
         for(let key in objProjectRole) {
             let obj=objProjectRole[key]
             let projectRoleId=await generateSnowId()
+            if(obj.name=="user") {
+                projectRoleUserId=projectRoleId
+            }
             let name=obj.name
             let description=obj.description
             await mysql.execute(`insert into ${Table_Project_Role} (id,name,description) values ('${projectRoleId}','${name}','${description}')`)
@@ -92,6 +105,7 @@ export async function initSystem() {
                 await mysql.execute(`insert into ${Table_Role_Permission} (id,role_id,permission_id) values ('${id}','${projectRoleId}','${objPermission[o.value]}')`)
             }
         }
+        await mysql.execute(`insert into ${Table_Project_User} (id,role,project_id,user_id) values ('${await generateSnowId()}','${projectRoleUserId}','${projectId}','${userId}')`)
         await mysql.execute(`insert into ${Table_Version} (version) values ('${getNacosInstance().version}')`)
     }
     console.log("init finish")

code/server/user/http/user.ts

@@ -7,7 +7,6 @@ import { Err } from "../../../common/status/error"
 class UserController {
     @DHttpApi(userApi.routes.create)
     async create(@DHttpContent content:typeof userApi.routes.create.req,@DHttpUser userInfo:IUserSession):Promise<typeof userApi.routes.create.res>{
-        console.log(userInfo)
         let user=new UserService()
         user.assignItem(content);
         let obj=await user.create()

code/server/user/mapper/user.ts

@@ -1,7 +1,7 @@
 import { Table_User, ICommon_Model_User, UserModel } from './../../../common/model/user';
 import { getMysqlInstance } from "../../common/db/mysql"
 import {Err} from "../../../common/status/error"
-import {generateCreateSql, generateDeleteSql, generateQuerySql, generateUpdateSql} from "../../common/util/sql"
+import {generateCreateSql, generateDeleteSql, generateQuerySql, generateSnowId, generateUpdateSql} from "../../common/util/sql"
 export namespace userMapper {
     export async function checkUserValid(username:string):Promise<boolean> {
         if(!username){
@@ -17,9 +17,10 @@ export namespace userMapper {
     }
     
     export async function createUser(info:ICommon_Model_User):Promise<void> {
-        if(!info || !info.username || !info.password ||!info.id){
+        if(!info || !info.username || !info.password ||info.id){
             throw  Err.Common.paramError
         }
+        info.id=await generateSnowId()
         var mysql=getMysqlInstance() 
         await mysql.execute(generateCreateSql(new UserModel,info))
     }

code/server/user/service/user.ts

@@ -17,7 +17,6 @@ export default class User extends Entity<ICommon_Model_User> {
         } else if(this.item.id) {
             throw  Err.User.userExists;
         }
-        this.item.id=await generateSnowId()
         await userMapper.createUser(this.item)
         await this.loadItem();
         return this.item;