@simitgroup/simpleapp-generator 1.0.32 → 1.0.35

package/templates/nest/src/simpleapp/generate/commons/dicts/foreignkeys.ts.eta

@@ -0,0 +1 @@
+export const foreignkeys = <%~JSON.stringify(it.foreignkeys)%>

package/templates/nest/src/simpleapp/generate/commons/docnogenerator.service.ts.eta

@@ -0,0 +1,101 @@
+import { UserContext } from './user.context';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import {DocNumberFormatResult} from '../types'
+import { Docnoformat } from '../types/docno.type'
+import { Injectable, InternalServerErrorException,BadRequestException } from '@nestjs/common';
+import * as moment from 'moment';
+import {ForeignKey} from '../types'
+
+export class DocNumberFormatGenerator{
+  constructor(@InjectModel('Docnoformat') private docformat: Model<Docnoformat>) {}
+
+
+  async generateNextNumberFromDocument(appuser:UserContext,docType:string,data:any){
+    let formatId = ''
+    if(data.docNoFormat && data.docNoFormat._id){
+      formatId=data.docNoFormat._id
+    }
+    const docnoobj = await this.generateNextNo(appuser,docType,formatId)        
+    const result:ForeignKey = {
+      _id : String(docnoobj.formatId),
+      label: docnoobj.formatName
+    }
+    data.docNoFormat = result
+    return docnoobj.result
+  }
+
+
+  generateNextNo = async (appuser: UserContext,doctype: string,id: string = '') => {
+    doctype = doctype.toUpperCase();
+    let filter = { docNoType: doctype };
+    if (id) {
+      filter['_id'] = id;
+    }
+    Object.assign(filter,appuser.getBranchFilter())
+    const result = await this.docformat.find(filter)
+    //search(appuser, filter);
+    if (result && result.length > 0) {
+      const d: Docnoformat = result[0];
+      const recordId = d._id;
+      const newdocno = DocNumberFormatGenerator.previewDocNo(d);
+      const newnextnumber = d.nextNumber + 1;
+      const updatedata = { nextNumber: newnextnumber } as Docnoformat;
+      const updateresult = await this.docformat.findByIdAndUpdate(recordId,updatedata).session(appuser.getDBSession())
+      
+      if (updateresult) {         
+        const result:DocNumberFormatResult = {formatId:d._id,formatName:d.docNoFormatName,result: newdocno }
+        return result 
+        //;
+      } else {
+        throw new InternalServerErrorException(
+          `Update document format ${doctype}/${recordId} to next number (${newnextnumber}) failed`,
+        );
+      }
+    } else {
+      throw new BadRequestException(
+        `invalid parameter doctype: "${doctype}" or id: ${id}`,
+      );
+    }
+  };
+  static previewDocNo = (s: Docnoformat) => {
+    try {
+      const pattern = s.docNoPattern;
+      const numberReg: RegExp = /\<(.*?)\>/g;
+      const dateReg: RegExp = /\{(.*?)\}/g;
+      let newvalue = pattern;
+      const numberpattern: string[] = pattern.match(numberReg);
+      const datepattern: string[] = pattern.match(dateReg);
+
+      if (numberpattern && numberpattern.length > 0) {
+        const numberlength = numberpattern[0]
+          .replace('<', '')
+          .replace('>', '').length;
+
+        let nextnumber = s.nextNumber.toString();
+
+        const numberdiff = numberlength - nextnumber.length;
+
+        for (let n = 0; n < numberdiff; n++) {
+          nextnumber = '0' + nextnumber;
+        }
+        newvalue = newvalue.replace(numberpattern[0], nextnumber);
+      }      
+
+      if (datepattern && datepattern.length > 0) {
+        for (let d = 0; d < datepattern.length; d++) {
+          const dpattern = datepattern[d];
+          const date = new Date();
+          const formatteddate = moment().format(
+            dpattern.replace('{', '').replace('}', ''),
+          );
+          newvalue = newvalue.replace(dpattern, formatteddate);
+        }
+      }
+      return newvalue;
+    } catch (e) {
+      const errors = `Format ${s.docNoFormatName} error ${e}`;
+      throw new InternalServerErrorException(errors);
+    }
+  };
+}

