@things-factory/document-template-base 6.1.81 → 6.1.88

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/document-template-base",
-  "version": "6.1.81",
+  "version": "6.1.88",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
@@ -25,9 +25,9 @@
   },
   "dependencies": {
     "@things-factory/env": "^6.1.79",
-    "@things-factory/shell": "^6.1.81",
+    "@things-factory/shell": "^6.1.84",
     "form-data": "^3.0.0",
     "node-fetch": "^2.6.0"
   },
-  "gitHead": "cf39cd5eb29e1abd83a71a66fbe797409b560282"
+  "gitHead": "c532b48aaef9dc9fca4182e38333de8fcb87e4e0"
 }

package/server/index.ts

@@ -2,3 +2,4 @@ import './routes'
 
 export * from './constants'
 export * from './controllers'
+export * from './service'

package/server/service/index.ts

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

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

@@ -0,0 +1,7 @@
+
+import { TemplateFile } from './template-file'
+import { TemplateFileQuery } from './template-file-query'
+import { TemplateFileMutation } from './template-file-mutation'
+
+export const entities = [TemplateFile]
+export const resolvers = [TemplateFileQuery, TemplateFileMutation]

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

@@ -0,0 +1,117 @@
+
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { TemplateFile } from './template-file'
+import { NewTemplateFile, TemplateFilePatch } from './template-file-type'
+
+@Resolver(TemplateFile)
+export class TemplateFileMutation {
+  @Directive('@transaction')
+  @Mutation(returns => TemplateFile, { description: 'To create new TemplateFile' })
+  async createTemplateFile(@Arg('templateFile') templateFile: NewTemplateFile, @Ctx() context: any): Promise<TemplateFile> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(TemplateFile).save({
+      ...templateFile,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => TemplateFile, { description: 'To modify TemplateFile information' })
+  async updateTemplateFile(
+    @Arg('id') id: string,
+    @Arg('patch') patch: TemplateFilePatch,
+    @Ctx() context: any
+  ): Promise<TemplateFile> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(TemplateFile)
+    const templateFile = await repository.findOne(
+      {
+        where: { domain: { id: domain.id }, id },
+        relations: ['domain','updater','creator','attachment']
+      }
+    )
+
+    return await repository.save({
+      ...templateFile,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [TemplateFile], { description: "To modify multiple TemplateFiles' information" })
+  async updateMultipleTemplateFile(
+    @Arg('patches', type => [TemplateFilePatch]) patches: TemplateFilePatch[],
+    @Ctx() context: any
+  ): Promise<TemplateFile[]> {
+    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 templateFileRepo = tx.getRepository(TemplateFile)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await templateFileRepo.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 templateFile = await templateFileRepo.findOne({
+          where: { domain: { id: domain.id }, id:updRecord.id },
+          relations: ['domain','updater','creator','attachment']
+        })
+        
+        const result = await templateFileRepo.save({
+          ...templateFile,
+          ...updRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete TemplateFile' })
+  async deleteTemplateFile(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+    const { domain, tx, user } = context.state
+    await tx.getRepository(TemplateFile).remove({ domain, id, updater:user })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple templateFiles' })
+  async deleteTemplateFiles(
+    @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(TemplateFile).remove(delEntitis)
+    return true
+  }
+}

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

@@ -0,0 +1,55 @@
+
+import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
+import { ListParam, getRepository, getQueryBuilderFromListParams } from '@things-factory/shell'
+import { TemplateFile } from './template-file'
+import { TemplateFileList } from './template-file-type'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+import { Attachment } from '@things-factory/attachment-base'
+
+@Resolver(TemplateFile)
+export class TemplateFileQuery {
+  @Query(returns => TemplateFile, { description: 'To fetch a TemplateFile' })
+  async templateFile(@Arg('id') id: string, @Ctx() context: any): Promise<TemplateFile> {
+    const { domain } = context.state
+    return await getRepository(TemplateFile).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Query(returns => TemplateFileList, { description: 'To fetch multiple TemplateFiles' })
+  async templateFiles(@Args() params: ListParam, @Ctx() context: any): Promise<TemplateFileList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: await getRepository(TemplateFile),
+      searchables: ['name', 'description', 'note']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+    return { items, total }
+  }
+
+  @FieldResolver(type => Attachment)
+  async attachment(@Root() templateFile: TemplateFile): Promise<Attachment> {
+    return await getRepository(Attachment).findOneBy({id:templateFile.attachmentId})
+  }  
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() templateFile: TemplateFile): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({id:templateFile.domainId})
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root()  templateFile: TemplateFile): Promise<User> {
+    return await getRepository(User).findOneBy({id:templateFile.creatorId})
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root()  templateFile: TemplateFile): Promise<User> {
+    return await getRepository(User).findOneBy({id:templateFile.updaterId})
+  }
+}

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

@@ -0,0 +1,73 @@
+
+import { ObjectType, Field, InputType, Int, ID } from 'type-graphql'
+import { ObjectRef } from '@things-factory/shell'
+import { TemplateFile } from './template-file'
+
+@InputType()
+export class NewTemplateFile {
+  @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 })
+  activeFlag?: boolean
+
+  @Field({ nullable: true })
+  note?: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  attachment?: ObjectRef
+}
+
+@InputType()
+export class TemplateFilePatch {
+  @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 })
+  activeFlag?: boolean
+
+  @Field({ nullable: true })
+  note?: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  attachment?: ObjectRef
+
+  @Field()
+  cuFlag: string
+}
+
+@ObjectType()
+export class TemplateFileList {
+  @Field(type => [TemplateFile])
+  items: TemplateFile[]
+
+  @Field(type => Int)
+  total: number
+}

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

