@simitgroup/simpleapp-generator 1.6.7-m-alpha → 2.0.0-a-alpha

package/templates/nest/src/simple-app/.core/features/cron/cron-system/schemas/index.ts.eta

@@ -0,0 +1,2 @@
+export {ApiEvent} from 'src/simple-app/.core/features/log/schemas';
+export {QueueJob} from 'src/simple-app/.resources/queue-job/queue-job.schema';

package/templates/nest/src/simple-app/.core/features/cron/cron.module.ts.eta

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { CronSystemModule } from './cron-system/cron-system.module';
+
+@Module({
+  imports: [CronSystemModule],
+  controllers: [],
+  providers: [],
+  exports: [CronSystemModule],
+})
+export class SimpleAppCronModule {}

package/templates/nest/src/simple-app/.core/features/document-no-format/document-no-format.controller.ts.eta

@@ -0,0 +1,31 @@
+import { Controller, Get, Put, Patch, Post, Delete, Body, Query, Param, Type, Res, Req, HttpStatus, HttpCode, NotFoundException } from '@nestjs/common';
+import { ApiTags, ApiBody, ApiResponse, ApiOperation, ApiQuery } from '@nestjs/swagger';
+import { Roles } from '../auth/role-guard/roles.decorator';
+import { Role } from '../auth/role-guard/roles.enum';
+import { Response } from 'express';
+import { AppUser } from '../user-context/appuser.decorator';
+import { UserContext } from '../user-context/user.context';
+import { MiniAppScope } from '../mini-app/mini-app-scope/mini-app-scope.decorator';
+import { DocumentNoFormatService } from './document-no-format.service';
+// import {} from '../doc-no-g'
+import * as schema from './document-no-format.schema';
+
+const apiname = 'docno'.toUpperCase();
+@ApiTags(apiname)
+@Controller(apiname.toLowerCase() + '-api')
+export class DocumentNoFormatController {
+  constructor(private service: DocumentNoFormatService) {}
+
+  @Get('/listdocformats/:doctype')
+  @Roles(Role.SuperAdmin, Role.SuperUser, Role.User)
+  @ApiResponse({ status: 200, description: 'get list of document format for 1 doctype', type: [schema.DocumentNoFormat] })
+  @ApiOperation({ operationId: 'runListDocFormats' })
+  async ListDocFormats(
+    @AppUser() appUser: UserContext,
+
+    @Param('doctype') doctype: string,
+  ) {
+    const res: schema.DocumentNoFormatPreview[] = await this.service.runListDocFormats(appUser, doctype);
+    return res;
+  }
+}

package/templates/nest/src/simple-app/.core/features/document-no-format/document-no-format.model.ts.eta

@@ -0,0 +1,15 @@
+import { DocumentNoFormat } from './document-no-format.schema';
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import * as mongoose from 'mongoose';
+
+// create mongodb schema
+
+export const DocumentNoFormatMongoSchema = SchemaFactory.createForClass(DocumentNoFormat)
+  .pre('save', function (next) {
+    this.increment();
+    return next();
+  })
+  .index({ 'tenantId': 1 })
+  .index({ orgId: 1, docNoFormatNo: 1 }, { unique: true })
+
+  .index({ 'branch._id': 1 });

package/templates/nest/src/simple-app/.core/features/document-no-format/document-no-format.module.ts.eta

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { DocumentNoFormatMongoSchema } from './document-no-format.model';
+import { DocumentNoFormatService } from './document-no-format.service';
+import {DocumentNoFormatController} from './document-no-format.controller'
+@Module({
+  imports: [MongooseModule.forFeature([{ name: 'DocumentNoFormat', schema: DocumentNoFormatMongoSchema }])],
+  controllers: [DocumentNoFormatController],
+  providers: [DocumentNoFormatService],
+  exports: [DocumentNoFormatService],
+})
+export class DocumentNoFormatModule {}

package/templates/nest/src/simple-app/.core/features/document-no-format/document-no-format.schema.ts.eta

