@things-factory/meta-ui 8.0.0-beta.9 → 8.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/meta-ui",
-  "version": "8.0.0-beta.9",
+  "version": "8.0.0",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -27,29 +27,29 @@
   },
   "dependencies": {
     "@material/web": "^2.0.0",
-    "@operato/barcode": "^8.0.0-beta",
-    "@operato/data-grist": "^8.0.0-beta",
-    "@operato/form": "^8.0.0-beta",
-    "@operato/i18n": "^8.0.0-beta",
-    "@operato/input": "^8.0.0-beta",
-    "@operato/layout": "^8.0.0-beta",
-    "@operato/menu": "^8.0.0-beta",
-    "@operato/moment-timezone-es": "^8.0.0-beta",
-    "@operato/p13n": "^8.0.0-beta",
-    "@operato/popup": "^8.0.0-beta",
-    "@operato/shell": "^8.0.0-beta",
-    "@operato/styles": "^8.0.0-beta",
-    "@operato/time-calculator": "^8.0.0-beta",
-    "@operato/utils": "^8.0.0-beta",
-    "@things-factory/auth-base": "^8.0.0-beta.9",
-    "@things-factory/env": "^8.0.0-beta.4",
-    "@things-factory/id-rule-base": "^8.0.0-beta.9",
-    "@things-factory/menu-base": "^8.0.0-beta.9",
-    "@things-factory/personalization": "^8.0.0-beta.9",
-    "@things-factory/resource-base": "^8.0.0-beta.9",
-    "@things-factory/shell": "^8.0.0-beta.9",
-    "@things-factory/worklist": "^8.0.0-beta.9",
+    "@operato/barcode": "^8.0.0",
+    "@operato/data-grist": "^8.0.0",
+    "@operato/form": "^8.0.0",
+    "@operato/i18n": "^8.0.0",
+    "@operato/input": "^8.0.0",
+    "@operato/layout": "^8.0.0",
+    "@operato/menu": "^8.0.0",
+    "@operato/moment-timezone-es": "^8.0.0",
+    "@operato/p13n": "^8.0.0",
+    "@operato/popup": "^8.0.0",
+    "@operato/shell": "^8.0.0",
+    "@operato/styles": "^8.0.0",
+    "@operato/time-calculator": "^8.0.0",
+    "@operato/utils": "^8.0.0",
+    "@things-factory/auth-base": "^8.0.0",
+    "@things-factory/env": "^8.0.0",
+    "@things-factory/id-rule-base": "^8.0.0",
+    "@things-factory/menu-base": "^8.0.0",
+    "@things-factory/personalization": "^8.0.0",
+    "@things-factory/resource-base": "^8.0.0",
+    "@things-factory/shell": "^8.0.0",
+    "@things-factory/worklist": "^8.0.0",
     "moment-timezone": "^0.5.45"
   },
-  "gitHead": "86b1dfa26292926a2d5447fdc23bfa5a9e983245"
+  "gitHead": "07ef27d272dd9a067a9648ac7013748510556a18"
 }

package/server/activity/CommonActivity.ts

@@ -0,0 +1,68 @@
+import { ActivityInstance, /* post, */ UpdateActivityInstanceStateAddendum } from '@things-factory/worklist'
+import { Scenario } from '@things-factory/integration-base'
+import { getRepository, GraphqlLocalClient } from '@things-factory/shell'
+
+import gql from 'graphql-tag'
+
+export async function callback(
+  activityInstance: ActivityInstance,
+  addendum: UpdateActivityInstanceStateAddendum,
+  context: ResolverContext
+) {
+  const { domain } = context.state
+  const { causedBy } = addendum || {}
+
+  let instanceName = ''
+  let scenarioName = `${activityInstance.activity.name}-activity-callback`
+
+  if ((await existsScenario(domain, scenarioName)) == false) {
+    return
+  }
+
+  let variables = {
+    activityInstance,
+    causedBy
+    /* post */
+  }
+
+  await runScenario(context, instanceName, scenarioName, variables)
+}
+
+async function existsScenario(domain: any, scenarioName: string): Promise<Boolean> {
+  var repository = getRepository(Scenario)
+  var scenario = await repository.findOne({
+    where: { domain: { id: domain.id }, name: scenarioName },
+    relations: ['domain', 'steps', 'creator', 'updater']
+  })
+
+  if (!scenario) {
+    return false
+  }
+  return true
+}
+
+async function runScenario(context: any, instanceName: String, scenarioName: String, variables: any): Promise<void> {
+  // await ScenarioInstanceMutation.runScenario(instanceName,scenarioName,variables,context);
+  var client = GraphqlLocalClient.client
+
+  await client.mutate({
+    mutation: gql`
+      mutation ($instanceName: String, $scenarioName: String!, $variables: Object) {
+        runScenario(instanceName: $instanceName, scenarioName: $scenarioName, variables: $variables) {
+          instanceName
+          scenarioName
+          state
+          result
+          message
+          timestamp
+        }
+      }
+    `,
+    variables: {
+      instanceName,
+      scenarioName,
+      variables
+    },
+    context
+  })
+}

