@things-factory/document-template-base 8.0.0 → 9.0.0-beta.3

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

@@ -1,120 +0,0 @@
-
-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

@@ -1,48 +0,0 @@
-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(type => ListParam) 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

@@ -1,80 +0,0 @@
-
-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

@@ -1,89 +0,0 @@
-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(type => User, { nullable: true })
-  creator?: User
-
-  @RelationId((docTemplate: DocTemplate) => docTemplate.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { createForeignKeyConstraints: false, nullable: true })
-  @Field(type => User, { 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

@@ -1,7 +0,0 @@
-
-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,25 +0,0 @@
-/* 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
-  ]
-}
-
-export const subscribers = [
-  /* SUBSCRIBERS */
-]

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

@@ -1,7 +0,0 @@
-
-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

@@ -1,117 +0,0 @@
-
-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

@@ -1,54 +0,0 @@
-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(type => ListParam) 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

@@ -1,73 +0,0 @@
-
-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
-}