package/templates/nest/src/simpleapp/generate/commons/exceptions/SimpleAppExceptionFilter.ts.eta

@@ -0,0 +1,39 @@
+import {
+  ExceptionFilter,
+  Catch,
+  ArgumentsHost,
+  HttpException,
+  HttpStatus,
+} from '@nestjs/common';
+import { HttpAdapterHost } from '@nestjs/core';
+import { ClientSession } from 'mongoose';
+@Catch()
+export class SimpleAppExceptionFilter implements ExceptionFilter {
+  constructor(private readonly httpAdapterHost: HttpAdapterHost) {}
+
+  catch(exception, host: ArgumentsHost): void {
+    // In certain situations `httpAdapter` might not be available in the
+    // constructor method, thus we should resolve it here.
+    const { httpAdapter } = this.httpAdapterHost;
+    const ctx = host.switchToHttp();
+    const request = ctx.getRequest<Request>();
+    if(request['sessionuser']){
+      const session:ClientSession = request['sessionuser'].getDBSession()
+      if(session.inTransaction())session.abortTransaction()      
+    }
+    
+
+    const responseBody = {
+      message:exception.message,
+      timestamp: new Date().toISOString(),      
+      path: httpAdapter.getRequestUrl(ctx.getRequest()),
+      error: exception.response.options?? exception.options
+    };
+    // console.log("exception properties", Object.getOwnPropertyNames(exception),exception.options)
+   
+    // console.log("exception.responseexception.response",exception)
+
+    
+    httpAdapter.reply(ctx.getResponse(), responseBody, exception.response.status??exception.status);
+  }
+}

package/templates/nest/src/simpleapp/generate/commons/interceptors/response.interceptor.ts.eta

@@ -0,0 +1,38 @@
+
+import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { tap } from 'rxjs/operators';
+import { Model,Connection, ClientSession } from 'mongoose';
+import { InjectConnection } from '@nestjs/mongoose';
+import { UserContext } from '../user.context';
+@Injectable()
+export class ResponseInterceptor implements NestInterceptor {
+  
+    constructor(@InjectConnection() private readonly connection: Connection,){
+     
+      
+    }
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+    const req = context.switchToHttp().getRequest()
+    
+    const usersession:UserContext = req['sessionuser']
+    const session:ClientSession =   usersession.getDBSession()
+    // session.startTransaction()
+      // console.log("sessionuser exists!!")
+    
+    const now = Date.now();
+    return next
+      .handle()
+      .pipe(
+        tap(() => {
+          
+          if(process.env.DRYRUN=='true'){
+            console.warn("--------dryrun! roll back everything-----------")
+            if(session.inTransaction())session.abortTransaction()
+          }else{
+            if(session.inTransaction())session.commitTransaction()
+          }                            
+        }),
+      );
+  }
+}

package/templates/nest/src/simpleapp/generate/commons/middlewares/tenant.middleware.ts.eta

