@simitgroup/simpleapp-generator 1.1.11 → 1.1.12

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

@@ -0,0 +1,430 @@
+/**
+ * bpmn microservices
+ * require endpoints
+ * 3. get list of proccess
+ * 
+ * user method
+ * 1. start new process *
+ * 2. update existing process
+ * 3. cancel process *
+ * 4. find my process *
+ * 5. find all proccess by filter in current tenant *
+ * 6. invoke process (approve, accept and reject)
+ * 7.getproccessbyid
+ * 
+ * supply callback
+ * 1. send messaging
+ * 2. obtain dynamic users, candidate users/groups
+ * 3. 
+ 
+ */
+
+import {
+  BadRequestException,
+  Injectable,
+  InternalServerErrorException,
+  Logger,
+  NotFoundException,
+} from '@nestjs/common';
+import {
+  WorkflowSettingApiSchema,
+  WorkflowDataApiSchema,
+  WorkflowProcess,
+  WorkflowTask,
+  UserTaskActors,
+  UserTaskType
+} from './workflow.type';
+import { BPMNServer, Logger as bpmnlogger } from 'bpmn-server';
+import { configuration } from './configuration';
+import { UserContext } from '../generate/commons/user.context';
+import * as formschemas from './formschema'
+export {
+  WorkflowSettingApiSchema,
+  WorkflowDataApiSchema,
+} from './workflow.type';
+
+@Injectable()
+export class WorkflowService {
+  protected bpmnServer: BPMNServer;
+  private readonly logger = new Logger();
+  constructor() {
+    this.bpmnServer = new BPMNServer(configuration);
+  }
+
+  /**
+   * get all workflow userTask for specific uid (uuid)
+   * @param appuser
+   * @returns array of usertask
+   */
+  async getActorUserTask(appuser: UserContext, uid: string) {
+    const tmp: any[] = await this.bpmnServer.dataStore.findItems({
+      'items.status': 'wait',
+      'data.tenantId': appuser.getTenantId(),
+      //filter uid properties base on function
+      $or: [
+        { 'items.assignee': appuser.getUname() },
+        { 'items.candidateUsers': appuser.getUname() },
+        { 'items.candidateGroups': appuser.getGroup() },
+      ],
+    });
+    const result:UserTaskType[] = tmp.map((proc) => {
+      const subitem:UserTaskType = {
+      id: proc.instanceId,
+      taskId: proc.id,
+      elementId: proc.elementId,
+      name: proc.name,
+      processName: proc.processName,
+      assignee: proc.assignee,
+      candidateUsers: proc.candidateUsers,
+      candidateGroups: proc.candidateGroups,
+      data: proc.data,
+      vars: proc.vars,
+      startedAt: proc.startedAt,
+      followUpDate: proc.followUpDate,
+      dueDate: proc.dueDate,
+      priority: proc.priority,
+      type: proc.type,
+      userId: proc.userId,
+    }
+    return subitem
+  });
+    return result;
+    // throw new BadRequestException(`getActorUserTask is not supported yet`)
+  }
+  /**
+   * get all workflow userTask for my uid (uuid)
+   * @param appuser
+   * @returns array of usertask
+   */
+  async getMyUserTask(appuser: UserContext) {
+    return await this.getActorUserTask(appuser, appuser.getUid());
+  }
+
+  /**
+   * !! waiting founder
+   * deveploper method
+   * create new process definitions
+   */
+  async newWorkflowDefinitions(
+    appuser: UserContext,
+    workflowName: string,
+    xml: string,
+  ) {
+    throw new BadRequestException(
+      `newWorkflowDefinitions "${workflowName}" is not supported yet`,
+    );
+  }
+
+  async getWorkflowDefinitions(appuser: UserContext) {
+    throw new BadRequestException(
+      `getWorkflowDefinitions is not supported yet`,
+    );
+  }
+
+  async readWorkflowDefinition(appuser: UserContext, workflowname: string) {
+    throw new BadRequestException(
+      `readWorkflowDefinition is not supported yet`,
+    );
+  }
+
+  async deleteWorkflowDefinition(appuser: UserContext, workflowname: string) {
+    throw new BadRequestException(
+      `deleteWorkflowDefinition is not supported yet`,
+    );
+  }
+
+  async updateWorkflowDefinition(
+    appuser: UserContext,
+    workflowname: string,
+    xml: string,
+  ) {
+    throw new BadRequestException(
+      `updateWorkflowDefinition is not supported yet`,
+    );
+  }
+
+  /**
+   * admin workflow service, obtain all active workflows and it's pending task from all tenant
+   * status: done
+   * @param appuser
+   * @returns array of workflow process and it's waiting task
+   */
+  async getAllActiveProcesses(appuser: UserContext) {
+    const alldata = await this.bpmnServer.dataStore.findInstances(
+      { status: 'running' },
+      'summary',
+    );
+    const result = this.workflowProcessArrayMaping(alldata);
+    return result;
+  }
+
+  /**
+   * delete a workflow process from database
+   * @param appuser
+   * @param id
+   * @returns
+   */
+  async deleteWorkflowById(appuser: UserContext, id: string) {
+    if (await this.getWorkflowById(appuser, id)) {
+      const result = await this.bpmnServer.dataStore.deleteInstances({
+        id: id,
+      });
+      return {
+        status: 'ok',
+        deletedCount: result['deletedCount'],
+      };
+    }
+  }
+
+  /**
+   * invoke workflow process to next step
+   * @param appuser
+   * @param id
+   * @param taskId
+   * @param data
+   * @returns
+   */
+  async invokeWorkflowUserTask(
+    appuser: UserContext,
+    taskId: string,
+    data: any,
+  ) {
+    try {
+      const response = await this.bpmnServer.engine.invoke(
+        { 'items.id': taskId, 'items.status': 'wait' },
+        data,
+      );
+      return Object.keys(response);
+    } catch (e) {
+      throw new NotFoundException(e);
+    }
+  }
+
+  /**
+   * !! waiting founder
+   * use in adhoc situation override bpmn assignee/candidateUsers/Groups with data
+   * status: draft
+   * @param appuser
+   * @param id
+   * @param taskId
+   * @param data
+   */
+  async updateWorkflowUserTask(
+    appuser: UserContext,
+    id: string,
+    taskId: string,
+    data: UserTaskActors,
+  ) {
+    try {
+      const result = await this.bpmnServer.dataStore.findInstance(
+        { id: id },
+        {},
+      );
+
+      const usertask = result.items.find((item) => item.id == taskId);
+      if (usertask) {
+        const result = await this.bpmnServer.engine.assign(
+          { id: id, 'items.id': taskId },
+          { newData: 1 },
+          appuser.getUid(),
+          data,
+        );
+        return 'OK'; //Object.keys(result)
+      } else {
+        throw new NotFoundException(`user task id:${taskId} not found`);
+      }
+    } catch (e) {
+      throw new NotFoundException(e);
+    }
+
+    // throw new BadRequestException(`updateWorkflowUserTask is not supported yet`)
+  }
+
+  /**
+   *
+   * @param appuser search all workflow in current tenant
+   * @param filter
+   * @returns
+   */
+  async searchRunningWorkflowProcesses(appuser: UserContext, filter: any) {
+    // filter['data.tenantId']= appuser.getTenantId()  //tmp disabled waiting
+    filter['status'] = 'running';
+    return await this.searchWorkflowProcesses(appuser, filter);
+  }
+
+  /**
+   *
+   * @param appuser search all workflow in current tenant
+   * @param filter
+   * @returns
+   */
+  async searchWorkflowProcesses(appuser: UserContext, filter: any) {
+    filter['data.tenantId'] = appuser.getTenantId(); //tmp disabled waiting
+    const alldata = await this.bpmnServer.dataStore.findInstances(
+      filter,
+      'summary',
+    );
+    const result = this.workflowProcessArrayMaping(alldata);
+    return result;
+  }
+
+  async getPendingProcess(appuser: UserContext) {
+    const tmp: any[] = await this.bpmnServer.dataStore.findItems({
+      'items.status': 'wait',
+    });
+
+    const result = tmp.map((proc) => ({
+      id: proc.instanceId,
+      assignee: proc.assignee,
+      candidateUsers: proc.candidateUsers,
+      candidateGroups: proc.candidateGroups,
+      data: proc.data,
+      processName: proc.processName,
+      startedAt: proc.startedAt,
+      type: proc.type,
+      taskName: proc.name,
+      userId: proc.userId,
+    }));
+    return result;
+  }
+
+  /**
+   * initialise new workflow process
+   * status: done
+   * @param appuser
+   * @param workflowName
+   * @param data
+   * @returns workflowsummary
+   */
+  async startWorkflow(appuser: UserContext, workflowName: string, data?: any) {
+    try {
+      data.tenantId = appuser.getTenantId();
+      data.orgId = appuser.getOrgId();
+      data.branchId = appuser.getBranchId();
+      const result = await this.bpmnServer.engine.start(
+        workflowName,
+        data,
+        null,
+        appuser.getUid(),
+      );
+      return {
+        id: result.id,
+        name: result.name,
+        status: result.status,
+        userId: result.userId,
+        startedAt: result.item.startedAt,
+      };
+    } catch (e) {
+      throw new BadRequestException(e, JSON.stringify(data));
+    }
+  }
+
+  /**
+   * read single process full property
+   * @param appuser
+   * @param id
+   * @returns
+   */
+  async getWorkflowById(appuser: UserContext, id: string) {
+    try {
+      const data = await this.bpmnServer.dataStore.findInstance({ id: id }, {}); // .findInstances({id:id},'full')
+      const result = this.workflowProcessMaping(data);
+      return result;
+    } catch (e) {
+      throw new NotFoundException(e);
+    }
+  }
+  async getPendingWorkflows(appuser: UserContext) {
+    const tmp: any[] = await this.bpmnServer.dataStore.findItems({
+      'items.status': 'wait',
+    });
+
+    const result = tmp.map((proc) => ({
+      id: proc.instanceId,
+      assignee: proc.assignee,
+      candidateUsers: proc.candidateUsers,
+      candidateGroups: proc.candidateGroups,
+      data: proc.data,
+      processName: proc.processName,
+      startedAt: proc.startedAt,
+      type: proc.type,
+      taskName: proc.name,
+      userId: proc.userId,
+    }));
+    return result;
+  }
+
+  /**
+   * obtain specific bpmn task camunda:formKey
+   * @param appuser
+   * @param processName
+   * @param elementId
+   * @returns properties
+   */
+  async getWorkflowUserTaskFormKey(
+    appuser,
+    processName: string,
+    elementId: string,
+  ) {
+    try{
+
+    
+    let definition = await this.bpmnServer.definitions.load(processName);
+    let node = definition.getNodeById(elementId);
+    if(node){
+       const formKey = node.def.formKey
+        let schema:string =''
+      if(formKey.includes('jsonschema://')){
+          const keyname = formKey.replace('jsonschema://','')          
+          schema = formschemas[keyname]
+        }else if(formKey.includes('custom://')){
+          schema=formKey
+        }else{
+          //others implementation like http://, https:// and etc
+        }
+
+        if(schema){
+          return {
+            processName: processName,
+            elementId: elementId,
+            schema: schema
+          }
+        }else{
+          throw new InternalServerErrorException(`Cannot resolve schema from invalid formKey '${formKey}', example: 'jsonschema://SimpleApproveReject' or 'custom://your-custom-key'`)
+        }
+    }else{
+      throw new NotFoundException(`Element ${elementId} not found in process ${processName}`)
+    }
+   
+    }catch(e){
+      throw new InternalServerErrorException(e)
+    }
+  }
+
+  // helper
+  workflowProcessArrayMaping(alldata: any[]) {
+    const result = alldata.map((data) => this.workflowProcessMaping(data));
+    return result;
+  }
+  workflowProcessMaping(data: any) {
+    const result: WorkflowProcess = {
+      id: data.id,
+      name: data.name,
+      status: data.status,
+      startedAt: data.startedAt,
+      items: data.items
+        .filter((item) => item.type != 'bpmn:SequenceFlow')
+        .map((item) => ({
+          taskId: item.id,
+          name: item.name,
+          status: item.status,
+          assignee: item.assignee,
+          candidateUsers: item.candidateUsers,
+          candidateGroups: item.candidateGroups,
+          type: item.type,
+        })),
+    };
+
+    return result;
+  }
+}

