@simitgroup/simpleapp-generator 1.0.32 → 1.0.35

package/templates/nest/src/simpleapp/profile/profile.apischema.ts.eta

@@ -0,0 +1,74 @@
+import { ApiProperty } from '@nestjs/swagger';
+import {ProfileUserInvites,ProfileUserBranch} from './profile.types'
+export class RegTenantApiSchema {
+  @ApiProperty({
+    type: 'string',
+    required: true,
+    examples: ['my company 1'],
+    default: '',
+  })
+  tenantName: string;
+}
+export class MyProfileApiSchemaBranches{
+  @ApiProperty({type: 'string'})
+  _id: '1231231';
+  @ApiProperty({type: 'number'})
+  tenantId: 2;
+  @ApiProperty({type: 'number'})
+  orgId: 1;
+  @ApiProperty({type: 'number'})
+  branchId: 1;
+  @ApiProperty({type: 'string'})
+  group: 'cashier';
+  @ApiProperty({type: 'string'})
+  xOrg: 'Mi0xLTE';
+}
+export class MyProfileApiSchemaInvites{
+  @ApiProperty({type: 'string'})
+  _id: string;
+  @ApiProperty({type: 'string'})
+  email: string;
+  @ApiProperty({type: 'string'})
+  created: string;
+  permission: any[];
+  // @ApiProperty({type: 'string'})
+  // _id: '6527e3eff96dd5156e267bab';
+  // @ApiProperty({type: 'number'})
+  // tenantId: 2;
+  // @ApiProperty({type: 'number'})
+  // orgId: 1;
+  // @ApiProperty({type: 'number'})
+  // branchId: 1;
+  // @ApiProperty({type: 'string'})
+  // group: 'cashier';
+  // @ApiProperty({type: 'string'})
+  // xOrg: 'Mi0xLTE';
+}
+export class MyProfileApiSchema {
+  @ApiProperty({type: 'string'})
+  _id: string;
+  @ApiProperty({type: 'number'})
+  tenantId: number;
+  @ApiProperty({type: 'number'})
+  'orgId': number;
+  @ApiProperty({type: 'number'})
+  'branchId': number;
+  @ApiProperty({type: 'string'})
+  'email': string;
+  @ApiProperty({type: 'number'})
+  'uid': string;
+  @ApiProperty({type: 'number'})
+  'fullName': string;
+  @ApiProperty({type: 'number'})
+  'group': string;
+  @ApiProperty({type: ['string']})
+  'roles': string[];
+  
+
+  @ApiProperty({type: [MyProfileApiSchemaBranches]})
+  'branches': ProfileUserBranch[]
+  @ApiProperty({type: [MyProfileApiSchemaInvites]})
+  'invites': ProfileUserInvites[];
+  @ApiProperty({type: 'string'})
+  'time': string;
+}

package/templates/nest/src/simpleapp/profile/profile.controller.ts.eta