package/server/index.ts

@@ -0,0 +1,3 @@
+import './routes'
+
+export * from './service'

package/server/routes.ts

@@ -0,0 +1,61 @@
+import { ActivityInstallations, Activity, ActivityStatus } from '@things-factory/worklist'
+import { getRepository } from '@things-factory/shell'
+import { callback } from './activity/CommonActivity'
+const path = require('path')
+const { appRootPath } = require('@things-factory/env')
+const AppPackage = require(path.resolve(appRootPath, 'package.json'))
+
+process.on('bootstrap-module-global-public-route' as any, async (app: any, globalPublicRouter) => {
+  /*
+   * can add global public routes to application (auth not required, tenancy not required)
+   *
+   * ex) routes.get('/path', async(context, next) => {})
+   * ex) routes.post('/path', async(context, next) => {})
+   */
+
+  const releaseActivityTemplates: Activity[] = await getRepository(Activity).find({
+    where: { state: ActivityStatus.Released }
+  })
+
+  ;(releaseActivityTemplates || []).forEach(activity => {
+    if (activity.model && activity.model.some(x => x.name == 'relation-menu')) {
+      ActivityInstallations.installActivityTemplate({
+        name: `${activity.name}`,
+        release: AppPackage.version,
+        description: activity.description,
+        provider: AppPackage.provider,
+        // category: activity.category,
+        activityType: activity.activityType,
+        priority: activity.priority,
+        // searchKeys: [],
+        // startable: true,
+        startingType: activity.startingType,
+        model: activity.model,
+        uiType: activity.uiType,
+        uiSource: activity.uiSource,
+        viewType: activity.viewType,
+        viewSource: activity.viewSource,
+        activity: activity,
+        callback
+      })
+    }
+  })
+})
+
+process.on('bootstrap-module-global-private-route' as any, (app, globalPrivateRouter) => {
+  /*
+   * can add global private routes to application (auth required, tenancy not required)
+   */
+})
+
+process.on('bootstrap-module-domain-public-route' as any, (app, domainPublicRouter) => {
+  /*
+   * can add domain public routes to application (auth not required, tenancy required)
+   */
+})
+
+process.on('bootstrap-module-domain-private-route' as any, (app, domainPrivateRouter) => {
+  /*
+   * can add domain private routes to application (auth required, tenancy required)
+   */
+})

package/server/service/button-role/button-role-mutation.ts