@@ -0,0 +1,162 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Field, ObjectType, ID } from '@nestjs/graphql';
+import GraphQLJSON, { GraphQLJSONObject } from 'graphql-type-json';
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import * as mongoose from 'mongoose';
+
+export * from 'src/simple-app/.core/framework/schemas';
+
+@ObjectType()
+@Schema({ collection: 'documentnoformatbranch' })
+export class DocumentNoFormatBranch {
+  @Prop()
+  @Field()
+  @ApiProperty({ type: () => String, required: false })
+  _id?: string;
+
+  @Prop()
+  @Field()
+  @ApiProperty({ type: () => String, required: false })
+  label?: string;
+
+  @Prop()
+  @Field()
+  @ApiProperty({ type: () => Number, required: false })
+  branchId?: number;
+}
+
+@ObjectType()
+@Schema({ collection: 'documentnoformat' })
+export class DocumentNoFormat {
+  __v?: number;
+
+  @Prop()
+  @Field()
+  @ApiProperty({ type: () => String, required: false })
+  _id?: string;
+
+  @Prop()
+  @Field()
+  @ApiProperty({ type: () => String, required: false })
+  created?: string;
+
+  @Prop()
+  @Field()
+  @ApiProperty({ type: () => String, required: false })
+  updated?: string;
+
+  @Prop()
+  @Field()
+  @ApiProperty({ type: () => String, required: false })
+  createdBy?: string;
+
+  @Prop()
+  @Field()
+  @ApiProperty({ type: () => String, required: false })
+  updatedBy?: string;
+
+  @Prop()
+  @Field()
+  @ApiProperty({ type: () => Number, required: false })
+  tenantId?: number;
+
+  @Prop()
+  @Field()
+  @ApiProperty({ type: () => Number, required: false })
+  orgId?: number;
+
+  @Prop()
+  @Field()
+  @ApiProperty({ type: () => Number, required: false })
+  branchId?: number;
+
+  @Prop()
+  @Field()
+  @ApiProperty({ type: () => String, required: false })
+  docNoFormatNo?: string;
+
+  @Prop()
+  @Field()
+  @ApiProperty({ type: () => String, required: false })
+  docNoFormatName?: string;
+
+  @Prop()
+  @Field()
+  @ApiProperty({ type: () => Boolean, required: false })
+  active?: boolean;
+
+  @Prop()
+  @Field()
+  @ApiProperty({ type: () => Boolean, required: false })
+  default?: boolean;
+
+  @Prop()
+  @Field()
+  @ApiProperty({ type: () => String, required: false })
+  docNoType?: string;
+
+  @Prop()
+  @Field()
+  @ApiProperty({ type: () => String, required: false })
+  docNoPattern?: string;
+
+  @Prop()
+  @Field()
+  @ApiProperty({ type: () => Number, required: false })
+  nextNumber?: number;
+
+  @Prop()
+  @Field()
+  @ApiProperty({ type: () => DocumentNoFormatBranch, required: false })
+  branch?: DocumentNoFormatBranch;
+}
+
+/***************************************** Start Auto Complete *****************************************/
+@ObjectType()
+@Schema()
+export class DocumentNoFormatAutoComplete {
+  @Prop()
+  @Field()
+  @ApiProperty({ type: String, required: true, default: '' })
+  _id: string;
+
+  @Prop()
+  @Field()
+  @ApiProperty({ type: String, required: true, default: '' })
+  code: string;
+
+  @Prop()
+  @Field()
+  @ApiProperty({ type: String, required: true, default: '' })
+  label: string;
+
+  @Prop()
+  @Field()
+  @ApiProperty({ type: () => Boolean, required: false })
+  default?: boolean;
+}
+
+
+export class DocumentNoFormatPreview{
+  @Field()
+  @ApiProperty({ type: String, required: true, default: '' })
+  _id: string
+  @Field()
+  @ApiProperty({ type: String, required: true, default: '' })
+  docNoFormatNo: string
+  @Field()
+  @ApiProperty({ type: String, required: true, default: '' })
+  docNoFormatName: string
+  @Field()
+  @ApiProperty({ type: String, required: true, default: '' })
+  docNoPattern: string
+  @Field()
+  @ApiProperty({ type: Number, required: true, default: '' })
+  nextNumber:number
+  @Field()
+  @ApiProperty({ type: Boolean, required: true, default: '' })
+  default: boolean
+  @Field()
+  @ApiProperty({ type: String, required: true, default: '' })
+  sample: string
+}

