@things-factory/pdf 7.0.33 → 7.0.37

package/server/service/pdf-release/pdf-release-mutation.ts

@@ -0,0 +1,138 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { PDFRelease } from './pdf-release'
+import { NewPDFRelease, PDFReleasePatch } from './pdf-release-type'
+
+@Resolver(PDFRelease)
+export class PDFReleaseMutation {
+  @Directive('@transaction')
+  @Mutation(returns => PDFRelease, { description: 'To create new PDFRelease' })
+  async createPDFRelease(
+    @Arg('pdfRelease') pdfRelease: NewPDFRelease,
+    @Ctx() context: ResolverContext
+  ): Promise<PDFRelease> {
+    const { domain, user, tx } = context.state
+
+    const result = await tx.getRepository(PDFRelease).save({
+      ...pdfRelease,
+      domain,
+      creator: user,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => PDFRelease, { description: 'To modify PDFRelease information' })
+  async updatePDFRelease(
+    @Arg('id') id: string,
+    @Arg('patch') patch: PDFReleasePatch,
+    @Ctx() context: ResolverContext
+  ): Promise<PDFRelease> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(PDFRelease)
+    const pdfRelease = await repository.findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+
+    const result = await repository.save({
+      ...pdfRelease,
+      ...patch,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [PDFRelease], { description: "To modify multiple PDFReleases' information" })
+  async updateMultiplePDFRelease(
+    @Arg('patches', type => [PDFReleasePatch]) patches: PDFReleasePatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<PDFRelease[]> {
+    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 pdfReleaseRepo = tx.getRepository(PDFRelease)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await pdfReleaseRepo.save({
+          ...newRecord,
+          domain,
+          creator: user,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const updateRecord = _updateRecords[i]
+        const pdfRelease = await pdfReleaseRepo.findOneBy({ id: updateRecord.id })
+
+        const result = await pdfReleaseRepo.save({
+          ...pdfRelease,
+          ...updateRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete PDFRelease' })
+  async deletePDFRelease(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(PDFRelease).delete({ domain: { id: domain.id }, id })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple PDFReleases' })
+  async deletePDFReleases(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(PDFRelease).delete({
+      domain: { id: domain.id },
+      id: In(ids)
+    })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To import multiple PDFReleases' })
+  async importPDFReleases(
+    @Arg('pdfReleases', type => [PDFReleasePatch]) pdfReleases: PDFReleasePatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await Promise.all(
+      pdfReleases.map(async (pdfRelease: PDFReleasePatch) => {
+        const createdPDFRelease: PDFRelease = await tx.getRepository(PDFRelease).save({ domain, ...pdfRelease })
+      })
+    )
+
+    return true
+  }
+}

package/server/service/pdf-release/pdf-release-query.ts

@@ -0,0 +1,51 @@
+import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { PDFRelease } from './pdf-release'
+import { PDFReleaseList } from './pdf-release-type'
+
+@Resolver(PDFRelease)
+export class PDFReleaseQuery {
+  @Query(returns => PDFRelease!, { nullable: true, description: 'To fetch a PDFRelease' })
+  async pdfRelease(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<PDFRelease> {
+    const { domain } = context.state
+
+    return await getRepository(PDFRelease).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Query(returns => PDFReleaseList, { description: 'To fetch multiple PDFReleases' })
+  async pdfReleases(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<PDFReleaseList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: await getRepository(PDFRelease),
+      searchables: ['name', 'description']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() pdfRelease: PDFRelease): Promise<Domain> {
+    return pdfRelease.domainId && (await getRepository(Domain).findOneBy({ id: pdfRelease.domainId }))
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() pdfRelease: PDFRelease): Promise<User> {
+    return pdfRelease.updaterId && (await getRepository(User).findOneBy({ id: pdfRelease.updaterId }))
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() pdfRelease: PDFRelease): Promise<User> {
+    return pdfRelease.creatorId && (await getRepository(User).findOneBy({ id: pdfRelease.creatorId }))
+  }
+}

package/server/service/pdf-release/pdf-release-type.ts

@@ -0,0 +1,55 @@
+import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
+import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
+import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-graphql'
+
+import { ObjectRef, ScalarObject } from '@things-factory/shell'
+
+import { PDFRelease, PDFReleaseStatus } from './pdf-release'
+
+@InputType()
+export class NewPDFRelease {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field(type => PDFReleaseStatus, { nullable: true })
+  state?: PDFReleaseStatus
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field({ nullable: true })
+  params?: string
+}
+
+@InputType()
+export class PDFReleasePatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field(type => PDFReleaseStatus, { nullable: true })
+  state?: PDFReleaseStatus
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@ObjectType()
+export class PDFReleaseList {
+  @Field(type => [PDFRelease])
+  items: PDFRelease[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/pdf-release/pdf-release.ts

@@ -0,0 +1,103 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  DeleteDateColumn,
+  Entity,
+  Index,
+  Column,
+  RelationId,
+  ManyToOne,
+  PrimaryGeneratedColumn
+} from 'typeorm'
+import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
+
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { PDFTemplate } from '../pdf-template/pdf-template'
+
+export enum PDFReleaseStatus {
+  published = 'published',
+  failed = 'failed'
+}
+
+registerEnumType(PDFReleaseStatus, {
+  name: 'PDFReleaseStatus',
+  description: 'state enumeration of a PDFRelease'
+})
+
+@Entity()
+@Index('ix_pdf_release_0', (pdfRelease: PDFRelease) => [pdfRelease.domain, pdfRelease.name], {
+  where: '"deleted_at" IS NULL',
+  unique: true
+})
+@ObjectType({ description: 'Entity for PDFRelease' })
+export class PDFRelease {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((pdfRelease: PDFRelease) => pdfRelease.domain)
+  domainId?: string
+
+  @Column()
+  @Field({ nullable: true })
+  name?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  active?: boolean
+
+  @ManyToOne(type => PDFTemplate, { nullable: false })
+  @Field(type => PDFTemplate)
+  template?: PDFTemplate
+
+  @RelationId((release: PDFRelease) => release.template)
+  @Field()
+  templateId?: string
+
+  @Column()
+  @Field({ nullable: true })
+  filePath?: string
+
+  @Column()
+  @Field({ nullable: true })
+  fileUrl?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  state?: PDFReleaseStatus
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @DeleteDateColumn()
+  @Field({ nullable: true })
+  deletedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((pdfRelease: PDFRelease) => pdfRelease.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((pdfRelease: PDFRelease) => pdfRelease.updater)
+  updaterId?: string
+}

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

@@ -0,0 +1,7 @@
+import { PDFTemplate } from './pdf-template'
+import { PDFTemplateQuery } from './pdf-template-query'
+import { PDFTemplateMutation } from './pdf-template-mutation'
+
+export const entities = [PDFTemplate]
+export const resolvers = [PDFTemplateQuery, PDFTemplateMutation]
+export const subscribers = []

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

@@ -0,0 +1,138 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { PDFTemplate } from './pdf-template'
+import { NewPDFTemplate, PDFTemplatePatch } from './pdf-template-type'
+
+@Resolver(PDFTemplate)
+export class PDFTemplateMutation {
+  @Directive('@transaction')
+  @Mutation(returns => PDFTemplate, { description: 'To create new PDFTemplate' })
+  async createPDFTemplate(
+    @Arg('pdfTemplate') pdfTemplate: NewPDFTemplate,
+    @Ctx() context: ResolverContext
+  ): Promise<PDFTemplate> {
+    const { domain, user, tx } = context.state
+
+    const result = await tx.getRepository(PDFTemplate).save({
+      ...pdfTemplate,
+      domain,
+      creator: user,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => PDFTemplate, { description: 'To modify PDFTemplate information' })
+  async updatePDFTemplate(
+    @Arg('id') id: string,
+    @Arg('patch') patch: PDFTemplatePatch,
+    @Ctx() context: ResolverContext
+  ): Promise<PDFTemplate> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(PDFTemplate)
+    const pdfTemplate = await repository.findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+
+    const result = await repository.save({
+      ...pdfTemplate,
+      ...patch,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [PDFTemplate], { description: "To modify multiple PDFTemplates' information" })
+  async updateMultiplePDFTemplate(
+    @Arg('patches', type => [PDFTemplatePatch]) patches: PDFTemplatePatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<PDFTemplate[]> {
+    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 pdfTemplateRepo = tx.getRepository(PDFTemplate)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await pdfTemplateRepo.save({
+          ...newRecord,
+          domain,
+          creator: user,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const updateRecord = _updateRecords[i]
+        const pdfTemplate = await pdfTemplateRepo.findOneBy({ id: updateRecord.id })
+
+        const result = await pdfTemplateRepo.save({
+          ...pdfTemplate,
+          ...updateRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete PDFTemplate' })
+  async deletePDFTemplate(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(PDFTemplate).delete({ domain: { id: domain.id }, id })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple PDFTemplates' })
+  async deletePDFTemplates(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(PDFTemplate).delete({
+      domain: { id: domain.id },
+      id: In(ids)
+    })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To import multiple PDFTemplates' })
+  async importPDFTemplates(
+    @Arg('pdfTemplates', type => [PDFTemplatePatch]) pdfTemplates: PDFTemplatePatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await Promise.all(
+      pdfTemplates.map(async (pdfTemplate: PDFTemplatePatch) => {
+        const createdPDFTemplate: PDFTemplate = await tx.getRepository(PDFTemplate).save({ domain, ...pdfTemplate })
+      })
+    )
+
+    return true
+  }
+}

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

@@ -0,0 +1,51 @@
+import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { PDFTemplate } from './pdf-template'
+import { PDFTemplateList } from './pdf-template-type'
+
+@Resolver(PDFTemplate)
+export class PDFTemplateQuery {
+  @Query(returns => PDFTemplate!, { nullable: true, description: 'To fetch a PDFTemplate' })
+  async PDFTemplate(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<PDFTemplate> {
+    const { domain } = context.state
+
+    return await getRepository(PDFTemplate).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Query(returns => PDFTemplateList, { description: 'To fetch multiple PDFTemplates' })
+  async PDFTemplates(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<PDFTemplateList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: await getRepository(PDFTemplate),
+      searchables: ['name', 'description']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() pdfTemplate: PDFTemplate): Promise<Domain> {
+    return pdfTemplate.domainId && (await getRepository(Domain).findOneBy({ id: pdfTemplate.domainId }))
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() pdfTemplate: PDFTemplate): Promise<User> {
+    return pdfTemplate.updaterId && (await getRepository(User).findOneBy({ id: pdfTemplate.updaterId }))
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() pdfTemplate: PDFTemplate): Promise<User> {
+    return pdfTemplate.creatorId && (await getRepository(User).findOneBy({ id: pdfTemplate.creatorId }))
+  }
+}

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

@@ -0,0 +1,87 @@
+import { ObjectType, Field, InputType, Int, ID } from 'type-graphql'
+
+import { PDFTemplate, PDFTemplateStatus } from './pdf-template'
+
+@InputType()
+export class NewPDFTemplate {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field(type => PDFTemplateStatus, { nullable: true })
+  state?: PDFTemplateStatus
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field({ nullable: true })
+  content_template?: string
+
+  @Field({ nullable: true })
+  header_template?: string
+
+  @Field({ nullable: true })
+  footer_template?: string
+
+  @Field({ nullable: true })
+  cover_template?: string
+
+  @Field({ nullable: true })
+  last_template?: string
+
+  @Field({ nullable: true, defaultValue: 'A4' })
+  page_size: string
+
+  @Field({ nullable: true })
+  watermark: string
+}
+
+@InputType()
+export class PDFTemplatePatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field(type => PDFTemplateStatus, { nullable: true })
+  state?: PDFTemplateStatus
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field({ nullable: true })
+  content_template?: string
+
+  @Field({ nullable: true })
+  header_template?: string
+
+  @Field({ nullable: true })
+  footer_template?: string
+
+  @Field({ nullable: true })
+  cover_template?: string
+
+  @Field({ nullable: true })
+  last_template?: string
+
+  @Field({ nullable: true, defaultValue: 'A4' })
+  page_size?: string
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@ObjectType()
+export class PDFTemplateList {
+  @Field(type => [PDFTemplate])
+  items: PDFTemplate[]
+
+  @Field(type => Int)
+  total: number
+}