@simitgroup/simpleapp-generator 1.0.32 → 1.0.35

package/templates/nest/SimpleAppService.eta

@@ -1,366 +0,0 @@
-import { Injectable, Logger } from '@nestjs/common';
-import { InjectModel } from '@nestjs/mongoose';
-import { Model } from 'mongoose';
-import Ajv from 'ajv';
-import addFormats from 'ajv-formats';
-import addErrors from 'ajv-errors';
-import foreignkeys from '../dicts/foreignkeys.json';
-import { Workflow } from './Workflow';
-import {
-  NotFoundException,
-  InternalServerErrorException,
-} from '@nestjs/common/exceptions';
-import { UserProvider } from './UserProvider';
-
-export enum IsolationType {
-  'none' = 'none',
-  'org' = 'org',
-  'tenant' = 'tenant',
-  'branch' = 'branch',
-}
-export enum HookType {
-  'init' = 'init',
-  'beforeSearch' = 'beforeSearch',
-  'afterSearch' = 'afterSearch',
-  'beforeValidation' = 'beforeValidation',
-  'afterValidation' = 'afterValidation',
-  'beforeCreate' = 'beforeCreate',
-  'afterCreate' = 'afterCreate',
-  'beforeUpdate' = 'beforeUpdate',
-  'afterUpdate' = 'afterUpdate',
-  'beforeDelete' = 'beforeDelete',
-  'afterDelete' = 'afterDelete',
-  'beforeFetchRecord' = 'beforeFetchRecord',
-  'afterFetchRecord' = 'afterFetchRecord',
-}
-export type MoreProjectionType = {
-  [key: string]: string;
-};
-@Injectable()
-export class SimpleAppService<T extends { _id?: string }> {
-  protected logger = new Logger();
-  protected jsonschema = { type: 'object', properties: {}, required: [] };
-  protected documentIdentityCode = 'code';
-  protected documentIdentityName = 'label';
-  protected documentName = '-unknowndocname-';
-  protected documentType = '-unknowndoctype-';
-  protected LIMITPERPAGE = 20;
-  protected moreAutoCompleteField: MoreProjectionType = {};
-  protected isolationtype: IsolationType = IsolationType.org;
-  protected isolationFilter: any = {};
-  protected data: T = { _id: '' } as T;
-  private doc: Model<T>; //set private to prevent developer break data isolation control
-  protected errorlist = [];
-  constructor(
-    doctype: string,
-    docname: string,
-    newdoc: Model<T>,
-    isolationtype: IsolationType = IsolationType.org,
-  ) {
-    this.documentType = doctype;
-    this.documentName = docname;
-    this.doc = newdoc;
-    this.isolationtype = isolationtype;
-    this.hook(HookType.init, this.documentName);
-    // this.tenantdoc = tenantdoc
-  }
-  getRecordId = (): string => this.data._id;
-  setSchema = (newschema) => (this.jsonschema = newschema);
-  getSchema = () => this.doc.schema.obj;
-  getData = () => {
-    //console.log('thisdata', this.data);
-    return this.data;
-  };
-  setData = (newdata: T) => {
-    delete newdata._id;
-    this.data = { ...newdata };
-    return this;
-  };
-  getIsolationFilter = () => {
-    let isolationFilter = {};
-    switch (this.isolationtype) {
-      case 'none':
-        isolationFilter = {};
-        break;
-      case 'branch':
-        isolationFilter = UserProvider.getInstance().getBranchFilter();
-        break;
-      case 'tenant':
-        isolationFilter = UserProvider.getInstance().getTenantFilter();
-        break;
-      case 'org':
-      default:
-        isolationFilter = UserProvider.getInstance().getOrgFilter();
-        break;
-    }
-    return isolationFilter;
-  };
-  async list() {
-    try {
-      //console.log("this.isolationFilter",this.getIsolationFilter())
-      const products = await this.doc.find(this.getIsolationFilter());
-      // console.log(products)
-      const productlist = products.map((p: T) => {
-        return p;
-      });
-      //   console.log(products);
-      return productlist;
-    } catch (err) {
-      throw new InternalServerErrorException(err.message);
-    }
-  }
-  addAutoCompleteField = (morefield: MoreProjectionType) => {
-    const props = Object.getOwnPropertyNames(morefield);
-    console.log('addAutoCompleteField', props);
-    for (let i = 0; i < props.length; i++) {
-      const key = props[i];
-      this.moreAutoCompleteField[key] = '$' + morefield[key];
-    }
-    console.log(this.moreAutoCompleteField);
-  };
-  async getAutoComplete(keyword: string) {
-    try {
-      const filter1 = {};
-      const filter2 = {};
-      filter1[this.documentIdentityCode] = { $regex: keyword, $options: 'i' };
-      filter2[this.documentIdentityName] = { $regex: keyword, $options: 'i' };
-      const filterobj = { $or: [filter1, filter2] };
-
-      Object.assign(filterobj, this.getIsolationFilter());
-      let projections = {
-        id: `\$_id`,
-        label: `\$${this.documentIdentityCode}`,
-        name: `\$${this.documentIdentityName}`,
-      };
-      if (this.moreAutoCompleteField) {
-        Object.assign(projections, this.moreAutoCompleteField);
-      }
-      const products = await this.doc.find(filterobj, projections, {
-        limit: this.LIMITPERPAGE,
-      });
-      const productlist = products.map((p: T) => {
-        return p;
-      });
-      return productlist;
-    } catch (err) {
-      throw new InternalServerErrorException(err.message);
-    }
-  }
-  async search(filters: Object) {
-    try {
-      Object.assign(filters, this.getIsolationFilter());
-      await this.hook(HookType.beforeSearch, filters);
-      const products = await this.doc.find(filters);
-      const productlist = products.map((p: T) => {
-        return p;
-      });
-      await this.hook(HookType.afterSearch, productlist);
-      //   console.log(products);
-      return productlist;
-    } catch (err) {
-      throw new InternalServerErrorException(err.message);
-    }
-    // return this;
-  }
-  async findById(id: string) {
-    await this.hook(HookType.beforeFetchRecord, id);
-    const data = await this.search({ _id: id });
-    await this.hook(HookType.afterFetchRecord, data);
-    if (data.length == 1) {
-      // console.log('data0', data[0]);
-      return data[0];
-    } else {
-      return null;
-    }
-  }
-
-  async create() {
-    let result;
-
-    try {
-      await this.hook(HookType.beforeCreate, this.data);
-      Object.assign(this.data, UserProvider.getInstance().getCreateFilter());
-      delete this.data._id;
-      await this.validateData(this.data);
-      const newdoc = new this.doc(this.data);
-      result = await newdoc.save();
-      await this.hook(HookType.afterCreate, result);
-    } catch (err) {
-      throw new InternalServerErrorException(err.message);
-    }
-    return result as T;
-  }
-  async update() {
-    const id: string = this.getRecordId();
-    Object.assign(this.data, UserProvider.getInstance().getUpdateFilter());
-    await this.findIdThenUpdate(id, this.data);
-  }
-  async delete() {
-    const id: string = this.getRecordId();
-    const dependency = await this.getRelatedRecords(id);
-    if (!dependency) {
-      return await this.findIdThenDelete(id);
-    } else {
-      return dependency;
-    }
-  }
-  hook = async (type: string, data?: any) => {
-    // console.log('Default hook', data);
-    return true;
-  };
-  async validateData(data: T) {
-    const ajv = new Ajv({ allErrors: true });
-    addFormats(ajv);
-    addErrors(ajv);
-
-    ajv.addFormat('x-document-no', /.*$/);
-    ajv.addFormat('x-document-label', /.*$/);
-    ajv.addFormat('tel', /^$|^\d{7,15}$/gm);
-    ajv.addFormat('x-text', /.*$/);
-    ajv.addFormat('x-html', /.*$/);
-
-    ajv.addKeyword({ keyword: 'x-document-status', type: 'array' });
-    ajv.addKeyword({ keyword: 'x-document-api', type: 'array' });
-    ajv.addKeyword({ keyword: 'x-ignore-autocomplete', type: 'boolean' });
-    ajv.addKeyword({ keyword: 'x-isolation-type', type: 'string' });
-    ajv.addKeyword({ keyword: 'x-document-type', type: 'string' });
-    ajv.addKeyword({ keyword: 'x-document-name', type: 'string' });
-    ajv.addKeyword({ keyword: 'x-collection-name', type: 'string' });
-    ajv.addKeyword({ keyword: 'x-autocomplete-field', type: 'boolean' });
-    ajv.addKeyword({ keyword: 'x-foreignkey', type: 'string' });
-
-    const issuccess = await this.hook(HookType.beforeValidation, data);
-    if (!issuccess) {
-      const erromsg: string[] = [];
-      for (let i = 0; i < this.errorlist.length; i++) {
-        erromsg.push(this.errorlist[i].message);
-      }
-      this.logger.log('run hook during validation');
-      throw new InternalServerErrorException(erromsg.join('\n'));
-    }
-
-    let validate;
-    try {
-      validate = ajv.compile(this.jsonschema);
-    } catch (err) {
-      this.logger.error('compile error', err);
-    }
-
-    const valid = validate(data);
-    if (!valid) {
-      this.logger.error(validate.errors);
-      const erromsg: string[] = [];
-      for (let i = 0; i < ajv.errors.length; i++) {
-        erromsg.push(ajv.errors[i].message);
-      }
-      this.logger.error('ajv erromsg: ', erromsg);
-      throw new InternalServerErrorException(erromsg.join('\n'));
-    }
-    await this.hook(HookType.afterValidation, data);
-  }
-
-  async findIdThenDelete(id: string): Promise<any> {
-    // const data = await this.findById(id);
-    try {
-      await this.hook(HookType.beforeDelete, id);
-      //console.log('deletedeletedeletedelete');
-      const dependency = await this.getRelatedRecords(id);
-      if (!dependency) {
-        let filter = this.getIsolationFilter();
-        filter['_id'] = id;
-        const deleteresult = await this.doc.deleteOne(filter);
-        // this.doc.findByIdAndDelete(id)
-        await this.hook(HookType.afterDelete, deleteresult);
-        //this.doc.findByIdAndDelete(id);
-        return deleteresult;
-      } else {
-        return Promise.reject(dependency);
-      }
-    } catch (err) {
-      throw new InternalServerErrorException(err.message);
-    }
-  }
-
-  updateOne = async (data: T) => {
-    this.doc.updateOne(data);
-  };
-
-  findIdThenUpdate = async (id: string, data: T) => {
-    const existingdata = await this.findById(id);
-    await this.hook(HookType.beforeUpdate, data);
-    try {
-      Object.assign(data, UserProvider.getInstance().getUpdateFilter());
-      Object.assign(existingdata, data);
-      await this.validateData(data);
-      let filter = this.getIsolationFilter();
-      filter['_id'] = id;
-      const result = await this.doc.findOneAndUpdate(filter, data);
-      await this.hook(HookType.afterUpdate, data);
-      return result;
-    } catch (err) {
-      throw new InternalServerErrorException(err.message);
-    }
-  };
-
-  //find what foreign key constraint
-  async getRelatedRecords(id: string) {
-    const foreignkeysettings = foreignkeys[this.documentName];
-    //console.log('foreignkeysettings', foreignkeysettings);
-    const propkeys = Object.getOwnPropertyNames(foreignkeysettings);
-
-    if (propkeys.length > 0) {
-      //console.log('Have properties');
-      for (let i = 0; i < propkeys.length; i++) {
-        const collectionname = propkeys[i];
-        //console.log('run ', i, collectionname);
-        const fobjs = foreignkeysettings[propkeys[i]];
-        const collection = this.doc.db.collection(collectionname);
-        //single schema may have multiple foreign key link here, loop all
-        for (let j = 0; j < fobjs.length; j++) {
-          const fkey = fobjs[j] + '._id';
-          const filter = {};
-          filter[fkey] = id;
-          //console.log('getRelatedRecords get filter', collectionname, filter);
-          const result = await collection.findOne(filter);
-          //console.log('getRelatedRecords', result);
-          if (result) {
-            return Promise.reject(result);
-          }
-        }
-      }
-    }
-    return Promise.resolve(null);
-  }
-
-  /**
-   * change property documentStatus for specific document, no workflow execution
-   * @param id
-   * @param docstatus
-   * @returns Promise
-   */
-  async setDocumentStatus(id: string, docstatus: string) {
-    const partialdata: T = {} as T;
-    partialdata['documentStatus'] = docstatus;
-    return this.findIdThenUpdate(id, partialdata);
-  }
-
-  /**
-   * change property documentStatus for specific document, no workflow execution
-   * @param id
-   * @param docstatus
-   * @returns Promise
-   */
-  async executeWorkFlow(id: string, bpmnname: string, docstatus: string) {
-    const data = await this.findById(id);
-    return Workflow.getInstance().executeWorkFlow(
-      id,
-      bpmnname,
-      docstatus,
-      data,
-    );
-  }
-
-  async getMyUserTask() {
-    return Workflow.getInstance().getMyUserTask();
-  }
-}