@@ -0,0 +1,105 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { ButtonRole } from './button-role'
+import { NewButtonRole, ButtonRolePatch } from './button-role-type'
+
+@Resolver(ButtonRole)
+export class ButtonRoleMutation {
+  @Directive('@transaction')
+  @Mutation(returns => ButtonRole, { description: 'To create new ButtonRole' })
+  async createButtonRole(@Arg('buttonRole') buttonRole: NewButtonRole, @Ctx() context: any): Promise<ButtonRole> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(ButtonRole).save({
+      ...buttonRole,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => ButtonRole, { description: 'To modify ButtonRole information' })
+  async updateButtonRole(@Arg('id') id: string, @Arg('patch') patch: ButtonRolePatch, @Ctx() context: any): Promise<ButtonRole> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(ButtonRole)
+    const buttonRole = await repository.findOne({
+      where: { domain: { id: domain.id }, id },
+      relations: ['domain', 'updater', 'creator']
+    })
+
+    return await repository.save({
+      ...buttonRole,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [ButtonRole], { description: "To modify multiple buttonRoles' information" })
+  async updateMultipleButtonRole(@Arg('patches', type => [ButtonRolePatch]) patches: ButtonRolePatch[], @Ctx() context: any): Promise<ButtonRole[]> {
+    const { domain, user, tx } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const buttonRoleRepo = tx.getRepository(ButtonRole)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await buttonRoleRepo.save({
+          ...newRecord,
+          domain,
+          creator: user,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const updRecord = _updateRecords[i]
+        const buttonRole = await buttonRoleRepo.findOne({
+          where: { domain: { id: domain.id }, id: updRecord.id },
+          relations: ['domain', 'updater', 'creator']
+        })
+
+        const result = await buttonRoleRepo.save({
+          ...buttonRole,
+          ...updRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete ButtonRole' })
+  async deleteButtonRole(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+    const { domain, tx, user } = context.state
+    await tx.getRepository(ButtonRole).remove({ domain, id, updater: user })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple ButtonRoles' })
+  async deleteButtonRoles(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+    const { domain, tx, user } = context.state
+
+    let delEntitis = ids.map(id => {
+      return { domain, id, updater: user }
+    })
+
+    await tx.getRepository(ButtonRole).remove(delEntitis)
+
+    return true
+  }
+}

package/server/service/button-role/button-role-query.ts

@@ -0,0 +1,53 @@
+import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
+import {
+  Domain,
+  ListParam,
+  convertListParams,
+  getRepository,
+  getQueryBuilderFromListParams
+} from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { ButtonRole } from './button-role'
+import { ButtonRoleList } from './button-role-type'
+
+@Resolver(ButtonRole)
+export class ButtonRoleQuery {
+  @Query(returns => ButtonRole, { description: 'To fetch a ButtonRole' })
+  async buttonRole(@Arg('id') id: string, @Ctx() context: any): Promise<ButtonRole> {
+    const { domain } = context.state
+    return await getRepository(ButtonRole).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Query(returns => ButtonRoleList, { description: 'To fetch a multiple ButtonRole' })
+  async buttonRoles(@Args(type => ListParam) params: ListParam, @Ctx() context: any): Promise<ButtonRoleList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: await getRepository(ButtonRole),
+      searchables: ['name', 'description']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() buttonRole: ButtonRole): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: buttonRole.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() buttonRole: ButtonRole): Promise<User> {
+    return await getRepository(User).findOneBy({ id: buttonRole.updaterId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() buttonRole: ButtonRole): Promise<User> {
+    return await getRepository(User).findOneBy({ id: buttonRole.creatorId })
+  }
+}

package/server/service/button-role/button-role-type.ts

@@ -0,0 +1,39 @@
+
+import { ObjectType, Field, InputType, Int, ID, Float, registerEnumType } from 'type-graphql'
+import { ObjectRef } from '@things-factory/shell'
+
+import { ButtonRole } from './button-role'
+
+@InputType()
+export class NewButtonRole {
+
+  @Field({ nullable: false })
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+}
+
+@InputType()
+export class ButtonRolePatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field()
+  cuFlag: string
+}
+
+@ObjectType()
+export class ButtonRoleList {
+  @Field(type => [ButtonRole])
+  items: ButtonRole[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/button-role/button-role.ts

@@ -0,0 +1,61 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  Entity,
+  Index,
+  Column,
+  RelationId,
+  ManyToOne,
+  OneToMany,
+  PrimaryGeneratedColumn
+} from 'typeorm'
+import { ObjectType, Field, Int, ID, Float, registerEnumType } from 'type-graphql'
+
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+
+@Entity('button_roles')
+@Index('ix_button_role_0', (buttonRole: ButtonRole) => [buttonRole.domain, buttonRole.name], { unique: true })
+@ObjectType({ description: 'Entity for ButtonRole' })
+export class ButtonRole {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @Column({ name: 'name', type: 'character varying', length: 100, nullable: false })
+  @Field({ nullable: false })
+  name: string
+
+  @Column({ name: 'description', type: 'character varying', length: 255, nullable: true })
+  @Field({ nullable: true })
+  description: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: false })
+  domain: Domain
+
+  @RelationId((buttonRole: ButtonRole) => buttonRole.domain)
+  domainId: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, { createForeignKeyConstraints: false, nullable: true })
+  @Field(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((buttonRole: ButtonRole) => buttonRole.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { createForeignKeyConstraints: false, nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((buttonRole: ButtonRole) => buttonRole.updater)
+  updaterId?: string
+}

package/server/service/button-role/index.ts

@@ -0,0 +1,7 @@
+
+import { ButtonRole } from './button-role'
+import { ButtonRoleQuery } from './button-role-query'
+import { ButtonRoleMutation } from './button-role-mutation'
+
+export const entities = [ButtonRole]
+export const resolvers = [ButtonRoleQuery, ButtonRoleMutation]