@@ -0,0 +1,110 @@
+import {
+  Controller,
+  Get,
+  Put,
+  Post,
+  Patch,
+  Delete,
+  Body,
+  Query,
+  Param,
+  Type,
+  Res,
+  HttpStatus,
+  Inject,
+  Injectable,
+  Scope,
+  Req,
+  HttpException,
+  Request,
+  Logger,
+} from '@nestjs/common';
+import { Roles } from '../generate/commons/roles/roles.decorator';
+import { Role } from '../generate/commons/roles/roles.enum';
+import { ApiTags, ApiBody, ApiResponse, ApiOperation } from '@nestjs/swagger';
+import { UserContext } from '../generate/commons/user.context';
+import { ProfileService } from './profile.service';
+import { AppUser } from '../generate/commons/decorators/appuser.decorator';
+import { RegTenant } from './profile.types';
+import { RegTenantApiSchema, MyProfileApiSchema } from './profile.apischema';
+@ApiTags('PROFILE')
+@Controller('/profile')
+export class ProfileController {
+  protected logger = new Logger();
+  constructor(private profileservice: ProfileService) {
+    //console.log("init Profile Controller ")
+  }
+
+  @Get()
+  @Roles(Role.Everyone, Role.User)
+  @ApiOperation({
+    operationId: 'getProfile',
+    description: 'Get current user profile',
+  })
+  @ApiResponse({
+    status: 200,
+    type: () => MyProfileApiSchema,
+    description: 'Success',
+  })
+  @ApiResponse({ status: 401, type: Object, description: 'Undefine profile' })
+  async getProfile(@AppUser() appuser: UserContext) {
+    this.logger.debug(
+      `access getProfile API by ${appuser.getUid()},(${appuser.getId()})`,
+    );
+    const result = await this.profileservice.getProfile(appuser);
+    this.logger.debug('getProfile result is:');
+    this.logger.debug(result);
+    if (result) {
+      return result;
+    } else {
+      throw new HttpException('Forbidden', HttpStatus.FORBIDDEN);
+    }
+  }
+
+
+  @Post('/tenant')
+  @Roles(Role.Everyone)
+  @ApiBody({ description: 'create tenant name', type: RegTenantApiSchema })
+  @ApiOperation({
+    operationId: 'createTenant',
+    description: 'create new tenant',
+  })
+  @ApiResponse({ status: 201, type: Object, description: 'Success' })
+  async createTenant(
+    @AppUser() appuser: UserContext,
+    @Body('tenantName') tenantName: string,
+  ) {
+    const result = await this.profileservice.createTenant(appuser, tenantName);
+    if (result) {
+      return result;
+    } else {
+      throw new HttpException('Forbidden', HttpStatus.FORBIDDEN);
+    }
+  }
+
+  @Post('/invitation/:id/:decision')
+  @Roles(Role.Everyone)
+  @ApiOperation({
+    operationId: 'decideInvitation',
+    description: 'accept or reject invitation to tenant',
+  })
+  @ApiResponse({ status: 201, type: Object, description: 'Success' })
+  async decideInvitation(
+    @AppUser() appuser: UserContext,
+    @Param('id') id: string,
+    @Param('decision') decision: string,
+  ) {
+    const result = await this.profileservice.decideInvitation(
+      appuser,
+      id,
+      decision,
+    );
+    if (result) {
+      console.log('result', result);
+      return result;
+    } else {
+      console.log('throw error');
+      throw new HttpException('Forbidden', HttpStatus.FORBIDDEN);
+    }
+  }
+}

package/templates/nest/src/simpleapp/profile/profile.service.ts.eta

