@simitgroup/simpleapp-generator 1.6.4-e-alpha → 1.6.4-g-alpha

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

@@ -11,12 +11,12 @@ import { Model } from 'mongoose';
 import { UserContext } from 'src/simpleapp/generate/commons/user.context';
 import { User } from 'src/simpleapp/services/user.service';
 import { Permission } from 'src/simpleapp/services/perm.service';
-
+const Base64URL = require('@darkwolf/base64url');
 @Injectable()
 export class SimpleAppRobotUserService {
   private systemAccessToken: string;
-  private setToken = (token:string) =>  this.systemAccessToken = token
-  private getToken = ()=>this.systemAccessToken
+  private setToken = (token: string) => (this.systemAccessToken = token);
+  private getToken = () => this.systemAccessToken;
   private expired: string;
   logger = new Logger();
   @InjectModel('User') private readonly usermodel: Model<User>;
@@ -28,7 +28,7 @@ export class SimpleAppRobotUserService {
   }
 
   async init() {
-    await this.refreshSystemToken();
+    // await this.refreshSystemToken();
   }
   async refreshSystemToken() {
     enum GrantType {
@@ -76,25 +76,27 @@ export class SimpleAppRobotUserService {
         return data;
       });
 
-    this.setToken(tokens.access_token)
-    // console.log("access token ",this.getToken())
+    this.setToken(tokens.access_token);
+    console.log("access token ",this.getToken())
     const nextrefresh = tokens.expires_in * 0.8;
     const appuser = this.prepareAppUser(undefined);
-    
-    if(tokens.access_token){
-      setTimeout(async () => {
-        await this.refreshSystemToken();
-      }, nextrefresh * 1000);
-    }
+
+    // if (tokens.access_token) {
+    //   setTimeout(async () => {
+    //     await this.refreshSystemToken();
+    //   }, nextrefresh * 1000);
+    // }
   }
 
   prepareAppUser(data: any) {
+    console.log("prepareAppUserprepareAppUser");
     const appuser = new UserContext(this.usermodel, this.permmodel);
     appuser.setAsStaticUser(
       '00000000-0000-0000-0000-000000000000',
       'robot',
       'Robot',
       'robot@a.org',
+      Base64URL.encodeText('0-0-0')
     );
 
     const tenantId = data?.tenantId ?? 0;
@@ -103,11 +105,7 @@ export class SimpleAppRobotUserService {
 
     appuser.setXorg(appuser.generateXorg(tenantId, orgId, branchId));
     appuser.setUserToken(this.getToken());
-    // console.log(
-    //   'return user ' + appuser.getUname(),
-    //   appuser.getXorg(),
-    //   appuser.getUserToken().length,
-    // );
+  
     return appuser;
   }
 }

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

@@ -11,16 +11,27 @@ import {
   Webhook,
   WebhookService,
 } from 'src/simpleapp/services/webhook.service';
-import {
-  Webhookhistory,
-  WebhookhistoryService,
-} from 'src/simpleapp/services/webhookhistory.service';
+import {alldocuments} from 'src/simpleapp/generate/commons/dicts/documents'
+
 @Injectable()
 export class RunWebhookService {
+  private webhookApiKey = process.env.WEBHOOK_SERVER_APIKEY
+  private webhookAppId=process.env.WEBHOOK_SERVER_APP_ID
+  private webhookurl = process.env.WEBHOOK_SERVER_URL;
+  private webhookprefix = process.env.PROJECT_CODE+'.'
+  private  webhookeventurl = `${process.env.WEBHOOK_SERVER_URL}/event/`;
+  private  webhookeventtypeurl = `${process.env.WEBHOOK_SERVER_URL}/event_types/`;
+  private webhooksync:boolean = process.env.WEBHOOKER_SYNC_EVENTTYPE=='true'
+
+
+
   public constructor(
-    private webhookService: WebhookService,
-    private webhookhistoryService: WebhookhistoryService,
-  ) {}
+    private webhookService: WebhookService,    
+  ) {
+    if(this.webhooksync) this.syncEventTypes()
+  }
+
+
   @OnEvent('webhook')
   async loadWebhook(
     appuser: UserContext,
@@ -28,42 +39,163 @@ export class RunWebhookService {
     actionName: string,
     data?: any,
   ) {
-    let subscribeall = false;
-    const webhooks = await this.webhookService.search(appuser, {
-      documentName: documentName,
-      active: true,
-    });
-    if (webhooks.length == 0) return;
 
-    const webhook = webhooks[0];
-    let subscribes: string[] = [];
-    if (webhook.setting == '' || webhook.setting === undefined) {
-      subscribeall = true;
-    } else {
-      subscribes = JSON.parse(webhook.setting);
+    //no webhook server implemented
+    if(!this.webhookApiKey) return true
+
+
+    const filter = {
+      eventTypes: documentName + '.' + actionName ,
+      active: true,
     }
+    console.log("Load webhook",documentName,actionName,filter)
+    const webhooks = await this.webhookService.search(appuser, filter);
+    console.log("Loaded webhook",webhooks)
+    if (webhooks.length == 0) return;
 
-    if (subscribeall || subscribes.includes(actionName)) {
-      await this.runWebHook(appuser, webhook, data);
+    for (let i = 0; i < webhooks.length; i++) {
+      const webhook = webhooks[i];
+      try {
+        const res = await this.runWebHook(
+          appuser,
+          webhook,
+          documentName,
+          actionName,
+          data,
+        );
+      } catch (e) {
+        return e;
+      }
     }
   }
 
-  async runWebHook(appuser: UserContext, webhook: Webhook, data: any) {
-    const webhookurl = webhook.url;
-    const headers = { 'x-from': process.env.PROJECT_NAME };
+  async runWebHook(
+    appuser: UserContext,
+    webhook: Webhook,
+    documentName: string,
+    actionName: string,
+    data: any,
+  ) {
+    
+    const headers = {};
+
+    console.log("Run webhook ",documentName,actionName)
     if (Array.isArray(webhook.headers)) {
       webhook.headers.forEach((h) => {
         headers[h.name] = h.value;
       });
     }
+    headers['accept'] = 'application/json';
+    headers['content-type'] = 'application/json';
+    headers['Authorization'] = this.webhookApiKey;
+    const eventname = `${this.webhookprefix}${documentName}.${actionName}`
     const options = {
-      method: webhook.requestMethod,
-      body: JSON.stringify(data),
+      method: webhook.requestMethod.toUpperCase(),
       headers: headers,
+      body: JSON.stringify({
+        labels: {
+          tenantId: appuser.getTenantId().toString(),
+        },
+        metadata: {
+          src: process.env.PROJECT_NAME,
+          user: appuser.getFullname(),
+        },
+        application_id: this.webhookAppId,
+        event_type: eventname,
+        event_id: crypto.randomUUID(),
+        occurred_at: new Date().toISOString(),
+        payload: JSON.stringify(data),
+        payload_content_type: 'application/json',
+      }),
+    };
+    try {
+      console.log("webhook request ",this.webhookeventurl,options)
+      const req = await fetch(this.webhookeventurl, options);
+      const statusCode = req.status;
+      if(statusCode>=300){
+        throw new InternalServerErrorException(`create event ${eventname} failed to webhook server`)
+      }
+      
+      // const body = req.body;
+    } catch (e) {
+      return e
+    }
+  }
+
+
+
+  async syncEventTypes(){
+    const options = {
+      method: 'GET', 
+      headers: {
+        accept: 'application/json',
+        Authorization: this.webhookApiKey
+      }};
+    //  {
+    //   "service_name": "billing",
+    //   "resource_type_name": "invoice",
+    //   "verb_name": "documentno",
+    //   "event_type_name": "billing.invoice.documentno"
+    // },
+    try{
+
+
+    const res = await fetch(
+      `${this.webhookeventtypeurl}?application_id=${this.webhookAppId}`, 
+      options)
+
+    const locallist = this.getSchemaEventTypes()
+    const eventlist = (await res.json()).map(item=>item.event_type_name)
+
+    for(let i=0; i<locallist.length;i++){
+      const item = locallist[i]
+      if(!eventlist.includes(item)){
+        //create remote event type
+        await this.createEventType(item)
+      }
+    }
+
+   
+    }catch(e){
+      throw new InternalServerErrorException(e)
+    }
+
+
+  }
+
+
+  async createEventType(eventname:string){
+    const para = eventname.split('.')
+    const options = {
+      method: 'POST',
+      headers: {
+        accept: 'application/json',
+        'content-type': 'application/json',
+        Authorization: this.webhookApiKey
+      },
+      body: JSON.stringify({
+        application_id: this.webhookAppId,
+        resource_type: para[0],
+        service: para[1],
+        verb: para[2]
+      })
     };
 
-    const req = await fetch(webhookurl, options);
-    const statusCode = req.status;
-    const body = req.body;
+    await fetch(this.webhookeventtypeurl, options)
+      // .then(response => response.json())
+      // .then(response => console.log(response))
+      // .catch(err => console.error(err));
+  }
+  getSchemaEventTypes(){
+    const alleventtypes:string[] = []
+    alldocuments.filter(item=>Array.isArray(item.webhook))
+      .forEach(item=>{
+        item.webhook.forEach(h=>{
+          alleventtypes.push(
+            `${this.webhookprefix}${item.docName.toLowerCase()}.${h}`)
+        })
+      })
+    return alleventtypes
+
   }
 }

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

@@ -58,6 +58,9 @@ export class UserContext {
   protected ssoACL: any = {};
   protected token: string = '';
   protected refreshtoken: string = '';
+  //guest access token obtain from header 'x-guest-accesstoken', during use x-apikey/x-apisecret
+  protected guestToken?: string='';  
+  protected guestInfo:{uid:string,uname:string,fullname:string,email:string} = {uid:'',uname:'',fullname:'',email:''}
   protected groups: string[] = [];
   protected branchCode: string = '';
   protected branchName: string = '';
@@ -110,6 +113,7 @@ export class UserContext {
   getOffsetMinute = () => this.offsetMinute;
   getGroups = () => this.groups;
   getCurrency = () => this.currency;
+  getGuestInfo = () => this.guestInfo;
   getMoreProps = () => this.moreProps;
   getRoles = () => this.roles;
   getModifieds = () => this.modifiedRecords;
@@ -282,10 +286,11 @@ export class UserContext {
     this.uid = tokeninfo?.sub ?? '';
     this.email = tokeninfo?.email ?? '';
     this.uname = tokeninfo?.preferred_username ?? '';
-    this.fullname = tokeninfo?.name ?? [];
+    this.fullname = tokeninfo?.name ?? '';
     this.ssoACL = tokeninfo?.resource_access ?? [];
     this.logger.verbose(`set token ${this.uid}`);
     //read current user from db
+    // console.log("Set User token")
     // console.log("await this.obtainProfileFromDb()")
     const userinfo = await this.obtainProfileFromDb();
     this.logger.verbose(userinfo, 'obtainProfileFromDb result');
@@ -696,6 +701,7 @@ export class UserContext {
     uname: string,
     name: string,
     email: string,
+    xorg:string
   ) => {
     //define token info
     this.token = '';
@@ -704,9 +710,18 @@ export class UserContext {
     this.uname = uname;
     this.fullname = name;
     this.ssoACL = '';
-    this.roles = [Role.Everyone, Role.User];
+    this.roles = [Role.Everyone, Role.User,Role.SuperUser];
+    this.setXorg(xorg);
   };
 
+  setGuestToken(tokenstr:string){
+    const tokeninfo = jwt.decode(tokenstr);   
+    this.guestInfo.uid = tokeninfo?.sub ?? '';
+    this.guestInfo.email = tokeninfo?.email ?? '';
+    this.guestInfo.uname = tokeninfo?.preferred_username ?? '';
+    this.guestInfo.fullname = tokeninfo?.name ?? '';
+      
+  }
   /**
    * define additional properties from user into moreProps
    */

package/templates/nest/src/simpleapp/generate/processors/simpleapp.processor.ts.eta

@@ -367,7 +367,6 @@ export class SimpleAppService<T extends { _id?: string; __v?: number }> {
       dbsession.startTransaction();
     }
 
-
     this.logger.debug(
       'this.withDocNumberFormat :' +
         this.withDocNumberFormat +
@@ -379,7 +378,6 @@ export class SimpleAppService<T extends { _id?: string; __v?: number }> {
       await this.genNewDocNo(appuser, data);
     }
 
-    
     let isolationFilter: any = { ...appuser.getCreateFilter() };
     isolationFilter = this.polishIsolationFilter(isolationFilter, data);
 
@@ -623,14 +621,14 @@ export class SimpleAppService<T extends { _id?: string; __v?: number }> {
           `You submit older version data "v${data.__v}"" but latest version = "v${existingdata.__v}"`,
         );
       }
-      this.logger.debug('warn1', existingdata);
+      // this.logger.debug('warn1', existingdata);
       data.__v = existingdata.__v + 1;
       // if (!existingdata) {
       //   throw new NotFoundException(`${id} not found`, 'not found');
       // }
-      this.logger.debug('warn2');
+      // this.logger.debug('warn2');
       if (this.hooks.beforeUpdate)
-        await this.hooks.beforeUpdate(appuser, id, data, existingdata);
+        await this.hooks.beforeUpdate(appuser, id,  existingdata,data);
 
       const dbsession = appuser.getDBSession();
       if (dbsession && !dbsession.inTransaction()) {
@@ -693,7 +691,7 @@ export class SimpleAppService<T extends { _id?: string; __v?: number }> {
     data.__v = existingdata.__v + 1;
 
     if (this.hooks.beforeUpdate)
-      await this.hooks.beforeUpdate(appuser, id, data, existingdata);
+      await this.hooks.beforeUpdate(appuser, id,existingdata, data);
 
     const dbsession = appuser.getDBSession();
     if (dbsession && !dbsession.inTransaction()) {

package/templates/nest/src/simpleapp/generate/processors/webhook.processor.ts.eta

@@ -0,0 +1,224 @@
+/**
+ * This file was automatically generated by simpleapp generator. Every
+ * MODIFICATION OVERRIDE BY GENERATEOR
+ * last change 2024-02-23
+ * Author: Ks Tan
+ */
+import { UserContext } from '../commons/user.context';
+import * as sharelibs from '../sharelibs';
+import { Injectable,  InternalServerErrorException, } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import * as jsonpath from 'jsonpath';
+import { Model } from 'mongoose';
+import { WebhookJsonSchema } from '../jsonschemas/webhook.jsonschema';
+import { SimpleAppService } from './simpleapp.processor';
+import * as types from '../types';
+import { DocNumberFormatGenerator } from '../commons/docnogenerator.service';
+import {
+  WebhookBasicAuth,
+  WebhookHeaders,
+  Webhook,
+} from '../types/webhook.type';
+import {
+  DefaultWebhookBasicAuth,
+  DefaultWebhookHeaders,
+  DefaultWebhook,
+} from '../defaults/webhook.default';
+
+@Injectable()
+export class WebhookProcessor extends SimpleAppService<Webhook> {
+  protected documentIdentityCode = 'title';
+  protected documentIdentityLabel = 'title';
+  private webhookApiKey = process.env.WEBHOOK_SERVER_APIKEY
+  private webhookAppId=process.env.WEBHOOK_SERVER_APP_ID
+  private webhookurl = process.env.WEBHOOK_SERVER_URL;
+  private webhookprefix = process.env.PROJECT_CODE+'.'
+  private  webhooksubscribtionurl = `${process.env.WEBHOOK_SERVER_URL}/subscriptions/`;
+
+  protected hooks: types.WebhookHooks = {
+    beforeCreate: async (appuser: UserContext, data: types.Webhook) =>
+      this.beforeCreate(appuser, data),
+    beforeUpdate: async (
+      appuser: UserContext,
+      id: string,
+      prevdata: types.Webhook,
+      newdata: types.Webhook,
+    ) => this.beforeUpdate(appuser, id, prevdata, newdata),
+    afterDelete: async (
+      appuser: UserContext,
+      result: types.DeleteResultType<types.Webhook>,
+      id: string,
+    ) => this.afterDelete(appuser, result, id),
+  };
+
+
+  protected foreignkeys = {};
+  constructor(mydoc: Model<Webhook>) {
+    super('WEBHOOK', 'webhook', mydoc, types.IsolationType.tenant);
+    this.setSchema(WebhookJsonSchema);
+    this.setData(DefaultWebhook(crypto.randomUUID()));
+  }
+
+  reCalculateValue(data: Webhook) {
+    //console.log('trigger new recalculate')
+    const $data = data;
+    const jsopbj = new jsonpath['JSONPath']();
+  }
+
+  async beforeCreate(appuser: UserContext, data: types.Webhook) {
+    const createResult = await this.addRemoteWebhook(appuser, data);
+    if (!createResult['subscription_id'])
+      throw new InternalServerErrorException(
+        'syncronize webhook server failed',
+      );
+    data.serverSubscriptionId = createResult.subscription_id;
+    data.serverSubscriptionSecret = createResult.secret;
+    // throw new BadRequestException("fail purposely")
+  }
+
+  async beforeUpdate(
+    appuser: UserContext,
+    id: string,
+    prevdata: types.Webhook,
+    newdata: types.Webhook,
+  ) {
+
+    if(!prevdata.serverSubscriptionId){
+        const createResult = await this.addRemoteWebhook(appuser, newdata);
+        if (!createResult['subscription_id'])
+          throw new InternalServerErrorException(
+            'syncronize webhook server failed',
+           );
+        newdata.serverSubscriptionId = createResult.subscription_id;
+        newdata.serverSubscriptionSecret = createResult.secret;
+    }else{
+      await this.updateRemoteWebhook(appuser,newdata)
+    }
+  }
+
+  async afterDelete(
+    appuser: UserContext,
+    result: types.DeleteResultType<types.Webhook>,
+    id: string,
+  ) {
+    await this.removeRemoteWebhook(appuser,result,id)         
+  }
+
+  async removeRemoteWebhook(
+    appuser: UserContext,
+    result: types.DeleteResultType<types.Webhook>,
+    id: string,
+  ){
+    const options = {
+      method: 'DELETE',
+      headers: {Authorization: this.webhookApiKey}
+    };
+
+
+    const subscriptionId=result.data.serverSubscriptionId
+    if(!subscriptionId)return 
+
+    try{
+      const res = await fetch(
+          `${this.webhooksubscribtionurl}/${subscriptionId}?application_id=${this.webhookAppId}`,
+          options)            
+    }catch(e){
+      throw new InternalServerErrorException(e)
+    }
+
+  }
+  async addRemoteWebhook(appuser: UserContext, data: types.Webhook) {
+    const headers = {};
+    data.headers.forEach((h) => {
+      headers[h.name] = h.value;
+    });
+
+    const options = {
+      method: 'POST',
+      headers: {
+        Authorization: this.webhookApiKey,
+        accept: 'application/json',
+        'content-type': 'application/json',
+      },
+      body: JSON.stringify({
+        application_id: this.webhookAppId,
+        description: data.title,
+        metadata: {
+          tenantId: data.tenantId.toString(),
+          creator: appuser.getUname(),
+        },
+        is_enabled: data.active,
+        event_types: data.eventTypes.map(
+          (item) => this.webhookprefix + item,
+        ),
+        label_key: 'tenantId',
+        label_value: data.tenantId.toString(),
+        target: {
+          headers: headers,
+          type: 'http',
+          method: data.requestMethod.toUpperCase(),
+          url: data.url,
+        },
+      }),
+    };
+    try {
+      const res = await fetch(this.webhooksubscribtionurl, options);
+      return await res.json();
+      if (res.status >= 300) {
+        this.logger.error(res.statusText, 'create webhook failed');
+        throw new InternalServerErrorException('create webhook failed');
+      }
+    } catch (e) {
+      throw new InternalServerErrorException(e);
+    }
+  }
+
+  async updateRemoteWebhook(appuser: UserContext, data: types.Webhook) {
+    const headers = {};
+    data.headers.forEach((h) => {
+      headers[h.name] = h.value;
+    });
+
+    const options = {
+      method: 'PUT',
+      headers: {
+        Authorization: this.webhookApiKey,
+        accept: 'application/json',
+        'content-type': 'application/json',
+      },
+      body: JSON.stringify({
+        application_id: this.webhookAppId,
+        description: data.title,
+        metadata: {
+          tenantId: data.tenantId.toString(),
+          creator: appuser.getUname(),
+        },
+        is_enabled: data.active,
+        event_types: data.eventTypes.map(
+          (item) => this.webhookprefix + item,
+        ),
+        label_key: 'tenantId',
+        label_value: data.tenantId.toString(),
+        target: {
+          headers: headers,
+          type: 'http',
+          method: data.requestMethod.toUpperCase(),
+          url: data.url,
+        },
+      }),
+    };
+    try {
+      const subscriptionId = data.serverSubscriptionId
+      const res = await fetch(`${this.webhooksubscribtionurl}/${subscriptionId}`, options);
+      return await res.json();
+      if (res.status >= 300) {
+        this.logger.error(res.statusText, 'updateRemoteWebhook webhook failed');
+        throw new InternalServerErrorException('update webhook failed');
+      }
+    } catch (e) {
+      throw new InternalServerErrorException(e);
+    }
+  }
+
+  /***************************** additional execute *****************************************/
+}