package/templates/nest/src/simple-app/.core/features/document-no-format/document-no-format.service.ts.eta

@@ -0,0 +1,189 @@
+import { UserContext } from '../user-context/user.context';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model, FilterQuery } from 'mongoose';
+import { DocNumberFormatResult, ForeignKey, SchemaFields } from '../../framework/schemas';
+import { DocumentNoFormat, DocumentNoFormatPreview } from './document-no-format.schema';
+import { Injectable, InternalServerErrorException, BadRequestException } from '@nestjs/common';
+import { alldocuments } from './document.dict';
+import dayjs from 'dayjs';
+
+export class DocumentNoFormatService {
+  constructor(@InjectModel('DocumentNoFormat') private docformat: Model<DocumentNoFormat>) {}
+
+  async runListDocFormats(appUser: UserContext, doctype: string) {
+    doctype = doctype.toUpperCase();
+    const searchresult = await this.docformat.aggregate([
+      {
+        $match: {
+          docNoType: doctype,
+          'branch.branchId': appUser.getBranchId(),
+        },
+      },
+      { $sort: { default: -1 } },
+    ]);
+
+    let data: DocumentNoFormatPreview[] = [];
+    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,
+          nextNumber: s.nextNumber,
+          default: s.default,
+          sample: DocumentNoFormatService.previewDocNo(s),
+        });
+      }
+    }
+    return data;
+  }
+  async generateNextNumberFromDocument(appUser: UserContext, docType: string, data: any) {
+    let formatId = '';
+    if (data.DocumentNoFormat && data.DocumentNoFormat._id) {
+      formatId = data.DocumentNoFormat._id;
+    }
+    const docnoobj = await this.generateNextNo(appUser, docType, formatId);
+    const result: ForeignKey = {
+      _id: String(docnoobj.formatId),
+      code: docnoobj.formatName,
+      label: docnoobj.formatName,
+    };
+    data.DocumentNoFormat = result;
+    return docnoobj.result;
+  }
+
+  async generateNextNo(appUser: UserContext, doctype: string, id: string = '') {
+    doctype = doctype.toUpperCase();
+    const filter = { docNoType: doctype, active: true };
+    if (id) {
+      filter['_id'] = id;
+    }
+    //
+    Object.assign(filter, appUser.getBranchFilter());
+    const result = await this.docformat.find(filter).session(appUser.getDBSession());
+    if (result && result.length > 0) {
+      const d: DocumentNoFormat = result[0];
+      const recordId = d._id;
+      const newdocno = DocumentNoFormatService.previewDocNo(d);
+      const newnextnumber = d.nextNumber + 1;
+      const updatedata = { nextNumber: newnextnumber } as DocumentNoFormat;
+      const updateresult = await this.docformat.findByIdAndUpdate(recordId, updatedata).session(appUser.getDBSession());
+
+      if (updateresult) {
+        const result: DocNumberFormatResult = {
+          formatId: d._id,
+          formatName: d.docNoFormatName,
+          result: newdocno,
+        };
+        return result;
+        //;
+      } else {
+        throw new InternalServerErrorException(`Update document format ${doctype}/${recordId} to next number (${newnextnumber}) failed`);
+      }
+    } else {
+      throw new BadRequestException(`No active document number found for ${doctype}. Please update in Settings > Document Numbering Format`);
+    }
+  }
+
+  async generateBranchDefaultDocNumbers(appUser: UserContext, data: SchemaFields) {
+    const branchName = data.branchName;
+    const branchCode = data.branchCode;
+    const recordId = data._id;
+    const branchId = data.branchId;
+    const orgId = data.orgId;
+    const tenantId = data.tenantId;
+    if (tenantId == 0) {
+      throw new BadRequestException('create document no format failed due to tenantId=0');
+    }
+    if (orgId == 0) {
+      throw new BadRequestException('create document no format failed due to orgId=0');
+    }
+    if (branchId == 0) {
+      throw new BadRequestException('create document no format failed due to branchId=0');
+    }
+    const docformats = alldocuments.filter((item) => item.docNumber);
+    const allFormats: DocumentNoFormat[] = [];
+    for (let i = 0; i < docformats.length; i++) {
+      const doc = docformats[i];
+      const pattern = doc.docNoPattern.replace('@BranchCode', branchCode);
+      const formatdata: DocumentNoFormat = {
+        _id: crypto.randomUUID(),
+        docNoFormatNo: `${doc.docType}-${branchCode}`,
+        docNoFormatName: `Default ${doc.docType} - ${branchCode}`,
+        docNoType: doc.docType,
+        docNoPattern: pattern,
+        branch: { _id: recordId, branchId: branchId, label: branchName },
+        branchId: branchId,
+        orgId: orgId,
+        tenantId: tenantId,
+        active: true,
+        nextNumber: 1,
+        created: new Date().toISOString(),
+        createdBy: appUser.getUid(),
+        updated: new Date().toISOString(),
+        updatedBy: appUser.getUid(),
+        default: true,
+      };
+      allFormats.push(formatdata);
+    }
+
+    try {
+      //rollback when not able to create branch
+      const result = await this.docformat.insertMany(allFormats, { session: appUser.getDBSession() });
+      if (!result) {
+        throw new InternalServerErrorException(`Generate ${allFormats.length} document formats for "${branchCode}" failed.`, 'generateDefaultDocNumbers');
+      }
+    } catch (err) {
+      throw new InternalServerErrorException(err);
+    }
+  }
+
+  static previewDocNo = (s: DocumentNoFormat) => {
+    try {
+      const pattern = s.docNoPattern;
+      const numberReg: RegExp = /\[(.*?)\]/g;
+      const dateReg: RegExp = /\{(.*?)\}/g;
+      let newvalue = pattern;
+      const numberpattern: string[] = pattern.match(numberReg);
+      const datepattern: string[] = pattern.match(dateReg);
+
+      if (numberpattern && numberpattern.length > 0) {
+        const numberlength = numberpattern[0].replace('[', '').replace(']', '').length;
+
+        let nextnumber = s.nextNumber.toString();
+
+        const numberdiff = numberlength - nextnumber.length;
+
+        for (let n = 0; n < numberdiff; n++) {
+          nextnumber = '0' + nextnumber;
+        }
+        newvalue = newvalue.replace(numberpattern[0], nextnumber);
+      }
+
+      if (datepattern && datepattern.length > 0) {
+        for (let d = 0; d < datepattern.length; d++) {
+          const dpattern = datepattern[d];
+          const date = new Date();
+          const formatteddate = dayjs().format(dpattern.replace('{', '').replace('}', ''));
+          newvalue = newvalue.replace(dpattern, formatteddate);
+        }
+      }
+      return newvalue;
+    } catch (e) {
+      const errors = `Format ${s.docNoFormatName} error ${e}`;
+      throw new InternalServerErrorException(errors);
+    }
+  };
+
+  async search (appUser,filter:FilterQuery<DocumentNoFormat>){
+    const isolationFilter:FilterQuery<DocumentNoFormat> = {
+      tenantId:appUser.tenantId,
+      orgId:appUser.orgId,
+      branchId:appUser.branchId,
+    }
+    Object.assign(filter,isolationFilter)
+    return await this.docformat.find<DocumentNoFormat>(filter,null,{session:appUser.getDBSession()})
+  }
+}