package/templates/nest/src/simpleapp/workflow/workflow.type.ts.eta

@@ -0,0 +1,56 @@
+import { UserService } from './../services/user.service';
+export type WorkflowSettingApiSchema = {
+  userServiceUrl: string;
+  callBackUrl?: string;
+  assignee?: string;
+  candidateUsers?: string[];
+  candidategroups?: string[];
+};
+
+export type WorkflowDataApiSchema = {
+  data: any;
+  workflowSetting: WorkflowSettingApiSchema;
+};
+
+export type WorkflowTask = {
+  id: string;
+  name: string;
+  assignee: string;
+  candidateUsers: string[];
+  candidateGroups: string[];
+  type: string;
+};
+export type WorkflowProcess = {
+  id: string;
+  name: string;
+  status: string;
+  startedAt: string;
+  items: WorkflowTask[];
+};
+
+export type UserTaskActors = {
+  assignee: string;
+  candidateUsers: string[];
+  candidateGroups: string[];
+};
+
+
+export type UserTaskType = {
+  
+    id: string
+    taskId:  string
+    elementId:  string
+    name:  string
+    processName:  string
+    assignee:  string
+    candidateUsers:  string[]
+    candidateGroups:  string[]
+    data: any
+    vars: any
+    startedAt:  string
+    followUpDate:  string
+    dueDate:  string
+    priority:  string
+    type:  string
+    userId: string 
+}