@@ -0,0 +1,94 @@
+
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  Entity,
+  Index,
+  Column,
+  RelationId,
+  ManyToOne,
+  OneToOne,
+  PrimaryGeneratedColumn,
+} from 'typeorm'
+import { ObjectType, Field, ID } from 'type-graphql'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+import { Attachment } from '@things-factory/attachment-base'
+
+@Entity('template_files')
+@Index('ix_template_file_0', (templateFile: TemplateFile) => [templateFile.domain,templateFile.name], { unique: true })
+@Index('ix_template_file_1', (templateFile: TemplateFile) => [templateFile.domain,templateFile.jobType])
+@Index('ix_template_file_2', (templateFile: TemplateFile) => [templateFile.domain,templateFile.jobClass])
+@Index('ix_template_file_3', (templateFile: TemplateFile) => [templateFile.domain,templateFile.jobCategory])
+@Index('ix_template_file_4', (templateFile: TemplateFile) => [templateFile.domain,templateFile.attachment])
+@ObjectType({ description: 'Entity for TemplateFile' })
+export class TemplateFile {
+  @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:'active_flag', type:'boolean', nullable:true  })
+  @Field( { nullable:true })
+  activeFlag?: boolean
+
+  @Column({ name:'note', nullable:true })
+  @Field({ nullable:true })
+  note?: string
+
+  @ManyToOne(type => Attachment, {createForeignKeyConstraints: false, nullable: true})
+  @Field({ nullable: true})
+  attachment: Attachment
+
+  @RelationId((templateFile: TemplateFile) => templateFile.attachment)
+  attachmentId?: string
+
+  @ManyToOne(type => Domain, {createForeignKeyConstraints: false, nullable: false})
+  @Field({ nullable: false })
+  domain: Domain
+
+  @RelationId((templateFile: TemplateFile) => templateFile.domain)
+  domainId: string
+
+  @ManyToOne(type => User, {createForeignKeyConstraints: false, nullable: true})
+  @Field({ nullable: true })
+  creator?: User
+
+  @RelationId((templateFile: TemplateFile) => templateFile.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, {createForeignKeyConstraints: false, nullable: true})
+  @Field({ nullable: true })
+  updater?: User
+
+  @RelationId((templateFile: TemplateFile) => templateFile.updater)
+  updaterId?: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+}