@@ -0,0 +1,195 @@
+import { UserService, User } from './../services/user.service';
+import {
+  Injectable,
+  Scope,
+  Inject,
+  Logger,
+  BadRequestException,
+  InternalServerErrorException,
+} from '@nestjs/common';
+import { UserContext } from '../generate/commons/user.context';
+import { RegTenant } from './profile.types';
+import * as mongoose from 'mongoose';
+import { InjectConnection } from '@nestjs/mongoose';
+import { TenantService, Tenant } from '../services/tenant.service';
+import { OrganizationService, Organization } from '../services/org.service';
+import { BranchService, Branch } from '../services/branch.service';
+import { PermissionService, Permission } from './../services/perm.service';
+
+const Base64URL = require('@darkwolf/base64url');
+@Injectable()
+export class ProfileService {
+  protected logger = new Logger();
+  constructor(
+    private usersvc: UserService,
+    private tenantsvc: TenantService,
+    private orgsvc: OrganizationService,
+    private branchsvc: BranchService,
+    private permsvc: PermissionService,
+  ) {}
+
+  /**
+   * get user profile for current tenant
+   * tenantId=0, if profile not exists will auto create one
+   * tenantId>0, if profile not exists will reject
+   * @param appuser
+   * @returns
+   */
+  async getProfile(appuser: UserContext) {
+    const accessTenantId = appuser.getTenantId();
+    this.logger.verbose(
+      `get userprofile for ${appuser.getUid()} for tenantId ${accessTenantId}`,
+      'getProfile',
+    );
+    const userinfo = await appuser.getUserInfo();
+
+    if (userinfo._id == '') {
+      this.logger.warn('unknown _id for ', appuser.getUid());
+
+      let newprofile;
+      if (accessTenantId == 0) {
+        newprofile = await this.createUserProfile(appuser);
+        newprofile['time'] = new Date().toISOString();
+        return newprofile;
+      } else {
+        return undefined;
+      }
+    } else {
+      userinfo['time'] = new Date().toISOString();
+      return userinfo;
+    }
+  }
+
+  async createUserProfile(appuser: UserContext) {
+
+    
+    const data: User = {
+      uid: appuser.getUid(),
+      fullname: appuser.getFullname(),
+      email: appuser.getEmail(),
+      active: true,
+      doctype: 'user',
+    } as User;
+
+    const createresult = await this.usersvc.create(appuser, data);
+    const userinfo = await appuser.getUserInfo();
+    userinfo._id = createresult._id;
+    return userinfo;
+  }
+
+  async createTenant(appuser: UserContext, tenantName: string) {
+    // try{
+    appuser.getDBSession().startTransaction()    
+    const tenantdata: Tenant = {
+      tenantId: 1,
+      tenantName: tenantName,
+      active: true,
+      owner: {
+        _id: appuser.getId(),
+        label: appuser.getFullname(),
+        uid: appuser.getUid(),
+      },
+    };
+    this.logger.log(tenantdata, 'createTenant data');
+    const tenantResult = await this.tenantsvc.create(appuser, tenantdata);
+    if (!tenantResult) {
+      throw new BadRequestException('Create tenant failed');
+    }
+    this.logger.log(tenantResult, 'createTenant result');
+    const tenantId = tenantResult.tenantId;
+
+    // return tenantResult
+    const orgdata: Organization = {
+      tenantId: tenantResult.tenantId,
+      orgName: tenantName,
+      active: true,
+      orgCode: 'HQ',
+      orgId: 1,
+    };
+    
+    this.logger.log(orgdata, 'createOrg data');
+    const orgResult = await this.orgsvc.create(appuser, orgdata);
+    if (!orgResult) {
+      throw new BadRequestException('Create Org failed');
+    }
+    const orgRecordId = orgResult._id.toString();
+    this.logger.log(orgResult, 'createOrg result');
+
+    const branchdata: Branch = {
+      branchId: 1,
+      branchCode: 'HQ',
+      branchName: tenantName,
+      active: true,
+      orgId: orgResult.orgId,
+      tenantId: tenantResult.tenantId,
+      organization: { _id: orgRecordId, label: tenantName },
+    };
+    this.logger.log(branchdata, 'createbranch data');
+    
+    const branchResult = await this.branchsvc.create(appuser, branchdata);
+    if (!branchResult) {
+      throw new BadRequestException('Create Branch failed');
+    }
+    const branchRecordId = branchResult._id.toString();
+    this.logger.log(branchResult, 'createbranch result');
+
+    const userdata: User = {
+      tenantId: tenantResult.tenantId,
+      orgId: orgResult.orgId,
+      branchId: branchResult.branchId,
+      uid: appuser.getUid(),
+      fullname: appuser.getFullname(),
+      email: appuser.getEmail(),
+      active: true,
+    };
+    this.logger.log(userdata, 'createtenant user data');
+    const userResult = await this.usersvc.create(appuser, userdata);
+    // if(true ){
+    if (!userResult) {
+      throw new BadRequestException('Create User failed');
+    }
+
+    this.logger.log(userResult, 'createtenant user result');
+    const userRecordId = userResult._id.toString();
+
+    const permdata: Permission = {
+      tenantId: tenantResult.tenantId,
+      orgId: orgResult.orgId,
+      branchId: branchResult.branchId,
+      uid: appuser.getUid(),
+      group: 'admin',
+    };
+    this.logger.log(permdata, 'create Permission data');
+    const permResult = await this.permsvc.create(appuser, permdata);
+    if (!permResult) {
+      throw new BadRequestException('Create permResult failed');
+    }
+
+    this.logger.log(permResult, 'create Permission result');
+
+    const xorg: string = Base64URL.encodeText(
+      `${tenantResult.tenantId}-${orgResult.orgId}-${branchResult.branchId}`,
+    );
+    const finalresult = {
+      xOrg: xorg,
+      tenantId: tenantResult.tenantId,
+      orgId: orgResult.orgId,
+      branchId: branchResult.branchId,
+    };
+    return finalresult;
+    // }catch(e){
+    //   this.logger.error("Couldn't generate tenant or subsequence records")
+    //   throw new InternalServerErrorException(e)
+    // }
+  }
+
+  /**
+   * accept or reject invitation
+   * @param appuser
+   * @param id
+   * @param decision
+   */
+  async decideInvitation(appuser: UserContext, id: string, decision: string) {
+    return await appuser.decideInvitation(id, decision);
+  }
+}