package/templates/nuxt/assets/primevue/passthrough.ts._eta

@@ -40,7 +40,8 @@ const CustomTailwind = usePassThrough(
             }
         },
         sidebar:{
-            root:{class:'w-1/2  bg-white dark:bg-gray-800 border p-2 h-full'}
+            root:{class:'w-full md:w-1/2 xl:w-1/4   bg-white dark:bg-gray-800 border p-0 h-full'},
+            content:{class:'p-0 pt-0 h-full w-full grow overflow-y-auto'}
         },
         panel: {
             root:{class:['border']},

package/templates/nuxt/components/event/EventDecision.vue.eta

@@ -6,7 +6,7 @@
  * author: Ks Tan
  */
 import {Notification, EventType} from '~/types'
-import { useToast, } from 'primevue/usetoast';
+//import { useToast, } from 'primevue/usetoast';
 import type {  ToastMessageOptions } from 'primevue/toast';
 import Toast from 'primevue/toast';
 import { stringify } from 'ajv';

package/templates/nuxt/components/event/EventNotification.vue.eta

@@ -6,7 +6,7 @@
  * author: Ks Tan
  */
 import {Notification, NotificationStatus} from '~/types'
-import { useToast, } from 'primevue/usetoast';
+//import { useToast, } from 'primevue/usetoast';
 import type {  ToastMessageOptions } from 'primevue/toast';
 import Toast from 'primevue/toast';
 import { stringify } from 'ajv';

package/templates/nuxt/components/header/HeaderBar.vue.eta

@@ -27,7 +27,9 @@
             <div class=" text-right">
                 <HeaderButtonProfile/>
             </div>
-         
+            <div class=" text-right">
+                <HeaderButtonTaskList/>
+            </div>
             <!-- <div class="">
                 <HeaderSelectBranch/>              
             </div>         -->

package/templates/nuxt/components/header/button/task/HeaderButtonTaskItem.vue.eta

@@ -0,0 +1,21 @@
+<template>
+   <div class="flex flex-col border cursor-pointer p-2" @click="$emit('click',task)">
+    <!-- <span v-else class="text-gray-400 text-sm">{{ value[f] }}</span> -->
+    <!-- <div>{{ task.data }}</div> -->
+    <div class="flex flex-row">
+        <span class="flex-1">{{task.name}}</span><span class="flex-1 text-right">{{ task.startedAt }}</span>
+    </div>
+    <div class="text text-sm text-gray-400">{{task.processName}}</div>            
+    <!-- <div class="text text-xs text-gray-300">{{task.taskId}}</div> -->
+    <div v-if="task.dueDate" class="text text-xs text-gray-200">{{ task.dueDate }}</div>
+    <div v-if="task.priority" class="text text-xs text-gray-200">{{ task.priority }}</div>
+   </div> 
+</template>
+<script setup lang="ts">
+defineEmits(['click'])
+const props = defineProps<{
+    task:any
+}>()
+
+
+</script>

package/templates/nuxt/components/header/button/task/HeaderButtonTaskList.vue.eta

@@ -0,0 +1,126 @@
+<template>
+    <button class="text-center border-none  cursor-pointer p-1" @click="visible=true" >
+        <i class="pi pi-bell"></i>
+        <Sidebar v-model:visible="visible" position="right"  :modal="false" :dismissable="false">            
+            <template #header>
+                <div class="text text-lg font-bold">{{ t('mytasks') }}</div>
+            </template>
+            <HeaderButtonTaskItem  v-for="task in tasklist" :task="task" @click="viewTask"></HeaderButtonTaskItem>                                                
+        </Sidebar>
+        <Dialog v-model:visible="dialogvisible" 
+            @update:visible="closeDialog" 
+            :pt="{root:{class:'w-1/2 h-5/6'}}"
+            :modal="true" 
+            :close-on-escape="false" >                
+            <template #header>
+                <div class="text text-lg font-bold">
+                    {{ selectedtask.processName }} / {{ selectedtask.name }}
+                </div>            
+            </template>
+            <template #default>
+                <div >
+
+                    <div>                       
+                        <pre>{{ selectedtask.data}}</pre>
+                    </div>
+                    <div class="border ">
+                        <Card>
+                            <template #header>Response</template>
+                            <template #content>
+                              <div v-if="formSchema">     
+                                
+                                <SimpleAppJsonSchemaForm :schema="formSchema" #default="o">                                                        
+                                    <div v-for="field in Object.keys(formSchema.properties)" class="border p-2">                                      
+                                        <SimpleAppInput :setting="o.getField(`#/properties/${field}`)" 
+                                         :input-type="autoPickInput(formSchema.properties[field])"
+                                         v-model="data[field]" />
+                                    </div>                                    
+                                </SimpleAppJsonSchemaForm>                                
+                              </div>                                
+                            </template>
+                            <template #footer>
+                                <Button class="btn-primary" @click="invokeTask()">{{ t('submit') }}</Button>
+                                
+                            </template>
+                        </Card>                        
+                    </div>                                                   
+                </div>
+            </template>                
+        </Dialog>
+    </button>
+</template>
+<script setup lang="ts">
+import {UserTaskType,SimpleAppInputType} from '~/types'
+import { useDialog } from 'primevue/usedialog';
+const dialog = useDialog()
+const dialogvisible = ref(false)
+const visible = ref(false)
+const selectedtask = ref()
+const tasklist = ref<UserTaskType[]>([])
+const formSchema = ref()
+const data = ref<any>({})
+//computed(async ()=>await getTaskList())
+
+onMounted(async ()=> syncTask())
+watch(visible,(newvalue)=>{
+    if(newvalue){
+        syncTask()
+    }
+})
+const syncTask = async ()=>{
+    tasklist.value = await getTaskList()
+    if(tasklist.value.length==0){
+        visible.value=false
+    }
+}
+const closeDialog = ()=>{
+    console.log('close dialog')
+}
+
+const invokeTask = async ()=>{
+    const res = await invokeUserTask(selectedtask.value.taskId,data)
+    syncTask()
+    dialogvisible.value=false
+}
+const viewTask = async (task:UserTaskType)=>{
+    selectedtask.value=task
+    dialogvisible.value=true
+    const formsettings:any = await getTaskForm(task.processName, task.elementId)
+    formSchema.value = formsettings.schema
+    Object.keys(formsettings.schema.properties).forEach((key)=>{        
+        data.value[key]=null
+    })
+    console.log("data,data",data)
+}
+
+const autoPickInput = (setting:any) =>{
+    if(setting.type=='boolean'){
+        return SimpleAppInputType.checkbox
+    }if(setting.type=='number'){
+        return SimpleAppInputType.number
+    }
+    else if(setting.enum){
+        return SimpleAppInputType.select
+    }
+    else if(setting.type=='string'){
+        return pickStringInput(setting)        
+    }else{
+        return SimpleAppInputType.text
+    }
+}
+
+const pickStringInput = (setting:any) =>{
+    switch(setting.format){
+        case 'date':
+            return SimpleAppInputType.date
+        break;
+        case 'textarea':
+            return SimpleAppInputType.textarea
+        break;
+        case 'text':
+        default:
+            return SimpleAppInputType.text
+        break;
+    }
+}
+</script>