package/templates/nest/src/simple-app/.core/features/event/event.module.ts.eta

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+
+@Module({
+  imports: [],
+  controllers: [],
+  providers: [],
+  exports: [],
+})
+export class SimpleAppEventModule {}

package/templates/nest/src/simple-app/.core/features/event/event.type.ts.eta

@@ -0,0 +1,23 @@
+export type DeletePayload<T> = {
+  id: string;
+  deleteData: T;
+};
+export type CreatePayload<T> = {
+  data: T;
+};
+export type UpdatePayload<T> = {
+  id: string;
+  prevData: T;
+  newData: T;
+};
+
+export type BeforeSetStatusPayload<T> = {
+  docStatus: string;
+  prevData: T;
+  newData: T;
+};
+
+export type AfterSetStatusPayload<T> = {
+  docStatus: string;
+  data: T;
+};

package/templates/nest/src/simple-app/.core/features/event/interface/event-after-create.interface.ts.eta

@@ -0,0 +1,5 @@
+import { UserContext } from "../../user-context/user.context"
+import { CreatePayload } from "../event.type"
+export interface EventAfterCreate<T> {
+    afterCreate(appUser:UserContext,payload: CreatePayload<T> ): Promise<void>
+}

package/templates/nest/src/simple-app/.core/features/event/interface/event-after-delete.interface.ts.eta