@@ -0,0 +1,88 @@
+import { Injectable, NestMiddleware, Logger,Scope,Inject } from '@nestjs/common';
+import { Request, Response, NextFunction } from 'express';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model,Connection } from 'mongoose';
+// import * as mongoose from 'mongoose';
+import {   User,  }  from '../../types/user.type';
+import {   Permission,  }  from '../../types/perm.type';
+import { InjectConnection } from '@nestjs/mongoose';
+
+const Base64URL = require('@darkwolf/base64url');
+// import * as jwt from 'nestjs-jwt'
+
+import { UserContext } from '../user.context';
+// import {KeycloakConfigService} from "../keycloak/keycloak.service"
+@Injectable()
+export class TenantMiddleware implements NestMiddleware {
+  protected defaultxorg=Base64URL.encodeText('0-0-0')
+  protected excludeXorgs = ['/profile', '/profile/tenant']
+  protected logger = new Logger()
+  protected transController
+  constructor(     
+    @InjectModel('User') private readonly usermodel:Model<User>,
+    @InjectModel('Permission') private readonly permmodel:Model<Permission>,
+    @InjectConnection() private readonly connection: Connection,
+    ){}
+  
+  requireXorg(baseurl:string):boolean{
+    // console.log('requireXorg')
+    for(let i =0; i < this.excludeXorgs.length;i++){
+      if(baseurl.includes(this.excludeXorgs[i])){
+        this.logger.verbose("requireXorg = false")
+        return false
+      }
+    }
+    // console.log("Require xorg")
+    return true
+  }
+  async use(req: Request, res: Response, next: NextFunction) {
+    if (req.baseUrl == '/oauth2-redirect.html') {
+      next();
+      return;
+    }
+    this.logger.debug(`running TenantMiddleware for ${req.baseUrl}`)
+    if (!req.headers['authorization']) {
+      this.logger.log("undefine bearer token")
+      return res.status(401).send('Undefine bearer token');
+    }
+    if (!req.headers['x-org'] && this.requireXorg(req.baseUrl)) {
+      this.logger.log("undefine x-org and require that at "+req.baseUrl,"TenantMiddleware")
+      return res.status(401).send('undefine header string x-org');
+    }
+    const session = await this.connection.startSession()
+    const u = new UserContext(this.usermodel,this.permmodel,session)
+    // console.log("line 43")
+    try {
+      let tokenstr: string = req.headers['authorization'];
+      tokenstr = tokenstr.replace('Bearer ', '');
+      
+      const xorg = req.headers['x-org']?? this.defaultxorg
+
+      await u.setCurrentUserInfo(tokenstr,xorg)      
+      if(u.getId()=='' && this.requireXorg(req.baseUrl)){        
+        this.logger.log("access deny of no user:", req.baseUrl)
+        return res.status(401).send('access deny');  
+      }else{
+        if(u.getId()==''){
+          this.logger.verbose(`grant new user (${u.getUid()}) access ${req.baseUrl}`)
+        }else{
+          this.logger.verbose(`grant user (${u.getId()}) access ${req.baseUrl}`)
+        }
+        req['sessionuser'] = u
+        this.logger.verbose(u.getRoles())
+
+        next();
+      }
+      
+    } catch(err) {
+      this.logger.warn(err,"invalid xorg or user info",)
+      this.logger.error(err)
+      if(err=='invalid x-org'){
+        return res.status(403).send(err);
+      }else{
+        return res.status(401).send(err);
+      }
+      
+    }
+  }
+}

package/templates/nest/{Workflow.eta → src/simpleapp/generate/commons/providers/workflow.provider.ts.etax}

@@ -1,30 +1,36 @@
 import { BPMNClient } from "bpmn-client";
-import { UserProvider } from './UserProvider';
-import { Injectable } from '@nestjs/common';
+import { UserContext } from './user.context';
+import { Injectable,Scope } from '@nestjs/common';
 
+export const WorkflowProviderFactory = {
+    provide:'WorkflowProvider', 
+    useFactory:()=>(new WorkflowProvider()),
+    scope:Scope.REQUEST 
+  }
+  
 export type UserTaskActorOptions={
     userId:string
     actGroups?:string[]
     actUsers?:string[]
 }
 @Injectable()
