@simitgroup/simpleapp-generator 1.0.32 → 1.0.35

package/templates/nest/src/simpleapp/generate/commons/user.context.ts.eta

@@ -0,0 +1,391 @@
+/**
+ * todo
+ * 1.base on xorg get current role and group
+ * 2. get profile want to obtain branchlist and invitation list
+ * 3. xorglist to user shall display appropriate tenant/org/branch name
+ */
+
+import { Injectable, Scope,Inject,Logger, BadRequestException } from '@nestjs/common';
+import { Model, model, connect, PipelineStage } from 'mongoose';
+import _ from 'lodash'
+import { Module } from '@nestjs/common';
+import * as jwt from 'jsonwebtoken';
+import { Role } from './roles/roles.enum';
+import * as rolegroups from './roles/roles.group'
+import { UserService } from './../../services/user.service';
+import { InjectModel } from '@nestjs/mongoose';
+const Base64URL = require('@darkwolf/base64url');
+import { UserMongoSchema } from './../models/user.model';
+import {   User,  }  from './../types/user.type';
+import {   Permission,  }  from './../types/perm.type';
+import {ProfileUserBranch , ProfileUserInvites} from '../../profile/profile.types'
+
+import {ClientSession}  from 'mongoose'
+@Injectable()
+export class UserContext {
+  protected logger = new Logger()
+  protected uid: string = '';
+  protected _id: string = '';
+  protected uname: string = '';
+  protected email: string = '';
+  protected fullname: string = '';
+  protected xOrg: string = '';
+  protected tenantId: number = 0;
+  protected orgId: number = 0;
+  protected branchId: number = 0;
+  protected ssoACL: any = {};
+  protected token: string = '';
+  protected refreshtoken: string = '';
+  protected group: string = '';
+  protected branchCode: string = '';
+  protected branchName: string = '';  
+  protected branches: any[] = []
+  protected invites: any[] = []  //User + field tenant:Tenant[]
+  protected roles: string[] = [];
+  
+
+  constructor(
+    private readonly usermodel:Model<User>,
+    private readonly permmodel:Model<Permission>,
+    private dbsession:ClientSession
+    ) {
+    
+  }
+  getDBSession = ():ClientSession => this.dbsession
+
+  getId = () => this._id;
+  getUid = () => this.uid;
+  getUname = () => this.uname;
+  getFullname = () => this.fullname;
+  getTenantId = () => this.tenantId;
+  getOrgId = () => this.orgId;
+  getBranchId = () => this.branchId;
+  getEmail = () => this.email;
+  getGroup = () => this.group;
+  getRoles = () => this.roles;
+  getBranches = ():ProfileUserBranch[] => {
+    this.branches;
+    const data:ProfileUserBranch[] = []
+
+    if(this.branches){
+      for(let i=0;i<this.branches.length; i++){
+        const b= this.branches[i]
+        data.push({
+          _id: b._id,          
+          branch: b.branch[0],
+          group: b.group,
+          xOrg: this.generateXorg(b.tenantId,b.orgId,b.branchId)
+
+        })
+      }
+    }
+    return data
+    
+  }
+  getInvites = ():ProfileUserInvites[] =>{
+    
+    // const usermodel = model<User>('user',UserMongoSchema,'user')    
+    
+    const data:ProfileUserInvites[] = []
+    if( this.invites){
+      // console.log("getInvites",res)
+      for(let i=0;i< this.invites.length; i++){
+        const r =  this.invites[0]
+        
+        data.push({
+          _id: r._id,
+          email: r.email,
+          tenantId: r.tenantId,
+          fullName: '',
+          tenantName: r.tenant[0].tenantName,
+          created: r.created,
+        })
+      }
+    }
+    return data    
+    
+    };
+  setCurrentUserInfo = async (tokenstr: string,xorg)=>{
+    this.setXorg(xorg);      
+    await this.setUserToken(tokenstr)
+    
+  }
+
+  /**
+   * obtain user profile filter by uid,tenantId,orgId,branchId
+   * @returns Promise<User|undefined>
+   */
+  obtainProfileFromDb = async () : Promise<User|undefined>=>{
+    const filter = { $match:{uid:this.uid,tenantId:this.tenantId} }
+    
+    
+
+
+    const joinpermission:PipelineStage = {$lookup: {
+      from : 'permission',
+      localField : 'uid',
+      foreignField : 'uid',
+      as : 'permissions',
+      pipeline:[
+          { $match:{
+            uid:this.uid,
+            tenantId:this.tenantId,
+            orgId:this.orgId,
+            branchId:this.branchId,            
+          }},
+          {$lookup:{from: 'branch',localField: 'branchId',foreignField:'branchId',as: 'currentbranch'}}
+        ]
+    }}
+
+    const pipeline:PipelineStage[]=[filter,]
+
+    if(this.tenantId>0){
+      pipeline.push(joinpermission)
+    }
+    // console.log("obtainProfileFromDbobtainProfileFromDb ",pipeline)
+    // const users = await usermodel.find(filter)
+    const users = await this.usermodel.aggregate(pipeline)
+    this.logger.verbose(`aggregate user profile from database`,'obtainProfileFromDb' )   
+    this.logger.verbose(pipeline,'obtainProfileFromDb x' )   
+    this.logger.verbose(users,'obtainProfileFromDb' )   
+    // console.log("obtainProfileFromDbobtainProfileFromDb ",users)
+    if(users && users.length>0){
+      const userinfo = users[0]
+      // console.log("userinfouserinfouserinfouserinfouserinfouserinfo ",userinfo)
+
+      if(this.tenantId>0){
+        const myperm=userinfo.permissions[0]
+        if(myperm && myperm.group){
+          userinfo.group = myperm.group                    
+          userinfo.roles = rolegroups[userinfo.group]   
+          userinfo.branchCode = myperm.currentbranch[0].branchCode
+          userinfo.branchName = myperm.currentbranch[0].branchName          
+        }    
+      }else{        
+        userinfo.group = '' 
+      }
+      
+      return userinfo  
+    }else{
+      return undefined
+    }
+    
+  }
+  setUserToken = async (tokenstr: string) => {    
+
+    //define token info
+    const tokeninfo = jwt.decode(tokenstr);      
+    this.token = tokenstr;
+    this.uid = tokeninfo.sub;
+    this.email = tokeninfo.email;
+    this.uname = tokeninfo.preferred_username;
+    this.fullname = tokeninfo.name;    
+    this.ssoACL = tokeninfo.resource_access;    
+    this.logger.verbose(`set token ${this.uid}`)   
+    //read current user from db
+    // console.log("await this.obtainProfileFromDb()")
+    const userinfo = await this.obtainProfileFromDb()      
+    this.logger.verbose(userinfo,'obtainProfileFromDb result')    
+    if(userinfo){
+      this.logger.debug(`${this.uid} user exists in tenant (${this.tenantId})`,'setUserToken' )   
+
+      this._id = userinfo._id.toString()
+      this.branchCode = userinfo['branchCode'] ?? ''
+      this.branchName = userinfo['branchName'] ?? ''
+      this.group = userinfo['group'] ?? ''
+      this.roles = userinfo['roles'] ?? [Role.Everyone,Role.User]
+    }else{
+      this.logger.debug(`Set unknown id of current user`,'setUserToken' )   
+      // this.group = ''
+      // this.tenantId=0
+      // this.orgId=0
+      // this.branchId=0
+      this.roles = [Role.Everyone,Role.Unknown]
+    }
+    this.logger.debug(`${this.uid} have _id (${this.getId()}), group (${this.group}) and role (${this.getRoles()})` )   
+
+    if(this.isRealmAdmin() && !this.roles.includes(Role.SuperAdmin)){
+      this.roles.push(Role.SuperAdmin)
+    }
+    this.logger.verbose(this)   
+  };
+
+
+  generateXorg = (tenantId:number,orgId:number,branchId:number):string=>{
+    return Base64URL.encodeText(`${tenantId}-${orgId}-${branchId}`)
+  }
+  getInfo = () => {    
+    return this;
+  };
+  getBranchFilter = () => {
+    return {
+      tenantId: this.tenantId,
+      orgId: this.orgId,
+      branchId: this.branchId,
+    };
+  };
+  getTenantFilter = () => {
+    return { tenantId: this.tenantId };
+  };
+  getOrgFilter = () => {
+    return {
+      tenantId: this.tenantId,
+      orgId: this.orgId,
+    };
+  };
+  getWorkflowTaskFilter() {
+    return {
+      'data.tenantId': this.tenantId,
+      'assignments.assignee': this.getUid(),
+      // 'assignments.assignee': User.getInstance().getUid(),
+    };
+  }
+  getCreateFilter = () => {
+    const u = this;
+    return {
+      tenantId: u.tenantId,
+      orgId: u.orgId,
+      branchId: u.branchId,
+      createdby: u.uid,
+      updatedby: u.uid,
+      created: new Date().toISOString(),
+      updated: new Date().toISOString()
+    };
+  };
+  getUpdateFilter = () => {
+    const u = this;
+    return {
+      updatedby: u.uid,
+      updated: new Date().toISOString()
+    };
+  };  
+  setXorg = (xorg) => {
+    try {
+      const decodedText: string = Base64URL.decodeText(xorg);
+      const arrXorg = decodedText.split('-');
+
+      if (arrXorg.length == 3) {
+        const u = this;
+        u.tenantId = Number(arrXorg[0]);
+        u.orgId = Number(arrXorg[1]);
+        u.branchId = Number(arrXorg[2]);     
+        
+      } else {
+        throw 'invalid x-org';
+      }
+    } catch (err) {
+      throw err;
+    }
+  };
+
+
+  async getUserInfo(){
+     
+    // obtain basic user info
+    const userinfo = {
+      _id: this.getId() ,
+      tenantId: this.getTenantId(),
+      orgId: this.getOrgId(),
+      branchId: this.getBranchId(),
+      branchCode: this.branchCode,
+      branchName: this.branchName,
+      email: this.getEmail(),
+      uid: this.getUid(),
+      fullName: this.getFullname(),
+      group: this.group,
+      roles: this.getRoles(),
+      branches: this.getBranches(),
+      invites: await this.getInvites()
+    }
+    this.logger.debug(userinfo,"init getUserInfo()")
+
+    if(this.getId()!=''){
+      this.logger.debug(userinfo,"obtain permissions and invitations")
+      const filter:PipelineStage ={ $match:{uid:this.uid }} as PipelineStage
+      const permission:PipelineStage = {$lookup: {
+      from : 'permission',
+      localField : 'uid',
+      foreignField : 'uid',
+      as : 'permissions',
+      pipeline:[
+        {$match:{uid: this.uid,},},
+        {$lookup:{from : 'branch',localField : 'branchId',foreignField : 'branchId',as : 'branch',}},
+      ]
+    }}
+    const lookupinvitation:PipelineStage = {$lookup: {
+      from : 'user',
+      localField : 'email',
+      foreignField : 'email',
+      as : 'invites',
+      pipeline:[
+        {$match:{uid: ''}},
+        {$lookup:{from : 'tenant',localField : 'tenantId',foreignField : 'tenantId',as : 'tenant',}},
+      ]
+    }}
+
+    const pipeline:PipelineStage[]=[
+      filter,
+      permission,
+      lookupinvitation
+    ]
+    this.logger.debug(pipeline,"getUserInfo")
+    // // // const users = await usermodel.find(filter)
+    const users = await this.usermodel.aggregate(pipeline)
+
+    
+    this.invites = users[0].invites
+    this.branches = users[0].permissions
+    this.logger.verbose(users,"getUserInfo")
+    userinfo.branches=this.getBranches()
+    userinfo.invites=this.getInvites()
+    // this.logger.debug(`getUserInfo result ${userinfo}`)
+    
+    }else{
+      this.logger.log(`${this.getUid()} does not exists in current tenant (${this.tenantId})`)
+    }
+    
+
+    return userinfo
+  }
+  async decideInvitation (id:string, decision:string):Promise<boolean> {
+    
+    // const usermodel = model<User>('user',UserMongoSchema,'user')
+    const res = await this.usermodel.findById(id)
+    // console.log("find invitation:",res)
+    if(!res.uid){
+      res.uid = this.getUid()
+      res.fullname = this.fullname
+      res.active = true
+      
+      if(decision=='accept'){
+        const result = await res.save({session:this.dbsession})
+        this.logger.log(result,"accept invitation 1")
+        //set permission of all user under this.user_id
+        const updateresult = await this.permmodel.updateMany({ uid:'',user_id:res._id},{uid:this.getUid()}).session(this.dbsession)
+        this.logger.log(updateresult,"update all permission")
+        return true
+      }else{
+        const deleteresult = await this.usermodel.deleteOne({_id: id}).session(this.dbsession)         
+        await this.permmodel.deleteMany({ uid:'',user_id:res._id}).session(this.dbsession)
+        return true
+      }          
+    }else{
+      throw new BadRequestException(`${id} not found.`)
+    }    
+
+  }
+
+  isRealmAdmin = ()=>{
+    const o = this.ssoACL    
+    const ssoclient = process.env.OAUTH2_CLIENTID
+    const adminRole = process.env.OAUTH2_ADMINROLE    
+    if( o[ssoclient] && o[ssoclient]['roles'] && o[ssoclient]['roles'] == adminRole ){
+      //console.log("isadmin")
+          return true
+    }else{     
+      //console.log("not admin")
+      return false
+    }
+    
+  }
+}