package/templates/nest/TenantMiddleware.eta

@@ -1,34 +0,0 @@
-import { Injectable, NestMiddleware, Scope } from '@nestjs/common';
-import { Request, Response, NextFunction } from 'express';
-// import * as jwt from 'nestjs-jwt'
-
-import { UserProvider } from './UserProvider';
-// import {KeycloakConfigService} from "../keycloak/keycloak.service"
-@Injectable({
-  scope: Scope.REQUEST,
-})
-export class TenantMiddleware implements NestMiddleware {
-  use(req: Request, res: Response, next: NextFunction) {
-    if (req.baseUrl == '/oauth2-redirect.html') {
-      next();
-      return;
-    }
-    if (!req.headers['authorization']) {
-      return res.status(401).send('Undefine bearer token');
-    }
-    if (!req.headers['x-org']) {
-      return res.status(401).send('undefine header string x-org');
-    }
-    const u = UserProvider.getInstance();
-
-    try {
-      u.setXorg(req.headers['x-org'].toString());
-      let tokenstr: string = req.headers['authorization'];
-      tokenstr = tokenstr.replace('Bearer ', '');
-      u.setUserToken(tokenstr);
-      next();
-    } catch {
-      return res.status(401).send('Invalid x-org or user info');
-    }
-  }
-}

