@simitgroup/simpleapp-generator 1.0.31 → 1.0.32

package/templates/nest/SimpleAppService.eta

@@ -1,67 +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',
-
-
+  '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
-}
+  [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 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,
+    doctype: string,
+    docname: string,
     newdoc: Model<T>,
     isolationtype: IsolationType = IsolationType.org,
   ) {
-    this.documentType=doctype
-    this.documentName=docname
+    this.documentType = doctype;
+    this.documentName = docname;
     this.doc = newdoc;
     this.isolationtype = isolationtype;
-    this.hook(HookType.init,this.documentName)
+    this.hook(HookType.init, this.documentName);
     // this.tenantdoc = tenantdoc
   }
   getRecordId = (): string => this.data._id;
@@ -79,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;
@@ -106,21 +109,21 @@ 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]
+  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)
-  }
+    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' };
+      filter1[this.documentIdentityCode] = { $regex: keyword, $options: 'i' };
+      filter2[this.documentIdentityName] = { $regex: keyword, $options: 'i' };
       const filterobj = { $or: [filter1, filter2] };
 
       Object.assign(filterobj, this.getIsolationFilter());
@@ -129,8 +132,8 @@ export class SimpleAppService<T extends { _id?: string }> {
         label: `\$${this.documentIdentityCode}`,
         name: `\$${this.documentIdentityName}`,
       };
-      if(this.moreAutoCompleteField){
-        Object.assign(projections,this.moreAutoCompleteField)
+      if (this.moreAutoCompleteField) {
+        Object.assign(projections, this.moreAutoCompleteField);
       }
       const products = await this.doc.find(filterobj, projections, {
         limit: this.LIMITPERPAGE,
@@ -145,14 +148,13 @@ export class SimpleAppService<T extends { _id?: string }> {
   }
   async search(filters: Object) {
     try {
-      
       Object.assign(filters, this.getIsolationFilter());
-      await this.hook(HookType.beforeSearch,filters)
+      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)
+      await this.hook(HookType.afterSearch, productlist);
       //   console.log(products);
       return productlist;
     } catch (err) {
@@ -161,9 +163,9 @@ export class SimpleAppService<T extends { _id?: string }> {
     // return this;
   }
   async findById(id: string) {
-    await this.hook(HookType.beforeFetchRecord,id)
+    await this.hook(HookType.beforeFetchRecord, id);
     const data = await this.search({ _id: id });
-    await this.hook(HookType.afterFetchRecord,data)
+    await this.hook(HookType.afterFetchRecord, data);
     if (data.length == 1) {
       // console.log('data0', data[0]);
       return data[0];
@@ -176,13 +178,13 @@ export class SimpleAppService<T extends { _id?: string }> {
     let result;
 
     try {
-      await this.hook(HookType.beforeCreate,this.data)
-      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;
       await this.validateData(this.data);
       const newdoc = new this.doc(this.data);
       result = await newdoc.save();
-      await this.hook(HookType.afterCreate,result)
+      await this.hook(HookType.afterCreate, result);
     } catch (err) {
       throw new InternalServerErrorException(err.message);
     }
@@ -190,7 +192,7 @@ export class SimpleAppService<T extends { _id?: string }> {
   }
   async update() {
     const id: string = this.getRecordId();
-    Object.assign(this.data, User.getInstance().getUpdateFilter());
+    Object.assign(this.data, UserProvider.getInstance().getUpdateFilter());
     await this.findIdThenUpdate(id, this.data);
   }
   async delete() {
@@ -202,44 +204,56 @@ export class SimpleAppService<T extends { _id?: string }> {
       return dependency;
     }
   }
-  hook = async (type: string, data?: any) =>{
-    console.log("Default hook",data)
+  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-name', /.*$/);
-    ajv.addFormat('x-text', /.*$/);
+    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',
-    });
 
-    const issuccess = await this.hook(HookType.beforeValidation, 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);
       }
-      
+      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 < 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'));
     }
     await this.hook(HookType.afterValidation, data);
@@ -248,7 +262,7 @@ export class SimpleAppService<T extends { _id?: string }> {
   async findIdThenDelete(id: string): Promise<any> {
     // const data = await this.findById(id);
     try {
-      await this.hook(HookType.beforeDelete,id)
+      await this.hook(HookType.beforeDelete, id);
       //console.log('deletedeletedeletedelete');
       const dependency = await this.getRelatedRecords(id);
       if (!dependency) {
@@ -256,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)
+        await this.hook(HookType.afterDelete, deleteresult);
         //this.doc.findByIdAndDelete(id);
         return deleteresult;
       } else {
@@ -273,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)
+    await this.hook(HookType.beforeUpdate, data);
     try {
-      Object.assign(data, User.getInstance().getUpdateFilter());
+      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)
+      await this.hook(HookType.afterUpdate, data);
       return result;
     } catch (err) {
       throw new InternalServerErrorException(err.message);
@@ -317,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();
+  }
+}

package/templates/nest/app.module.eta

@@ -10,6 +10,8 @@ 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'
 <%}%>
@@ -32,8 +34,10 @@ import {<%= it[i].docname %>Module} from './docs/<%= it[i].doctype %>/<%= it[i].
       tokenValidation: TokenValidation.ONLINE,
     }),
     <% for(let i=0;i<it.length; i++){ %><%= it[i].docname %>Module,<%}%>],
-  controllers: [],
-  providers: [ {
+  controllers: [AppController],
+  providers: [
+    AppService,
+    {
     provide: APP_GUARD,     
     useClass: AuthGuard,
   },

package/templates/nest/app.service.eta

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

package/templates/nest/nest.env.eta

@@ -6,6 +6,13 @@ 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%>

package/templates/nuxt/components.debugdocdata.vue.eta

@@ -29,6 +29,6 @@ const visible = ref(false)
     right: 0;
     background-color: antiquewhite;
     font-size: large;    
-    top: 0;
+    top: 20;
 }
 </style>