package/templates/nest/src/simpleapp/generate/controllers/simpleapp.controller.ts.eta

@@ -0,0 +1,71 @@
+import {
+  Controller,
+  Get,
+  Put,
+  Post,
+  Delete,
+  Body,
+  Param,
+  Type,
+} from '@nestjs/common';
+// import { ApiTags, ApiBody, ApiResponse, ApiOperation } from '@nestjs/swagger';
+import {UserContext} from '../commons/user.context'
+import {SearchBody} from '../types';
+const doctype = 'person'.toUpperCase();
+type ServiceType = {
+  list: Function;
+  search: Function;
+  create: Function;
+  //update: Function;
+  //delete: Function;
+  findById: Function;
+  findIdThenDelete: Function;
+  findIdThenUpdate: Function;
+  setData: Function;
+  getAutoComplete: Function;
+};
+
+// @ApiTags(doctype)
+// @Controller(doctype.toLowerCase())
+export class SimpleAppAbstractController<TService extends ServiceType, TApiSchema, T> {
+  protected service: TService;
+  protected tryno: number;
+  //   protected apiSchemaClass=
+
+  constructor(service: TService) {
+    this.service = service;
+  }
+
+  async _list(appuser:UserContext) {
+    return this.service.list(appuser,);
+  }
+  async _search(appuser:UserContext,searchObject:SearchBody) {
+    
+    return this.service.search(appuser,searchObject['filter'], searchObject['fields'],searchObject['sorts']);
+  }
+  async _autocomplete(appuser:UserContext,keyword: string) {
+    return this.service.getAutoComplete(appuser,keyword);
+  }
+  async _findOne(appuser:UserContext,id: string) {
+    const result = (await this.service.findById(appuser,id)) as TApiSchema;
+
+    return result as Type<TApiSchema>;
+  }
+
+  async _create(appuser:UserContext,data: TApiSchema) {
+    //const newdata: persontype.Person = { ...data };
+    const newdata: T = {} as T; //= { ...data };
+    Object.assign(newdata, data); //
+    return this.service.create(appuser,newdata) as TApiSchema;
+  }
+
+  async _update(appuser:UserContext,id: string, data: TApiSchema) {
+    const newdata: T = {} as T; //= { ...data };
+    Object.assign(newdata, data); //
+    return this.service.findIdThenUpdate(appuser,id, newdata) as TApiSchema;
+  }
+
+  async _delete(appuser:UserContext,id: string) {
+    return this.service.findIdThenDelete(appuser,id);
+  }
+}