@@ -0,0 +1,5 @@
+import { UserContext } from "../../user-context/user.context"
+import { DeletePayload } from "../event.type"
+export interface EventAfterDelete<T> {
+    afterDelete(appUser:UserContext,payload: DeletePayload<T>): Promise<void>
+}

package/templates/nest/src/simple-app/.core/features/event/interface/event-after-set-status.interface.ts.eta

@@ -0,0 +1,5 @@
+import { UserContext } from "../../user-context/user.context"
+import { AfterSetStatusPayload } from "../event.type"
+export interface EventAfterSetStatus<T> {
+    afterSetStatus(appUser:UserContext,payload: AfterSetStatusPayload<T> ): Promise<void>
+}

package/templates/nest/src/simple-app/.core/features/event/interface/event-after-update.interface.ts.eta

@@ -0,0 +1,5 @@
+import { UserContext } from "../../user-context/user.context"
+import { UpdatePayload } from "../event.type"
+export interface EventAfterUpdate<T> {
+    afterUpdate(appUser:UserContext,payload: UpdatePayload<T> ): Promise<void>
+}

package/templates/nest/src/simple-app/.core/features/event/interface/event-before-create.interface.ts.eta

@@ -0,0 +1,5 @@
+import { UserContext } from "../../user-context/user.context"
+import {CreatePayload} from '../event.type'
+export interface EventBeforeCreate<T> {
+    beforeCreate(appUser:UserContext,payload: CreatePayload<T> ): Promise<void>
+}

package/templates/nest/src/simple-app/.core/features/event/interface/event-before-delete.interface.ts.eta

@@ -0,0 +1,5 @@
+import { UserContext } from "../../user-context/user.context"
+import { DeletePayload } from "../event.type"
+export interface EventBeforeDelete<T> {
+    beforeDelete(appUser:UserContext, payload: DeletePayload<T> ): Promise<void>
+}

package/templates/nest/src/simple-app/.core/features/event/interface/event-before-set-status.interface.ts.eta

@@ -0,0 +1,5 @@
+import { UserContext } from "../../user-context/user.context"
+import { BeforeSetStatusPayload } from "../event.type"
+export interface EventBeforeSetStatus<T> {
+    beforeSetStatus(appUser:UserContext,payload: BeforeSetStatusPayload<T> ): Promise<void>
+}

package/templates/nest/src/simple-app/.core/features/event/interface/event-before-update.interface.ts.eta

@@ -0,0 +1,5 @@
+import { UserContext } from "../../user-context/user.context"
+import { UpdatePayload } from "../event.type"
+export interface EventBeforeUpdate<T> {
+    beforeUpdate(appUser:UserContext,payload: UpdatePayload<T>): Promise<void>
+}

package/templates/nest/src/simple-app/.core/features/event/interface/index.ts.eta

@@ -0,0 +1,8 @@
+export * from './event-before-create.interface';
+export * from './event-after-create.interface';
+export * from './event-before-update.interface';
+export * from './event-after-update.interface';
+export * from './event-before-delete.interface';
+export * from './event-after-delete.interface';
+export * from './event-before-set-status.interface';
+export * from './event-after-set-status.interface';

package/templates/nest/src/simple-app/.core/features/foreign-key/foreign-key.module.ts.eta

