@simitgroup/simpleapp-generator 1.0.29 → 1.0.32

package/templates/basic/simpleappclient.eta

@@ -6,13 +6,16 @@
  * Author: Ks Tan
  */
 import { SimpleAppClient } from "@simitgroup/simpleapp-vue-component/src/SimpleAppClient";
+import {AxiosResponse} from 'axios'
 
 // import { JSONSchema7 } from 'json-schema';
 import { Configuration,
       <%= it.doctype.toUpperCase()%>Api, 
       <%= it.typename%> ,
       <%Object.keys(it.schema).forEach(function(key){%>              
-        <% if(typeof it.schema[key]=='string'){%><%= it.schema[key]  %>,<%}%>
+        <% if(typeof it.schema[key]=='string' || (Array.isArray(it.schema[key]) && typeof it.schema[key][0]=='string')){%>
+          <%= it.schema[key]  %>,
+        <%}%>
       <%})%>
 
     } from '../openapi';
@@ -24,6 +27,9 @@ export class <%= it.typename%>Doc extends SimpleAppClient<<%= it.typename%>,<%=
   protected documentIdentityCode='<%~ it.autocompletecode %>'
   protected documentIdentityName='<%~ it.autocompletename %>'
   constructor(xorg:string,event:any,listen?:any) {    
+    if(!xorg){
+      xorg='MC0wLTA' //0-0-0
+    }
     const apiconfig = new Configuration({ basePath:  `${useRuntimeConfig().public.APP_URL}/api/${xorg}` });
     const apiobj = new <%= it.doctype.toUpperCase()%>Api(apiconfig)
     super(apiobj,'<%= it.doctype %>','<%=it.name %>')
@@ -57,6 +63,53 @@ export class <%= it.typename%>Doc extends SimpleAppClient<<%= it.typename%>,<%=
             this.setData(newdata)
     }
 
+<%Object.keys(it.jsonschema.properties).forEach(function(key) { %>
+    <% let obj=it.jsonschema.properties[key] %>
+    
+    <% if(obj.type=='array' && obj.items.type=='object' && obj.items['properties']){ %>
+        <%let tablefields = Object.keys(obj.items.properties) %>
+       add<%=key%> = () => {
+        const tmp:<%=it.typename%><%=capitalizeFirstLetter(key)%> = {
+          <% for(let a=0;a<tablefields.length;a++){%>
+              <% const skey =  tablefields[a] %>
+              <% const sobj =  obj.items.properties[skey] %>
+              <%if(sobj.type=='object'  && typeof sobj['x-foreignkey']!='undefined'){%>
+                <%=skey%>: <%~ sobj.default?JSON.stringify(sobj.default): '{_id:"",label:""}'%>,
+              <%}else if(sobj.type=='boolean'){%>
+                  <%=skey%>: <%=sobj.default??false%>,
+              <%}else if(sobj.type=='number'){%>
+                <%=skey%>: <%=sobj.default??0.00%>,
+              <%}else if(sobj.type=='integer'){%>
+                <%=skey%>: <%=sobj.default??0%>,
+              <%}else if(sobj.type=='string'){%>
+                <%=skey%>: '<%=sobj.default??""%>',
+              <%}%>
+
+          <%}%>
+          }
+        this.getReactiveData().value.<%= key %>.push(tmp)
+       }
+        
+          
+    <%}%>
+  <%})%>
+  
+
+  <%for(let i=0;i<it.apiSettings.length;i++){%>
+  <% let api = it.apiSettings[i] %>
+  async exec<%=capitalizeFirstLetter(api.action)%>(){
+    const recordid: string = this.data.value._id ?? '';
+    return await this.docapi.exec<%=capitalizeFirstLetter(api.action)%>(recordid)
+    .then((res: AxiosResponse) => {
+      if(this.event){this.event('info:<%=capitalizeFirstLetter(api.action)%>',res.data)}
+      return res;
+    }).catch((res:any)=>{
+      if(this.event){this.event('error:<%=capitalizeFirstLetter(api.action)%>',res)}
+      return Promise.reject(res)
+    });
+  } 
+  <%}%>
+
   /*****************************customized frontend + backend code*****************************************/
     
   <%~ it.bothEndCode %>

package/templates/nest/SimpleAppService.eta