package/templates/nest/src/simpleapp/generate/models/perm.model.ts.eta

@@ -0,0 +1,53 @@
+/**
+ * This file was automatically generated by simpleapp generator.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and regenerate this file.
+ * last change 2023-09-09
+ * Author: Ks Tan
+ */
+
+import { Schema } from 'mongoose';
+import {  Permission,  }  from '../types/perm.type';
+const schemasetting = {
+  
+      
+    
+          tenantId: {type: Number, required: false},  //field 
+          
+    
+          orgId: {type: Number, required: false},  //field 
+          
+    
+          branchId: {type: Number, required: false},  //field 
+          
+    
+          group: {type: String, required: false},  //field 
+          
+    
+          uid: {type: String, required: false},  //field 
+          
+    
+          user_id: {type: String, required: false},  //field 
+          
+    
+          _id: {type:'string', required:true},
+          
+    
+          doctype: {type: String, required: false},  //field 
+          
+    
+          created: {type: String, required: false},  //field 
+          
+    
+          updated: {type: String, required: false},  //field 
+          
+    
+          createdby: {type: String, required: false},  //field 
+          
+    
+          updatedby: {type: String, required: false},  //field 
+      };
+
+export const PermissionMongoSchema = new Schema(schemasetting,{collection: 'permission'})
+    .index({user_id:1,branchId:1},{unique:true})
+    // .index({productName:1,orgId:1});