@@ -0,0 +1,16 @@
+import { Module } from '@nestjs/common';
+// import { MongooseModule } from '@nestjs/mongoose';
+// import { ProfileService } from './profile.service';
+// import { ProfileController } from './profile.controller';
+// import {UserModule} from '../../resources/user/user.module'
+// import {PermissionModule} from '../../resources/permission/permission.module'
+// import {TenantModule} from '../../resources/tenant/tenant.module'
+// import {BranchModule} from '../../resources/branch/branch.module'
+// import {OrganizationModule} from '../../resources/organization/organization.module'
+@Module({
+  imports: [],
+  controllers: [],
+  providers: [],
+  exports: [],
+})
+export class SimpleAppForeignKeyModule {}

package/templates/nest/src/simple-app/.core/features/log/log.module.ts.eta

@@ -0,0 +1,20 @@
+/**
+ * This file was automatically generated by simpleapp generator. Every
+ * MODIFICATION OVERRIDE BY GENERATEOR
+ * last change 2024-04-02
+ * Author: Ks Tan
+ */
+import { Module } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { ApiEventMongoSchema,DocumentEventMongoSchema } from './schemas';
+
+@Module({
+  imports: [MongooseModule.forFeature([
+    { name: 'ApiEvent', schema: ApiEventMongoSchema },
+    { name: 'DocumentEvent', schema: DocumentEventMongoSchema }
+    ])],
+  controllers: [],
+  providers: [],
+  exports: [MongooseModule],
+})
+export class SimpleAppLogModule {}

package/templates/nest/src/simple-app/.core/features/log/log.service.ts.eta

@@ -0,0 +1,68 @@
+/**
+ * This file was automatically generated by simpleapp generator. Every
+ * MODIFICATION OVERRIDE BY GENERATEOR
+ * last change 2023-10-28
+ * Author: Ks Tan
+ */
+import { InjectModel } from '@nestjs/mongoose';
+import { Injectable } from '@nestjs/common';
+import { UserContext } from '../user-context/user.context';
+import { Model } from 'mongoose';
+import { DocumentEvent, ApiEvent } from './schemas';
+
+@Injectable()
+export class SimpleAppLogService {
+  constructor(@InjectModel('DocumentEvent') private doc: Model<DocumentEvent>) {}
+
+  // addEvent(data: any) {
+  //   console.log('Add event into db:', data);
+  // }
+  async addEvent(appUser: UserContext, documentName: string, id: string, eventType: string, data: any) {
+    const eventdata: DocumentEvent = {
+      _id: crypto.randomUUID(),
+      documentName: documentName,
+      documentId: id,
+      eventType: eventType,
+      eventData: data,
+      created:'',
+      createdBy:'',
+      updated: '',
+      updatedBy:'',
+      tenantId:0,
+      orgId:0,
+      branchId:0,
+    };
+    Object.assign(eventdata, appUser.getCreateFilter());
+    // console.log('add event', documentName, id, eventType);
+    // console.log('Add event into db:', eventdata);
+    const newdoc = new this.doc(eventdata);
+    const dbsession = appUser.getDBSession();
+    const result = await newdoc.save({ session: dbsession });
+  }
+
+  async addManyEvents(appUser: UserContext, documentName: string, eventType: string, datas: any[]) {
+    // console.log('add many event', documentName, eventType);
+    const alldata: DocumentEvent[] = [];
+    for (const data of datas) {
+      Object.assign(data, appUser.getCreateFilter());
+      const eventdata: DocumentEvent = {
+        _id: crypto.randomUUID(),
+        documentName: documentName,
+        documentId: data.id,
+        eventType: eventType,
+        eventData: data,
+        created:'',
+        createdBy:'',
+        updated: '',
+        updatedBy:'',
+        tenantId:0,
+        orgId:0,
+        branchId:0,
+      };
+      Object.assign(eventdata, appUser.getCreateFilter());
+      alldata.push(eventdata);
+    }
+    const dbsession = appUser.getDBSession();
+    this.doc.insertMany(alldata, { session: dbsession });
+  }
+}