package/templates/nest/UserProvider.eta

@@ -1,127 +0,0 @@
-import { Injectable, Scope } from '@nestjs/common';
-import Base64URL from '@darkwolf/base64url';
-import * as jwt from 'jsonwebtoken';
-
-@Injectable({
-  scope: Scope.REQUEST,
-})
-export class UserProvider {
-  private static instance: UserProvider;
-  protected uid: 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 accessrights: any = {};
-  protected token: string = '';
-  protected refreshtoken: string = '';
-  protected groups: string[] = [];
-  constructor() {}
-  public static getInstance(): UserProvider {
-    if (!UserProvider.instance) {
-      UserProvider.instance = new UserProvider();
-    }
-    return UserProvider.instance;
-  }
-  getUid = () => this.uid;
-  getUname = () => this.uname;
-  getFullname = () => this.fullname;
-  getTenantId = () => this.tenantId;
-  getOrgId = () => this.orgId;
-  getBranchId = () => this.branchId;
-  getEmail = () => this.email;
-  getGroups = () => this.groups;
-  setUserToken = (tokenstr: string) => {
-    const tokeninfo = jwt.decode(tokenstr);
-    // realm_access: {
-    //   roles: [
-    //     'default-roles-simitdeveloper',
-    //     'offline_access',
-    //     'uma_authorization'
-    //   ]
-    // },
-    // resource_access: { account: { roles: [Array] } },
-    // scope: 'openid email profile',
-    // sid: '53192f53-d4af-413b-b8d7-1e186419fe53',
-    // email_verified: false,
-    // name: 'kstan kstan',
-    // preferred_username: 'kstan',
-    // given_name: 'kstan',
-    // family_name: 'kstan',
-    // email: 'kstan@simitgroup.com'
-
-    const u = UserProvider.getInstance();
-    u.token = tokenstr;
-    u.uid = tokeninfo.sub;
-    u.email = tokeninfo.email;
-    u.uname = tokeninfo.preferred_username;
-    u.fullname = tokeninfo.name;
-    u.groups = ['superuser', 'accountant', 'directors'];
-    u.accessrights = tokeninfo.resource_access;
-  };
-  getInfo = () => {
-    return UserProvider.getInstance();
-  };
-  getBranchFilter = () => {
-    return {
-      tenantId: UserProvider.getInstance().tenantId,
-      orgId: UserProvider.getInstance().orgId,
-      branchId: UserProvider.getInstance().branchId,
-    };
-  };
-  getTenantFilter = () => {
-    return { tenantId: UserProvider.getInstance().tenantId };
-  };
-  getOrgFilter = () => {
-    return {
-      tenantId: UserProvider.getInstance().tenantId,
-      orgId: UserProvider.getInstance().orgId,
-    };
-  };
-  getWorkflowTaskFilter() {
-    return {
-      'data.tenantId': UserProvider.getInstance().tenantId,
-      'assignments.assignee': UserProvider.getInstance().getUid(),
-      // 'assignments.assignee': User.getInstance().getUid(),
-    };
-  }
-  getCreateFilter = () => {
-    const u = UserProvider.getInstance();
-    return {
-      tenantId: u.tenantId,
-      orgId: u.orgId,
-      branchId: u.branchId,
-      createdby: u.uid,
-      updatedby: u.uid,
-      created: new Date().getTime().toString(),
-      updated: new Date().getTime().toString(),
-    };
-  };
-  getUpdateFilter = () => {
-    const u = UserProvider.getInstance();
-    return {
-      updatedby: u.uid,
-      updated: new Date().getTime().toString(),
-    };
-  };
-  setXorg = (xorg) => {
-    try {
-      const decodedText: string = Base64URL.decodeText(xorg);
-      const arrXorg = decodedText.split('-');
-
-      if (arrXorg.length == 3) {
-        const u = UserProvider.getInstance();
-        u.tenantId = Number(arrXorg[0]);
-        u.orgId = Number(arrXorg[1]);
-        u.branchId = Number(arrXorg[2]);
-      } else {
-        throw 'invalid x-org';
-      }
-    } catch (err) {
-      throw err;
-    }
-  };
-}