package/templates/nest/src/simpleapp/generate/models/tenant.model.ts.eta

@@ -0,0 +1,45 @@
+/**
+ * This file was automatically generated by simpleapp generator.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and regenerate this file.
+ * last change 2023-09-09
+ * Author: Ks Tan
+ */
+
+import { Schema } from 'mongoose';
+import { TenantOwner, Tenant } from '../types/tenant.type';
+const schemasetting = {
+  tenantId: { type: Number, required: true }, //field
+
+  tenantName: { type: String, required: true }, //field
+
+  uuid: { type: String, required: false }, //field
+
+  active: { type: Boolean, required: false,default:true }, //field
+
+  description: { type: String, required: false }, //field
+
+  owner: { type: <TenantOwner>{}, required: false }, //object
+
+  _id: {type:'string', required:true},
+
+  doctype: { type: String, required: false }, //field
+
+  created: { type: String, required: false }, //field
+
+  updated: { type: String, required: false }, //field
+
+  createdby: { type: String, required: false }, //field
+
+  updatedby: { type: String, required: false }, //field
+
+  orgId: { type: Number, required: false }, //field
+
+  branchId: { type: Number, required: false }, //field
+};
+
+export const TenantMongoSchema = new Schema(schemasetting, {
+  collection: 'tenant',
+})
+.index({ tenantId: 1 }, { unique: true })
+.index({ uuid:1 },{unique:true});