@@ -1,41 +1,67 @@
-import { Injectable } from '@nestjs/common';
+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 { User } from './User';
+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 = 'category';
-  protected documentType = 'CAT';
+  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;
@@ -53,15 +79,18 @@ export class SimpleAppService<T extends { _id?: string }> {
   getIsolationFilter = () => {
     let isolationFilter = {};
     switch (this.isolationtype) {
+      case 'none':
+        isolationFilter = {};
+        break;
       case 'branch':
-        isolationFilter = User.getInstance().getBranchFilter();
+        isolationFilter = UserProvider.getInstance().getBranchFilter();
         break;
       case 'tenant':
-        isolationFilter = User.getInstance().getTenantFilter();
+        isolationFilter = UserProvider.getInstance().getTenantFilter();
         break;
       case 'org':
       default:
-        isolationFilter = User.getInstance().getOrgFilter();
+        isolationFilter = UserProvider.getInstance().getOrgFilter();
         break;
     }
     return isolationFilter;
@@ -80,20 +109,32 @@ export class SimpleAppService<T extends { _id?: string }> {
       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 };
-      filter2[this.documentIdentityName] = { $regex: keyword };
+      filter1[this.documentIdentityCode] = { $regex: keyword, $options: 'i' };
+      filter2[this.documentIdentityName] = { $regex: keyword, $options: 'i' };
       const filterobj = { $or: [filter1, filter2] };
 
       Object.assign(filterobj, this.getIsolationFilter());
-      const projections = {
+      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,
       });
@@ -108,10 +149,12 @@ export class SimpleAppService<T extends { _id?: string }> {
   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) {
@@ -120,7 +163,9 @@ export class SimpleAppService<T extends { _id?: string }> {
     // 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];
@@ -133,11 +178,13 @@ export class SimpleAppService<T extends { _id?: string }> {
     let result;
 
     try {
-      Object.assign(this.data, User.getInstance().getCreateFilter());
+      await this.hook(HookType.beforeCreate, this.data);
+      Object.assign(this.data, UserProvider.getInstance().getCreateFilter());
       delete this.data._id;
-      this.validateData(this.data);      
+      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);
     }
@@ -145,8 +192,8 @@ export class SimpleAppService<T extends { _id?: string }> {
   }
   async update() {
     const id: string = this.getRecordId();
-    Object.assign(this.data, User.getInstance().getUpdateFilter());
-    this.findIdThenUpdate(id, this.data);
+    Object.assign(this.data, UserProvider.getInstance().getUpdateFilter());
+    await this.findIdThenUpdate(id, this.data);
   }
   async delete() {
     const id: string = this.getRecordId();
@@ -157,47 +204,65 @@ export class SimpleAppService<T extends { _id?: string }> {
       return dependency;
     }
   }
-  hook(type: string, data: T) {
+  hook = async (type: string, data?: any) => {
+    // console.log('Default hook', data);
     return true;
-  }
-  validateData(data: T) {
+  };
+  async validateData(data: T) {
     const ajv = new Ajv({ allErrors: true });
     addFormats(ajv);
+    addErrors(ajv);
+
     ajv.addFormat('x-document-no', /.*$/);
-    ajv.addFormat('x-document-name', /.*$/);
+    ajv.addFormat('x-document-label', /.*$/);
+    ajv.addFormat('tel', /^$|^\d{7,15}$/gm);
     ajv.addFormat('x-text', /.*$/);
     ajv.addFormat('x-html', /.*$/);
-    ajv.addKeyword({
-      keyword: 'x-foreignkey',
-      type: 'string',
-    });
 
-    if (!this.hook('pre-validation', data)) {
+    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);
       }
-      console.log("pre-validation:",erromsg)
+      this.logger.log('run hook during validation');
       throw new InternalServerErrorException(erromsg.join('\n'));
     }
-    const validate = ajv.compile(this.jsonschema);
+
+    let validate;
+    try {
+      validate = ajv.compile(this.jsonschema);
+    } catch (err) {
+      this.logger.error('compile error', err);
+    }
+
     const valid = validate(data);
-    //console.log(validate.errors);
     if (!valid) {
-      // console.log(validate.errors);
+      this.logger.error(validate.errors);
       const erromsg: string[] = [];
-      for (let i = 0; i < validate.errors.length; i++) {
-        erromsg.push(validate.errors[i].message);
+      for (let i = 0; i < ajv.errors.length; i++) {
+        erromsg.push(ajv.errors[i].message);
       }
-      console.log("ajv erromsg: ",erromsg)
+      this.logger.error('ajv erromsg: ', erromsg);
       throw new InternalServerErrorException(erromsg.join('\n'));
     }
-    this.hook('post-validation', data);
+    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) {
@@ -205,7 +270,7 @@ export class SimpleAppService<T extends { _id?: string }> {
         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 {
@@ -222,15 +287,15 @@ export class SimpleAppService<T extends { _id?: string }> {
 
   findIdThenUpdate = async (id: string, data: T) => {
     const existingdata = await this.findById(id);
-
+    await this.hook(HookType.beforeUpdate, data);
     try {
-      Object.assign(data, User.getInstance().getUpdateFilter());
+      Object.assign(data, UserProvider.getInstance().getUpdateFilter());
       Object.assign(existingdata, data);
-      this.validateData(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);
@@ -252,7 +317,7 @@ export class SimpleAppService<T extends { _id?: string }> {
         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];
+          const fkey = fobjs[j] + '._id';
           const filter = {};
           filter[fkey] = id;
           //console.log('getRelatedRecords get filter', collectionname, filter);
@@ -266,4 +331,36 @@ export class SimpleAppService<T extends { _id?: string }> {
     }
     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

@@ -2,38 +2,33 @@ import { Injectable, NestMiddleware, Scope } from '@nestjs/common';
 import { Request, Response, NextFunction } from 'express';
 // import * as jwt from 'nestjs-jwt'
 
-
-import { User } from './User';
+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 ;
+      return;
     }
-    if(!req.headers['authorization']){
+    if (!req.headers['authorization']) {
       return res.status(401).send('Undefine bearer token');
     }
-    if (!req.headers['x-org']){
+    if (!req.headers['x-org']) {
       return res.status(401).send('undefine header string x-org');
     }
-    const u = User.getInstance();      
+    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);      
+      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

@@ -0,0 +1,127 @@
+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/Workflow.eta

@@ -0,0 +1,75 @@
+import { BPMNClient } from "bpmn-client";
+import { UserProvider } from './UserProvider';
+import { Injectable } from '@nestjs/common';
+
+export type UserTaskActorOptions={
+    userId:string
+    actGroups?:string[]
+    actUsers?:string[]
+}
+@Injectable()
+export class Workflow{
+    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;
+      }
+
+    async executeWorkFlow(id: string, bpmnname: string, docstatus: string,data:any) {  
+        const workflowactoroptions : UserTaskActorOptions ={
+            userId:UserProvider.getInstance().getUid(),
+            actGroups:[],
+            actUsers:[]
+        }
+        var instance = await this.server.engine.start(bpmnname, data,null,workflowactoroptions);    
+        const res = {instanceId:instance.id,data:instance.data,name:instance.name,status:instance.status}        
+        return Promise.resolve(res);
+    }
+    async getMyUserTask(){        
+        const uid = UserProvider.getInstance().getUid()
+        const groups = UserProvider.getInstance().getGroups()
+        // 'assignments.candidateUsers': User.getInstance().getUid(),
+        // 'assignments.candidateGroups': User.getInstance().getGroups
+        
+        let anyof:any = [
+            {'items.assignments.assignee':uid},            
+        ]
+        let usersfilter={}
+        usersfilter[uid]={$in: 'items.assignments.candidateUsers'}
+        anyof.push(usersfilter)
+//{'data.tenantId': 1,'$or':[{
+//     'items.assignments.assignee': 'b2a49a8f-a943-4814-8087-60b1ef2f304f'
+// }]}
+        //any of the group
+        for(let i=0;i<groups.length;i++){
+            const gname = groups[i]
+            const tmp = {}
+            tmp[gname]={ $in: 'items.assignments.candidateGroups'}
+            anyof.push(tmp)
+        }
+        const filters = {
+            'data.tenantId': UserProvider.getInstance().getTenantId(),
+            '$or':anyof
+        }
+        console.dir(filters)
+
+        
+        // 'assignments.assignee': User.getInstance().getUid(),     
+        const client = new BPMNClient(process.env.BPMN_HOST, process.env.BPMN_PORT, process.env.BPMN_API_KEY);    
+        const items = await client.datastore.findItems(filters)
+        let data=[]
+        for(let i=0;i<items.length;i++){
+            if(items[i].status=='wait'){
+                data.push(items[i])
+            }
+        }
+        return Promise.resolve(data);
+      }
+}

package/templates/nest/app.controller.eta

@@ -0,0 +1,12 @@
+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();
+  }
+}