package/templates/nest/src/simpleapp/profile/profile.types.ts.eta

@@ -0,0 +1,18 @@
+export type RegTenant = {
+    tenantName: string;
+  };
+  export type ProfileUserBranch = {
+    _id: string  
+    branch: any  
+    group: string
+    xOrg: string
+  };
+  export type ProfileUserInvites = {
+    _id: string;
+    email: string;
+    fullName: string;
+    tenantId: string;
+    tenantName: string;
+    created: string;
+  };
+  

package/templates/nest/src/simpleapp/services/autoinc.service.ts.eta

@@ -0,0 +1,89 @@
+/**
+ * This file was automatically generated by simpleapp generator.
+ * It will not override by generator
+ * last change 2023-09-23
+ * Author: Ks Tan
+ */
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { Injectable } from '@nestjs/common';
+import { AutoincreamentProcessor } from '../generate/processors/autoinc.processor';
+import { DocNumberFormatGenerator } from '../generate/commons/docnogenerator.service';
+import { Autoincreament } from '../generate/types/autoinc.type';
+import { UserContext } from '../generate/commons/user.context';
+export { Autoincreament } from '../generate/types/autoinc.type';
+
+@Injectable()
+export class AutoincreamentService extends AutoincreamentProcessor {
+  constructor(
+    @InjectModel('Autoincreament') mydoc: Model<Autoincreament>,
+    docnogenerator: DocNumberFormatGenerator,
+    ) {
+    super(mydoc,docnogenerator);
+  }
+
+  //    hook = async (appuser:UserContext,type: string, data?: any) => {
+  //     switch(type){
+  //         case 'init':
+  //         break;
+  //         case 'beforeSearch':
+  //         break;
+  //         case 'afterSearch':
+  //         break;
+  //         case 'beforeValidation':
+  //         break;
+  //         case 'afterValidation':
+  //         break;
+  //         case 'beforeCreate':
+  //         break;
+  //         case 'afterCreate':
+  //         break;
+  //         case 'beforeUpdate':
+  //         break;
+  //         case 'afterUpdate':
+  //         break;
+  //         case 'beforeDelete':
+  //         break;
+  //         case 'afterDelete':
+  //         break;
+  //         case 'beforeFetchRecord':
+  //         break;
+  //         case 'afterFetchRecord':
+  //         break;
+  //         default:
+  //         break;
+  //         }
+  //     return true;
+  //   };
+
+  async generateNextNo(
+    appuser: UserContext,
+    collection: string,
+    field: string,
+  ) {
+    const res = await this.search(appuser, {
+      collectionName: collection,
+      fieldName: field,
+    });
+    // console.log(res)
+    let data;
+    if (res.length > 0) {
+      // console.log("FOUND RESULT------")
+      const tmp = res[0];
+      const nextno = tmp.nextno;
+      data = { collectionName: collection, fieldName: field, nextno: nextno };
+      this.findIdThenUpdate(appuser, tmp._id, {
+        collectionName: collection,
+        fieldName: field,
+        nextno: tmp.nextno + 1,
+      });
+    } else {
+      // console.log("CREATE ROW------")
+      this.data = { collectionName: collection, fieldName: field, nextno: 2 };
+      const createResult = await this.create(appuser, this.data);
+      data = { _id:crypto.randomUUID(), collectionName: collection, fieldName: field, nextno: 1 };
+    }
+
+    return data;
+  }
+}

package/templates/nest/src/simpleapp/services/branch.service.ts.eta