package/templates/nest/app.controller.eta

@@ -1,12 +0,0 @@
-import { Controller, Get } from '@nestjs/common';
-import { AppService } from './app.service';
-
-@Controller()
-export class AppController {
-  constructor(private readonly appService: AppService) {}
-
-  @Get('myworkflowtask')
-  async getHello() {
-    return await this.appService.getMyTask();
-  }
-}

package/templates/nest/app.module.eta

@@ -1,64 +0,0 @@
-import { Module,MiddlewareConsumer,NestModule } from '@nestjs/common';
-import { MongooseModule } from '@nestjs/mongoose';
-import { APP_GUARD } from '@nestjs/core';
-import {
-  AuthGuard, KeycloakConnectModule,
-  ResourceGuard,TokenValidation,
-  RoleGuard,PolicyEnforcementMode
-} from 'nest-keycloak-connect';
-import { ConfigModule } from '@nestjs/config';
-import { ServeStaticModule } from '@nestjs/serve-static';
-import { join } from 'path';
-import {TenantMiddleware} from './class/TenantMiddleware'
-import {AppController} from './app.controller'
-import {AppService} from './app.service'
-<% for(let i=0;i<it.length; i++){ %>
-import {<%= it[i].docname %>Module} from './docs/<%= it[i].doctype %>/<%= it[i].doctype %>.module'
-<%}%>
-
-@Module({
-    //define environment variables: MONGODB_URL='mongodb://<user>:<pass>@<host>:<port>/<db>?authMechanism=DEFAULT'
-  imports: [
-    ConfigModule.forRoot(),
-    MongooseModule.forRoot(process.env.MONGODB_URL),
-    ServeStaticModule.forRoot({
-      rootPath: join(__dirname, '..', 'public_html'),
-      exclude: ['/api/(.*)'],      
-    }),
-    KeycloakConnectModule.register({
-      authServerUrl: process.env.OAUTH2_BASEURL,
-      realm: process.env.OAUTH2_REALM,
-      clientId: process.env.OAUTH2_CLIENTID,
-      secret: process.env.OAUTH2_CLIENTSECRET,
-      policyEnforcement: PolicyEnforcementMode.PERMISSIVE,
-      tokenValidation: TokenValidation.ONLINE,
-    }),
-    <% for(let i=0;i<it.length; i++){ %><%= it[i].docname %>Module,<%}%>],
-  controllers: [AppController],
-  providers: [
-    AppService,
-    {
-    provide: APP_GUARD,     
-    useClass: AuthGuard,
-  },
-  {
-    provide: APP_GUARD,
-    useClass: ResourceGuard,
-  },
-  {
-    provide: APP_GUARD,
-    useClass: RoleGuard,
-  },],
-})
-export class AppModule implements NestModule{
-  configure(consumer: MiddlewareConsumer) {
-    consumer
-      .apply(TenantMiddleware)
-      // .exclude('/api-yaml')
-      // .exclude('/api-json')
-      // .exclude('/api')
-      .forRoutes('*')
-      
-      
-  }
-}

