@things-factory/tax-invoice 6.2.84

package/server/service/tax-invoice-api/tax-invoice-api.ts

@@ -0,0 +1,137 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  DeleteDateColumn,
+  Entity,
+  Index,
+  OneToOne,
+  Column,
+  RelationId,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  VersionColumn,
+  JoinColumn
+} from 'typeorm'
+import { ObjectType, Field, ID } from 'type-graphql'
+
+import { Domain, ScalarObject, encryptTransformer } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+
+@Entity()
+@Index('ix_tax_invoice_api_0', (taxInvoiceApi: TaxInvoiceApi) => [taxInvoiceApi.domain, taxInvoiceApi.name, taxInvoiceApi.deletedAt])
+@Index('ix_tax_invoice_api_1', (taxInvoiceApi: TaxInvoiceApi) => [taxInvoiceApi.domain, taxInvoiceApi.description, taxInvoiceApi.deletedAt])
+@ObjectType({ description: 'Entity for Tax Invoice Api' })
+export class TaxInvoiceApi {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id!: string
+
+  @VersionColumn()
+  @Field({ nullable: true })
+  version?: number = 1
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((taxInvoiceApi: TaxInvoiceApi) => taxInvoiceApi.domain)
+  domainId?: string
+
+  @Field({ nullable: false })
+  @Column({ nullable: false })
+  name!: string
+
+  @Field({ nullable: true })
+  @Column({ nullable: true })
+  description?: string
+
+  @Column({ nullable: true, comment: 'API Key', transformer: encryptTransformer })
+  @Field({ nullable: true, description: 'API Key' })
+  apiKey?: string
+
+  @Column({ nullable: true, comment: 'API 계정 ID', transformer: encryptTransformer })
+  @Field({ nullable: true, description: 'API 계정 ID' })
+  apiAccountId?: string
+
+  @Column({ nullable: true, comment: 'API 계정 비밀번호', transformer: encryptTransformer })
+  @Field({ nullable: true, description: 'API 계정 비밀번호' })
+  apiAccountPassword?: string
+
+  @Column({ nullable: true, comment: '사업자등록번호', transformer: encryptTransformer })
+  @Field({ nullable: true, description: '사업자등록번호' })
+  businessRegistrationNumber?: string
+
+  @Column({ nullable: true, comment: '종사업장 식별 코드' })
+  @Field({ nullable: true, description: '종사업장 식별 코드' })
+  branchIdentification?: string
+
+  @Column({ nullable: true, comment: '사업자명' })
+  @Field({ nullable: true, description: '사업자명' })
+  businessName?: string
+
+  @Column({ nullable: true, comment: '대표자명' })
+  @Field({ nullable: true, description: '대표자명' })
+  representativeName?: string
+
+  @Column({ nullable: true, comment: '주소', transformer: encryptTransformer })
+  @Field({ nullable: true, description: '주소' })
+  address?: string
+
+  @Column({ nullable: true, comment: '업태' })
+  @Field({ nullable: true, description: '업태' })
+  businessType?: string
+
+  @Column({ nullable: true, comment: '업종' })
+  @Field({ nullable: true, description: '업종' })
+  industryType?: string
+
+  @Column({ nullable: true, comment: '담당 부서' })
+  @Field({ nullable: true, description: '담당 부서' })
+  department?: string
+
+  @Column({ nullable: true, comment: '담당자명', transformer: encryptTransformer })
+  @Field({ nullable: true, description: '담당자명' })
+  contactName?: string
+
+  @Column({ nullable: true, comment: '담당자 전화번호', transformer: encryptTransformer })
+  @Field({ nullable: true, description: '담당자 전화번호' })
+  contactPhone?: string
+
+  @Column({ nullable: true, comment: '담당자 이메일', transformer: encryptTransformer })
+  @Field({ nullable: true, description: '담당자 이메일' })
+  contactEmail?: string
+
+  @Column({ nullable: true, comment: '담당자 핸드폰 번호', transformer: encryptTransformer })
+  @Field({ nullable: true, description: '담당자 핸드폰 번호' })
+  contactCellPhone?: string
+
+  @Column('simple-json', { nullable: true })
+  @Field(type => ScalarObject, { nullable: true })
+  attributes?: any
+
+  @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((taxInvoiceApi: TaxInvoiceApi) => taxInvoiceApi.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((taxInvoiceApi: TaxInvoiceApi) => taxInvoiceApi.updater)
+  updaterId?: string
+}

package/server/service/tax-invoice-company/index.ts

@@ -0,0 +1,6 @@
+import { TaxInvoiceCompany } from './tax-invoice-company'
+import { TaxInvoiceCompanyQuery } from './tax-invoice-company-query'
+import { TaxInvoiceCompanyMutation } from './tax-invoice-company-mutation'
+
+export const entities = [TaxInvoiceCompany]
+export const resolvers = [TaxInvoiceCompanyQuery, TaxInvoiceCompanyMutation]

package/server/service/tax-invoice-company/tax-invoice-company-mutation.ts

@@ -0,0 +1,84 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { TaxInvoiceCompany } from './tax-invoice-company'
+import { TaxInvoiceCompanyPatch } from './tax-invoice-company-type'
+
+@Resolver(TaxInvoiceCompany)
+export class TaxInvoiceCompanyMutation {
+  @Directive('@transaction')
+  @Mutation(returns => [TaxInvoiceCompany], { description: "To modify multiple TaxInvoiceCompanies' information" })
+  async updateMultipleTaxInvoiceCompany(
+    @Arg('patches', type => [TaxInvoiceCompanyPatch]) patches: TaxInvoiceCompanyPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<TaxInvoiceCompany[]> {
+    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 taxInvoiceCompanyRepo = tx.getRepository(TaxInvoiceCompany)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await taxInvoiceCompanyRepo.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 taxInvoiceCompany = await taxInvoiceCompanyRepo.findOneBy({ id: updateRecord.id })
+
+        const result = await taxInvoiceCompanyRepo.save({
+          ...taxInvoiceCompany,
+          ...updateRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple TaxInvoiceCompanies' })
+  async deleteTaxInvoiceCompanies(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(TaxInvoiceCompany).delete({
+      domain: { id: domain.id },
+      id: In(ids)
+    })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To import multiple TaxInvoiceCompanies' })
+  async importTaxInvoiceCompanies(
+    @Arg('taxInvoiceCompanies', type => [TaxInvoiceCompanyPatch]) taxInvoiceCompanies: TaxInvoiceCompanyPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await Promise.all(
+      taxInvoiceCompanies.map(async (taxInvoiceCompany: TaxInvoiceCompanyPatch) => {
+        const createdTaxInvoiceCompany: TaxInvoiceCompany = await tx.getRepository(TaxInvoiceCompany).save({ domain, ...taxInvoiceCompany })
+      })
+    )
+
+    return true
+  }
+}

package/server/service/tax-invoice-company/tax-invoice-company-query.ts

@@ -0,0 +1,53 @@
+import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx } from 'type-graphql'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { TaxInvoiceCompany, companyTypeLabel } from './tax-invoice-company'
+import { TaxInvoiceCompanyList } from './tax-invoice-company-type'
+
+@Resolver(TaxInvoiceCompany)
+export class TaxInvoiceCompanyQuery {
+  @Query(returns => TaxInvoiceCompany!, { nullable: true, description: 'To fetch a Tax Invoice Company' })
+  async taxInvoiceCompany(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<TaxInvoiceCompany> {
+    const { domain } = context.state
+
+    return await getRepository(TaxInvoiceCompany).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Query(returns => TaxInvoiceCompanyList, { description: 'To fetch multiple Tax Invoice Companies' })
+  async taxInvoiceCompanies(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<TaxInvoiceCompanyList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: await getRepository(TaxInvoiceCompany),
+      searchables: ['name', 'description']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => String)
+  async convertedType(@Root() taxInvoiceCompany: TaxInvoiceCompany): Promise<string> {
+    return companyTypeLabel[taxInvoiceCompany.type]
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() taxInvoiceCompany: TaxInvoiceCompany): Promise<Domain> {
+    return taxInvoiceCompany.domainId && (await getRepository(Domain).findOneBy({ id: taxInvoiceCompany.domainId }))
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() taxInvoiceCompany: TaxInvoiceCompany): Promise<User> {
+    return taxInvoiceCompany.updaterId && (await getRepository(User).findOneBy({ id: taxInvoiceCompany.updaterId }))
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() taxInvoiceCompany: TaxInvoiceCompany): Promise<User> {
+    return taxInvoiceCompany.creatorId && (await getRepository(User).findOneBy({ id: taxInvoiceCompany.creatorId }))
+  }
+}

package/server/service/tax-invoice-company/tax-invoice-company-type.ts

@@ -0,0 +1,69 @@
+import { ObjectType, Field, InputType, Int, ID } from 'type-graphql'
+import { ScalarObject } from '@things-factory/shell'
+import { CompanyType, TaxInvoiceCompany } from './tax-invoice-company'
+
+@InputType()
+export class TaxInvoiceCompanyPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  type?: CompanyType
+
+  @Field({ nullable: true })
+  businessRegistrationNumber?: string
+
+  @Field({ nullable: true })
+  branchIdentification?: string
+
+  @Field({ nullable: true })
+  businessName?: string
+
+  @Field({ nullable: true })
+  representativeName?: string
+
+  @Field({ nullable: true })
+  address?: string
+
+  @Field({ nullable: true })
+  businessType?: string
+
+  @Field({ nullable: true })
+  industryType?: string
+
+  @Field({ nullable: true })
+  department?: string
+
+  @Field({ nullable: true })
+  contactName?: string
+
+  @Field({ nullable: true })
+  contactPhone?: string
+
+  @Field({ nullable: true })
+  contactEmail?: string
+
+  @Field({ nullable: true })
+  contactCellPhone?: string
+
+  @Field(type => ScalarObject, { nullable: true })
+  attributes?: any
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@ObjectType()
+export class TaxInvoiceCompanyList {
+  @Field(type => [TaxInvoiceCompany])
+  items: TaxInvoiceCompany[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/tax-invoice-company/tax-invoice-company.ts

@@ -0,0 +1,142 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  DeleteDateColumn,
+  Index,
+  Entity,
+  OneToOne,
+  Column,
+  RelationId,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  VersionColumn
+} from 'typeorm'
+import { ObjectType, Field, ID, registerEnumType } from 'type-graphql'
+
+import { Domain, ScalarObject, encryptTransformer } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { TaxInvoiceApi } from '../tax-invoice-api/tax-invoice-api'
+
+export enum CompanyType {
+  SUPPLIER = 10, // 공급자
+  BUYER = 20 // 거래처
+}
+export const companyTypeLabel = {
+  [CompanyType.SUPPLIER]: '공급자',
+  [CompanyType.BUYER]: '거래처'
+}
+registerEnumType(CompanyType, {
+  name: 'CompanyType',
+  description: 'company type'
+})
+
+@Entity()
+@Index('ix_tax_invoice_company_0', (taxInvoiceCompany: TaxInvoiceCompany) => [taxInvoiceCompany.domain, taxInvoiceCompany.name, taxInvoiceCompany.deletedAt])
+@Index('ix_tax_invoice_company_1', (taxInvoiceCompany: TaxInvoiceCompany) => [taxInvoiceCompany.domain, taxInvoiceCompany.description, taxInvoiceCompany.deletedAt])
+@ObjectType({ description: 'Entity for TaxInvoice Company' })
+export class TaxInvoiceCompany {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id!: string
+
+  @VersionColumn()
+  @Field({ nullable: true })
+  version?: number = 1
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((taxInvoiceCompany: TaxInvoiceCompany) => taxInvoiceCompany.domain)
+  domainId?: string
+
+  @Field({ nullable: false })
+  @Column({ nullable: false })
+  name!: string
+
+  @Field({ nullable: true })
+  @Column({ nullable: true })
+  description?: string
+
+  @Field({ nullable: false })
+  @Column({ nullable: false })
+  type!: CompanyType
+
+  @Column({ nullable: true, comment: '사업자등록번호', transformer: encryptTransformer })
+  @Field({ nullable: true, description: '사업자등록번호' })
+  businessRegistrationNumber?: string
+
+  @Column({ nullable: true, comment: '종사업장 식별 코드' })
+  @Field({ nullable: true, description: '종사업장 식별 코드' })
+  branchIdentification?: string
+
+  @Column({ nullable: true, comment: '사업자명' })
+  @Field({ nullable: true, description: '사업자명' })
+  businessName?: string
+
+  @Column({ nullable: true, comment: '대표자명' })
+  @Field({ nullable: true, description: '대표자명' })
+  representativeName?: string
+
+  @Column({ nullable: true, comment: '주소', transformer: encryptTransformer })
+  @Field({ nullable: true, description: '주소' })
+  address?: string
+
+  @Column({ nullable: true, comment: '업태' })
+  @Field({ nullable: true, description: '업태' })
+  businessType?: string
+
+  @Column({ nullable: true, comment: '업종' })
+  @Field({ nullable: true, description: '업종' })
+  industryType?: string
+
+  @Column({ nullable: true, comment: '담당 부서' })
+  @Field({ nullable: true, description: '담당 부서' })
+  department?: string
+
+  @Column({ nullable: true, comment: '담당자명', transformer: encryptTransformer })
+  @Field({ nullable: true, description: '담당자명' })
+  contactName?: string
+
+  @Column({ nullable: true, comment: '담당자 전화번호', transformer: encryptTransformer })
+  @Field({ nullable: true, description: '담당자 전화번호' })
+  contactPhone?: string
+
+  @Column({ nullable: true, comment: '담당자 이메일', transformer: encryptTransformer })
+  @Field({ nullable: true, description: '담당자 이메일' })
+  contactEmail?: string
+
+  @Column({ nullable: true, comment: '담당자 핸드폰 번호', transformer: encryptTransformer })
+  @Field({ nullable: true, description: '담당자 핸드폰 번호' })
+  contactCellPhone?: string
+
+  @Column('simple-json', { nullable: true })
+  @Field(type => ScalarObject, { nullable: true })
+  attributes?: any
+
+  @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((taxInvoiceCompany: TaxInvoiceCompany) => taxInvoiceCompany.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((taxInvoiceCompany: TaxInvoiceCompany) => taxInvoiceCompany.updater)
+  updaterId?: string
+}

package/server/service/tax-invoice-item/index.ts

@@ -0,0 +1,6 @@
+import { TaxInvoiceItem } from './tax-invoice-item'
+import { TaxInvoiceItemQuery } from './tax-invoice-item-query'
+import { TaxInvoiceItemMutation } from './tax-invoice-item-mutation'
+
+export const entities = [TaxInvoiceItem]
+export const resolvers = [TaxInvoiceItemQuery, TaxInvoiceItemMutation]

package/server/service/tax-invoice-item/tax-invoice-item-mutation.ts

@@ -0,0 +1,128 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { TaxInvoiceItem } from './tax-invoice-item'
+import { NewTaxInvoiceItem, TaxInvoiceItemPatch } from './tax-invoice-item-type'
+
+@Resolver(TaxInvoiceItem)
+export class TaxInvoiceItemMutation {
+  @Directive('@transaction')
+  @Mutation(returns => TaxInvoiceItem, { description: 'To create new TaxInvoiceItem' })
+  async createTaxInvoiceItem(@Arg('taxInvoiceItem') taxInvoiceItem: NewTaxInvoiceItem, @Ctx() context: ResolverContext): Promise<TaxInvoiceItem> {
+    const { domain, user, tx } = context.state
+
+    const result = await tx.getRepository(TaxInvoiceItem).save({
+      ...taxInvoiceItem,
+      domain,
+      creator: user,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => TaxInvoiceItem, { description: 'To modify TaxInvoiceItem information' })
+  async updateTaxInvoiceItem(@Arg('id') id: string, @Arg('patch') patch: TaxInvoiceItemPatch, @Ctx() context: ResolverContext): Promise<TaxInvoiceItem> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(TaxInvoiceItem)
+    const taxInvoiceItem = await repository.findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+
+    const result = await repository.save({
+      ...taxInvoiceItem,
+      ...patch,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [TaxInvoiceItem], { description: "To modify multiple TaxInvoiceItems' information" })
+  async updateMultipleTaxInvoiceItem(
+    @Arg('patches', type => [TaxInvoiceItemPatch]) patches: TaxInvoiceItemPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<TaxInvoiceItem[]> {
+    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 taxInvoiceItemRepo = tx.getRepository(TaxInvoiceItem)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await taxInvoiceItemRepo.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 taxInvoiceItem = await taxInvoiceItemRepo.findOneBy({ id: updateRecord.id })
+
+        const result = await taxInvoiceItemRepo.save({
+          ...taxInvoiceItem,
+          ...updateRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete TaxInvoiceItem' })
+  async deleteTaxInvoiceItem(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(TaxInvoiceItem).delete({ domain: { id: domain.id }, id })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple TaxInvoiceItems' })
+  async deleteTaxInvoiceItems(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(TaxInvoiceItem).delete({
+      domain: { id: domain.id },
+      id: In(ids)
+    })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To import multiple TaxInvoiceItems' })
+  async importTaxInvoiceItems(
+    @Arg('taxInvoiceItems', type => [TaxInvoiceItemPatch]) taxInvoiceItems: TaxInvoiceItemPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await Promise.all(
+      taxInvoiceItems.map(async (taxInvoiceItem: TaxInvoiceItemPatch) => {
+        const createdTaxInvoiceItem: TaxInvoiceItem = await tx.getRepository(TaxInvoiceItem).save({ domain, ...taxInvoiceItem })
+      })
+    )
+
+    return true
+  }
+}

package/server/service/tax-invoice-item/tax-invoice-item-query.ts

@@ -0,0 +1,57 @@
+import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
+import { Attachment } from '@things-factory/attachment-base'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { TaxInvoiceItem } from './tax-invoice-item'
+import { TaxInvoiceItemList } from './tax-invoice-item-type'
+
+@Resolver(TaxInvoiceItem)
+export class TaxInvoiceItemQuery {
+  @Query(returns => TaxInvoiceItem!, { nullable: true, description: 'To fetch a TaxInvoiceItem' })
+  async taxInvoiceItem(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<TaxInvoiceItem> {
+    const { domain } = context.state
+
+    return await getRepository(TaxInvoiceItem).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Query(returns => TaxInvoiceItemList, { description: 'To fetch multiple TaxInvoiceItems' })
+  async taxInvoiceItems(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<TaxInvoiceItemList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: await getRepository(TaxInvoiceItem),
+      searchables: ['name', 'description']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => String)
+  async thumbnail(@Root() taxInvoiceItem: TaxInvoiceItem): Promise<string | undefined> {
+    const attachment: Attachment = await getRepository(Attachment).findOne({
+      where: {
+        domain: { id: taxInvoiceItem.domainId },
+        refType: TaxInvoiceItem.name,
+        refBy: taxInvoiceItem.id
+      }
+    })
+
+    return attachment?.fullpath
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() taxInvoiceItem: TaxInvoiceItem): Promise<Domain> {
+    return taxInvoiceItem.domainId && (await getRepository(Domain).findOneBy({ id: taxInvoiceItem.domainId }))
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() taxInvoiceItem: TaxInvoiceItem): Promise<User> {
+    return taxInvoiceItem.creatorId && (await getRepository(User).findOneBy({ id: taxInvoiceItem.creatorId }))
+  }
+}