@@ -0,0 +1,66 @@
+/**
+ * This file was automatically generated by simpleapp generator.
+ * It will not override by generator
+ * last change 2023-09-23
+ * Author: Ks Tan
+ */
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { Injectable } from '@nestjs/common';
+import { BranchProcessor } from '../generate/processors/branch.processor';
+import { Branch } from '../generate/types/branch.type';
+export { Branch } from '../generate/types/branch.type';
+import { AutoincreamentService } from './autoinc.service';
+import { UserContext } from '../generate/commons/user.context';
+import { DocNumberFormatGenerator } from '../generate/commons/docnogenerator.service';
+@Injectable()
+export class BranchService extends BranchProcessor {
+  protected strictIsolation = false;
+  constructor(
+    @InjectModel('Branch') mydoc: Model<Branch>,
+    private increament: AutoincreamentService,
+    docnogenerator: DocNumberFormatGenerator,
+  ) {
+    super(mydoc,docnogenerator);
+  }
+
+  hook = async (appuser: UserContext, type: string, data?: any) => {
+    switch (type) {
+      //         case 'init':
+      //         break;
+      //         case 'beforeSearch':
+      //         break;
+      //         case 'afterSearch':
+      //         break;
+      //         case 'beforeValidation':
+      //         break;
+      //         case 'afterValidation':
+      //         break;
+      case 'beforeCreate':
+        const searchresult = await this.increament.generateNextNo(
+          appuser,
+          'branch',
+          'branchId',
+        );
+        data.branchId = searchresult.nextno;
+        break;
+      //         case 'afterCreate':
+      //         break;
+      //         case 'beforeUpdate':
+      //         break;
+      //         case 'afterUpdate':
+      //         break;
+      //         case 'beforeDelete':
+      //         break;
+      //         case 'afterDelete':
+      //         break;
+      //         case 'beforeFetchRecord':
+      //         break;
+      //         case 'afterFetchRecord':
+      //         break;
+      //         default:
+      //         break;
+    }
+    return true;
+  };
+}

package/templates/nest/src/simpleapp/services/docno.service.ts.eta

@@ -0,0 +1,93 @@
+import { BadRequestException } from '@nestjs/common';
+/**
+ * This file was automatically generated by simpleapp generator.
+ * It will not override by generator
+ * last change 2023-09-23
+ * Author: Ks Tan
+ */
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { Injectable, InternalServerErrorException } from '@nestjs/common';
+import { DocnoformatProcessor } from '../generate/processors/docno.processor';
+import { Docnoformat } from '../generate/types/docno.type';
+import { UserContext } from '../generate/commons/user.context';
+import * as moment from 'moment';
+import { DocNumberFormatGenerator } from '../generate/commons/docnogenerator.service';
+export { Docnoformat } from '../generate/types/docno.type';
+
+@Injectable()
+export class DocnoformatService extends DocnoformatProcessor {
+  constructor(
+    @InjectModel('Docnoformat') mydoc: Model<Docnoformat>,
+    docnogenerator: DocNumberFormatGenerator,
+  ) {
+    super(mydoc,docnogenerator);
+  }
+
+  //    hook = async (type: string, data?: any) => {
+  //     switch(type){
+  //         case 'init':
+  //         break;
+  //         case 'beforeSearch':
+  //         break;
+  //         case 'afterSearch':
+  //         break;
+  //         case 'beforeValidation':
+  //         break;
+  //         case 'afterValidation':
+  //         break;
+  //         case 'beforeCreate':
+  //         break;
+  //         case 'afterCreate':
+  //         break;
+  //         case 'beforeUpdate':
+  //         break;
+  //         case 'afterUpdate':
+  //         break;
+  //         case 'beforeDelete':
+  //         break;
+  //         case 'afterDelete':
+  //         break;
+  //         case 'beforeFetchRecord':
+  //         break;
+  //         case 'afterFetchRecord':
+  //         break;
+  //         default:
+  //         break;
+  //         }
+  //     return true;
+  //   };
+
+  /**
+   * list document number format and prepare sample of docformat
+   * @param appuser
+   * @param doctype
+   * @returns
+   */
+  async listDocFormats(appuser: UserContext, doctype: string) {
+    doctype = doctype.toUpperCase();
+    const searchresult = await this.search(
+      appuser,
+      { docNoType: doctype },
+      { default: 'desc' },
+    );
+    console.log(searchresult);
+    let data: any = [];
+    for (let i = 0; i < searchresult.length; i++) {
+      const s = searchresult[i];
+      if (s.active && s.docNoPattern) {
+        data.push({
+          _id: s._id,
+          docNoFormatNo: s.docNoFormatNo,
+          docNoFormatName: s.docNoFormatName,
+          docNoPattern: s.docNoPattern,
+          isMonthly: s.isMonthly,
+          nextNumber: s.nextNumber,
+          default: s.default,
+          sample: DocNumberFormatGenerator.previewDocNo(s),
+        });
+      }
+    }
+    return data;
+  }
+}