package/templates/nest/app.service.eta

@@ -1,8 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { Workflow } from './class/Workflow';
-@Injectable()
-export class AppService {
-  async getMyTask() {
-    return await Workflow.getInstance().getMyUserTask()
-  }
-}

package/templates/nest/inputvalidation-exception.eta

@@ -1,6 +0,0 @@
-import {HttpException,HttpStatus} from '@nestjs/common'
-export class InputValidationExceptions extends HttpException {
-    constructor() {
-      super('input error', HttpStatus.INTERNAL_SERVER_ERROR);
-    }
-  }

package/templates/nest/nest.env.eta

@@ -1,28 +0,0 @@
-MONGODB_URL=<%=it.mongoConnectStr%>
-
-HTTP_PORT=<%=it.backendPort%>
-
-PROJECT_NAME=SimpleApp Demo1
-PROJECT_DESCRIPTION=Try CRUD
-PROJECT_Version=1.0.0
-
-BPMN_HOST=<%=it.bpmnsetting.BPMN_HOST%>
-
-BPMN_PORT=<%=it.bpmnsetting.BPMN_PORT%>
-
-BPMN_API_KEY=<%=it.bpmnsetting.BPMN_API_KEY%>
-
-
-OAUTH2_BASEURL=<%=it.keycloaksetting.OAUTH2_BASEURL%>
-
-OAUTH2_REALM=<%=it.keycloaksetting.OAUTH2_REALM%>
-
-OAUTH2_CONFIGURL=<%=it.keycloaksetting.OAUTH2_CONFIGURL%>
-
-OAUTH2_CLIENTID=<%=it.keycloaksetting.OAUTH2_CLIENTID%>
-
-OAUTH2_CLIENTSECRET=<%=it.keycloaksetting.OAUTH2_CLIENTSECRET%>
-
-AUTH_SECRET_KEY=<%=it.keycloaksetting.AUTH_SECRET_KEY%>
-
-AUTH_ORIGIN=http://localhost:8080