-export class Workflow{
-    private static instance: Workflow;
+export class WorkflowProvider{
+    // private static instance: Workflow;
     server:BPMNClient
 
     constructor(){
         this.server= new BPMNClient(process.env.BPMN_HOST, process.env.BPMN_PORT, process.env.BPMN_API_KEY);
     }
-    public static getInstance(): Workflow {
-        if (!Workflow.instance) {
-            Workflow.instance = new Workflow();
-        }
-        return Workflow.instance;
-      }
+    // public static getInstance(): Workflow {
+    //     if (!Workflow.instance) {
+    //         Workflow.instance = new Workflow();
+    //     }
+    //     return Workflow.instance;
+    //   }
 
     async executeWorkFlow(id: string, bpmnname: string, docstatus: string,data:any) {  
         const workflowactoroptions : UserTaskActorOptions ={
-            userId:UserProvider.getInstance().getUid(),
+            userId: 'id',
             actGroups:[],
             actUsers:[]
         }
@@ -33,8 +39,8 @@ export class Workflow{
         return Promise.resolve(res);
     }
     async getMyUserTask(){        
-        const uid = UserProvider.getInstance().getUid()
-        const groups = UserProvider.getInstance().getGroups()
+        const uid = 'id'
+        const groups = 'group'
         // 'assignments.candidateUsers': User.getInstance().getUid(),
         // 'assignments.candidateGroups': User.getInstance().getGroups
         
@@ -55,7 +61,7 @@ export class Workflow{
             anyof.push(tmp)
         }
         const filters = {
-            'data.tenantId': UserProvider.getInstance().getTenantId(),
+            'data.tenantId': 1,
             '$or':anyof
         }
         console.dir(filters)

package/templates/nest/src/simpleapp/generate/commons/roles/roles.decorator.ts.eta

@@ -0,0 +1,6 @@
+
+import { SetMetadata } from '@nestjs/common';
+import { Role } from './roles.enum';
+
+export const ROLES_KEY = 'roles';
+export const Roles = (...roles: Role[]) => SetMetadata(ROLES_KEY, roles);

package/templates/nest/src/simpleapp/generate/commons/roles/roles.enum.ts.eta

@@ -0,0 +1,28 @@
+export enum Role {
+    Unknown = 'unknown',    // unuse yet
+    Everyone = 'everyone',       //everyone
+    SuperAdmin = 'superadmin',   //reserved for developers, no control, 
+    SuperUser = 'suerpuser',     //reserved, plan use by support 
+    TenantOwner = 'tenantowner', //tenant owner/creator 
+    User = 'user',
+    <% for(let i=0;i<it.modules.length; i++){ %>
+        <% const m = it.modules[i] %>
+        <%=m.docname%>_create='<%=m.docname%>:create',
+
+        <%=m.docname%>_update='<%=m.docname%>:update',
+
+        <%=m.docname%>_delete='<%=m.docname%>:delete',
+
+        <%=m.docname%>_search='<%=m.docname%>:search',
+
+        <% if(m.api && m.api.length >0) {%>
+
+            <% for(let j=0;j<m.api.length; j++){ %>
+                <%let api = m.api[j]%>
+        
+        <%=m.docname%>_<%=api.action%>='<%=m.docname%>:<%=api.action%>',
+        
+            <%}%>
+        <%}%>
+    <%}%>
+  }

package/templates/nest/src/simpleapp/generate/commons/roles/roles.group.ts.eta

@@ -0,0 +1,10 @@
+import {Role} from './roles.enum'
+
+<% Object.getOwnPropertyNames(it.allroles).forEach((key)=>{ %>
+export const <%=key%>=[
+    Role.User,
+    <%for(let i=0; i <it.allroles[key].length; i++){%>
+    Role.<%=it.allroles[key][i]%>,
+    <%}%>
+]
+<%})%>

package/templates/nest/src/simpleapp/generate/commons/roles/roles.guard.ts.eta

@@ -0,0 +1,34 @@
+
+import { Injectable, Inject, CanActivate, ExecutionContext, Scope } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { Role } from './roles.enum'
+import { ROLES_KEY } from './roles.decorator'
+import { UserContext } from '../user.context';
+
+@Injectable()
+export class RolesGuard implements CanActivate {
+  constructor(private reflector: Reflector) {}
+
+  canActivate(context: ExecutionContext): boolean {
+    
+    const requiredRoles = this.reflector.getAllAndOverride<Role[]>(ROLES_KEY, [
+      context.getHandler(),
+      context.getClass(),
+    ]);
+
+    const sessionuser = context.switchToHttp().getRequest()['sessionuser']
+    
+    if (!requiredRoles) {
+      return true;
+    }
+        
+    const roles = sessionuser.getRoles()    
+    if(!roles){      
+      return false
+    }
+    const result = requiredRoles.some((role) => roles.includes(role));
+
+    return result
+    // return true
+  }
+}