package/templates/nest/src/simpleapp/generate/models/user.model.ts.eta

@@ -0,0 +1,57 @@
+/**
+ * This file was automatically generated by simpleapp generator.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and regenerate this file.
+ * last change 2023-09-09
+ * Author: Ks Tan
+ */
+
+import { Schema } from 'mongoose';
+import {  User,  }  from '../types/user.type';
+const schemasetting = {
+  
+      
+    
+          uid: {type: String, required: false},  //field 
+          
+    
+          fullname: {type: String, required: true},  //field 
+          
+    
+          email: {type: String, required: true},  //field 
+          
+    
+          active: {type: Boolean, required: false,default:true},  //field 
+          
+    
+          _id: {type:'string', required:true}, 
+          
+    
+          doctype: {type: String, required: false},  //field 
+          
+    
+          created: {type: String, required: false},  //field 
+          
+    
+          updated: {type: String, required: false},  //field 
+          
+    
+          createdby: {type: String, required: false},  //field 
+          
+    
+          updatedby: {type: String, required: false},  //field 
+          
+    
+          tenantId: {type: Number, required: false},  //field 
+          
+    
+          orgId: {type: Number, required: false},  //field 
+          
+    
+          branchId: {type: Number, required: false},  //field 
+      };
+
+export const UserMongoSchema = new Schema(schemasetting,{collection: 'user'})
+      .index({email:1,tenantId:1},{unique:true})
+    .index({fullname:1,tenantId:1});
+