package/templates/nest/nest.main.eta

@@ -1,31 +0,0 @@
-import { NestFactory } from '@nestjs/core';
-import { AppModule } from './app.module';
-import { SwaggerModule, DocumentBuilder } from '@nestjs/swagger';
-
-async function bootstrap() {
-  const app = await NestFactory.create(AppModule);
-  app.enableCors();
-  const config = new DocumentBuilder()
-    .setTitle(process.env.PROJECT_NAME)
-    .setDescription(process.env.PROJECT_DESCRIPTION)
-    .setVersion(process.env.PROJECT_VERSION)
-    .addApiKey({
-        in: 'header',name: 'x-org',type: 'apiKey',description: 'base 64 url encode. example: MS0xLTE',
-      },'x-org',)
-    .addOAuth2({
-        type:'oauth2',flows:{          
-          implicit:{          
-            authorizationUrl: `${process.env.OAUTH2_CONFIGURL}/protocol/openid-connect/auth`,
-            scopes:{},                      
-          }}},'oauth2')
-    .addSecurityRequirements('x-org')
-    .addSecurityRequirements('oauth2')
-    .build();
-  const document = SwaggerModule.createDocument(app, config);
-  SwaggerModule.setup('api', app, document, {
-    swaggerOptions: { showExtensions: true, persistAuthorization: true },
-  });
-
-  await app.listen(process.env.HTTP_PORT ?? 8000); //listen which port
-}
-bootstrap();