@things-factory/document-template-base 6.1.94 → 6.1.96

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/document-template-base",
-  "version": "6.1.94",
+  "version": "6.1.96",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
@@ -24,10 +24,10 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create -d ./server/migrations"
   },
   "dependencies": {
-    "@things-factory/env": "^6.1.90",
-    "@things-factory/shell": "^6.1.94",
+    "@things-factory/env": "^6.1.96",
+    "@things-factory/shell": "^6.1.96",
     "form-data": "^3.0.0",
     "node-fetch": "^2.6.0"
   },
-  "gitHead": "d8e03a082bcb10fc9417b3d3bb18268bdb2a649c"
+  "gitHead": "535ca1d403d6c2d6e25314ece79f4b77d877c75b"
 }

package/server/service/doc-template/doc-template-mutation.ts

@@ -0,0 +1,120 @@
+
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { In } from 'typeorm'
+import { DocTemplate } from './doc-template'
+import { NewDocTemplate, DocTemplatePatch } from './doc-template-type'
+import { Domain, getRepository } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+
+@Resolver(DocTemplate)
+export class DocTemplateMutation {
+  @Directive('@transaction')
+  @Mutation(returns => DocTemplate, { description: 'To create new DocTemplate' })
+  async createDocTemplate(@Arg('docTemplate') docTemplate: NewDocTemplate, @Ctx() context: any): Promise<DocTemplate> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(DocTemplate).save({
+      ...docTemplate,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => DocTemplate, { description: 'To modify DocTemplate information' })
+  async updateDocTemplate(
+    @Arg('id') id: string,
+    @Arg('patch') patch: DocTemplatePatch,
+    @Ctx() context: any
+  ): Promise<DocTemplate> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(DocTemplate)
+    const docTemplate = await repository.findOne(
+      {
+        where: { domain: { id: domain.id }, id },
+        relations: ['domain','updater','creator']
+      }
+    )
+
+    return await repository.save({
+      ...docTemplate,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [DocTemplate], { description: "To modify multiple DocTemplates' information" })
+  async updateMultipleDocTemplate(
+    @Arg('patches', type => [DocTemplatePatch]) patches: DocTemplatePatch[],
+    @Ctx() context: any
+  ): Promise<DocTemplate[]> {
+    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 docTemplateRepo = tx.getRepository(DocTemplate)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await docTemplateRepo.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 docTemplate = await docTemplateRepo.findOne({
+          where: { domain: { id: domain.id }, id:updRecord.id },
+          relations: ['domain','updater','creator']
+        })
+        
+        const result = await docTemplateRepo.save({
+          ...docTemplate,
+          ...updRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete DocTemplate' })
+  async deleteDocTemplate(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+    const { domain, tx, user } = context.state
+    await tx.getRepository(DocTemplate).remove({ domain, id, updater:user })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple docTemplates' })
+  async deleteDocTemplates(
+    @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(DocTemplate).remove(delEntitis)
+    return true
+  }
+}

package/server/service/doc-template/doc-template-query.ts

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

package/server/service/doc-template/doc-template-type.ts

@@ -0,0 +1,80 @@
+
+import { ObjectType, Field, InputType, Int, ID, Float, registerEnumType } from 'type-graphql'
+import { ObjectRef } from '@things-factory/shell'
+import { DocTemplate } from './doc-template'
+
+@InputType()
+export class NewDocTemplate {
+
+  @Field( { nullable: false })
+  name: string
+
+  @Field( { nullable: false })
+  description: string
+
+  @Field( { nullable: true })
+  jobType?: string
+
+  @Field( { nullable: true })
+  jobClass?: string
+
+  @Field( { nullable: true })
+  jobCategory?: string
+
+  @Field( { nullable: true })
+  template?: string
+
+  @Field( { nullable: true })
+  logic?: string
+
+  @Field( { nullable: true })
+  activeFlag?: boolean
+
+  @Field( { nullable: true })
+  note?: string
+}
+
+@InputType()
+export class DocTemplatePatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field( { nullable: true })
+  name?: string
+
+  @Field( { nullable: true })
+  description?: string
+
+  @Field( { nullable: true })
+  jobType?: string
+
+  @Field( { nullable: true })
+  jobClass?: string
+
+  @Field( { nullable: true })
+  jobCategory?: string
+
+  @Field( { nullable: true })
+  template?: string
+
+  @Field( { nullable: true })
+  logic?: string
+
+  @Field( { nullable: true })
+  activeFlag?: boolean
+
+  @Field( { nullable: true })
+  note?: string
+
+  @Field()
+  cuFlag: string
+}
+
+@ObjectType()
+export class DocTemplateList {
+  @Field(type => [DocTemplate])
+  items: DocTemplate[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/doc-template/doc-template.ts

@@ -0,0 +1,90 @@
+
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  Entity,
+  Index,
+  Column,
+  RelationId,
+  ManyToOne,
+  PrimaryGeneratedColumn
+} from 'typeorm'
+import { ObjectType, Field, Int, ID, Float, registerEnumType } from 'type-graphql'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+@Entity('doc_templates')
+@Index('ix_doc_template_0', (docTemplate: DocTemplate) => [docTemplate.domain,docTemplate.name], { unique: true })
+@Index('ix_doc_template_1', (docTemplate: DocTemplate) => [docTemplate.domain,docTemplate.activeFlag])
+@ObjectType({ description: 'Entity for DocTemplate' })
+export class DocTemplate {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @Column({ name:'name', nullable:false })
+  @Field({ nullable:false })
+  name: string
+
+  @Column({ name:'description', nullable:false })
+  @Field({ nullable:false })
+  description: string
+
+  @Column({ name:'job_type', nullable:true })
+  @Field({ nullable:true })
+  jobType?: string
+
+  @Column({ name:'job_class', nullable:true })
+  @Field({ nullable:true })
+  jobClass?: string
+
+  @Column({ name:'job_category', nullable:true })
+  @Field({ nullable:true })
+  jobCategory?: string
+
+  @Column({ name:'template', type:'text', nullable:true  })
+  @Field({ nullable:true })
+  template?: string
+
+  @Column({ name:'logic', type:'text', nullable:true  })
+  @Field({ nullable:true })
+  logic?: string
+
+  @Column({ name:'active_flag', type:'boolean', nullable:true  })
+  @Field({ nullable:true })
+  activeFlag?: boolean
+
+  @Column({ name:'note', nullable:true })
+  @Field({ nullable:true })
+  note?: string
+  
+  @ManyToOne(type => Domain, {createForeignKeyConstraints: false, nullable: false})
+  @Field({ nullable: false })
+  domain: Domain
+
+  @RelationId((docTemplate: DocTemplate) => docTemplate.domain)
+  domainId: string
+
+  @ManyToOne(type => User, {createForeignKeyConstraints: false, nullable: true})
+  @Field({ nullable: true })
+  creator?: User
+
+  @RelationId((docTemplate: DocTemplate) => docTemplate.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, {createForeignKeyConstraints: false, nullable: true})
+  @Field({ nullable: true })
+  updater?: User
+
+  @RelationId((docTemplate: DocTemplate) => docTemplate.updater)
+  updaterId?: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+}

package/server/service/doc-template/index.ts

@@ -0,0 +1,7 @@
+
+import { DocTemplate } from './doc-template'
+import { DocTemplateQuery } from './doc-template-query'
+import { DocTemplateMutation } from './doc-template-mutation'
+
+export const entities = [DocTemplate]
+export const resolvers = [DocTemplateQuery, DocTemplateMutation]

package/server/service/index.ts

@@ -1,17 +1,21 @@
 /* EXPORT ENTITY TYPES */
+export * from './doc-template/doc-template'
 export * from './template-file/template-file'
 
 /* IMPORT ENTITIES AND RESOLVERS */
+import { entities as DocTemplateEntities, resolvers as DocTemplateResolvers } from './doc-template'
 import { entities as TemplateFileEntities, resolvers as TemplateFileResolvers } from './template-file'
 
 export const entities = [
   /* ENTITIES */
+  ...DocTemplateEntities,
 	...TemplateFileEntities
 ]
 
 export const schema = {
   resolverClasses: [
     /* RESOLVER CLASSES */
+    ...DocTemplateResolvers,
 		...TemplateFileResolvers
   ]
 }