@things-factory/accounting 8.0.0-beta.1 → 8.0.0-beta.2

package/server/service/bank-account/bank-account-mutation.ts

@@ -1,137 +0,0 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-import { In } from 'typeorm'
-import { getRepository } from '@things-factory/shell'
-
-import { BankAccount } from './bank-account'
-import { NewBankAccount, BankAccountPatch } from './bank-account-type'
-
-@Resolver(BankAccount)
-export class BankAccountMutation {
-  @Directive('@transaction')
-  @Mutation(returns => BankAccount, { description: 'To create new BankAccount' })
-  async createBankAccount(@Arg('bankAccount') bankAccount: NewBankAccount, @Ctx() context: ResolverContext): Promise<BankAccount> {
-    const { domain, user, tx } = context.state
-
-    const result = await getRepository(BankAccount, tx).save({
-      ...bankAccount,
-      domain,
-      creator: user,
-      updater: user
-    })
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => BankAccount, { description: 'To modify BankAccount information' })
-  async updateBankAccount(
-    @Arg('id') id: string,
-    @Arg('patch') patch: BankAccountPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<BankAccount> {
-    const { domain, user, tx } = context.state
-
-    const repository = getRepository(BankAccount, tx)
-    const bankAccount = await repository.findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-
-    const result = await repository.save({
-      ...bankAccount,
-      ...patch,
-      updater: user
-    })
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [BankAccount], { description: "To modify multiple BankAccounts' information" })
-  async updateMultipleBankAccount(
-    @Arg('patches', type => [BankAccountPatch]) patches: BankAccountPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<BankAccount[]> {
-    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 bankAccountRepo = getRepository(BankAccount, tx)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await bankAccountRepo.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 bankAccount = await bankAccountRepo.findOneBy({ id: updateRecord.id })
-
-        const result = await bankAccountRepo.save({
-          ...bankAccount,
-          ...updateRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete BankAccount' })
-  async deleteBankAccount(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await getRepository(BankAccount, tx).delete({ domain: { id: domain.id }, id })
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple BankAccounts' })
-  async deleteBankAccounts(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await getRepository(BankAccount, tx).delete({
-      domain: { id: domain.id },
-      id: In(ids)
-    })
-
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To import multiple BankAccounts' })
-  async importBankAccounts(
-    @Arg('bankAccounts', type => [BankAccountPatch]) bankAccounts: BankAccountPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await Promise.all(
-      bankAccounts.map(async (bankAccount: BankAccountPatch) => {
-        const createdBankAccount: BankAccount = await getRepository(BankAccount, tx).save({ domain, ...bankAccount })
-      })
-    )
-
-    return true
-  }
-}

package/server/service/bank-account/bank-account-query.ts

@@ -1,48 +0,0 @@
-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 { BankAccount } from './bank-account'
-import { BankAccountList } from './bank-account-type'
-
-@Resolver(BankAccount)
-export class BankAccountQuery {
-  @Query(returns => BankAccount!, { nullable: true, description: 'To fetch a BankAccount' })
-  async bankAccount(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<BankAccount> {
-    const { domain } = context.state
-
-    return await getRepository(BankAccount).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @Query(returns => BankAccountList, { description: 'To fetch multiple BankAccounts' })
-  async bankAccounts(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<BankAccountList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      domain,
-      params,
-      repository: await getRepository(BankAccount),
-      searchables: ['name', 'description']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() bankAccount: BankAccount): Promise<Domain> {
-    return bankAccount.domainId && (await getRepository(Domain).findOneBy({ id: bankAccount.domainId }))
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() bankAccount: BankAccount): Promise<User> {
-    return bankAccount.updaterId && (await getRepository(User).findOneBy({ id: bankAccount.updaterId }))
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() bankAccount: BankAccount): Promise<User> {
-    return bankAccount.creatorId && (await getRepository(User).findOneBy({ id: bankAccount.creatorId }))
-  }
-}

package/server/service/bank-account/bank-account-type.ts

@@ -1,112 +0,0 @@
-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 { AccountType, BankAccount, OwnerType } from './bank-account'
-
-@InputType()
-export class NewBankAccount {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true, description: 'Name of the account holder' })
-  accountHolderName?: string // 계좌 소유자의 이름
-
-  @Field({ nullable: true, description: 'Bank account number' })
-  accountNumber?: string
-
-  @Field({ nullable: true, description: 'Bank name' })
-  bankName?: string
-
-  @Field(type => AccountType, { description: 'Type of the account (Bank or Card)' })
-  accountType: AccountType
-
-  @Field({ nullable: true, description: 'Currency of the account' })
-  currency?: string
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field(type => OwnerType, { description: 'Type of the owner of the bank account' })
-  ownerType: OwnerType
-
-  @Field({ description: 'ID of the owner of the bank account' })
-  ownerId: string
-
-  @Field({ nullable: true, description: 'IBAN of the bank account' })
-  iban?: string // 은행 계좌의 IBAN
-
-  @Field({ nullable: true, description: 'BIC of the bank account' })
-  bic?: string // 은행 계좌의 BIC
-
-  @Field({ nullable: true, description: 'Country of the bank account' })
-  country?: string // 은행 계좌의 국적
-
-  @Field({ nullable: true, description: 'Cover image of the bank account' })
-  image?: string // 은행 계좌의 커버이미지
-}
-
-@InputType()
-export class BankAccountPatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true, description: 'Name of the account holder' })
-  accountHolderName?: string // 계좌 소유자의 이름
-
-  @Field({ nullable: true, description: 'Bank account number' })
-  accountNumber?: string
-
-  @Field({ nullable: true, description: 'Bank name' })
-  bankName?: string
-
-  @Field(type => AccountType, { description: 'Type of the account (Bank or Card)' })
-  accountType: AccountType
-
-  @Field({ nullable: true, description: 'Currency of the account' })
-  currency?: string
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field(type => OwnerType, { description: 'Type of the owner of the bank account' })
-  ownerType: OwnerType
-
-  @Field({ description: 'ID of the owner of the bank account' })
-  ownerId: string
-
-  @Field({ nullable: true, description: 'IBAN of the bank account' })
-  iban?: string // 은행 계좌의 IBAN
-
-  @Field({ nullable: true, description: 'BIC of the bank account' })
-  bic?: string // 은행 계좌의 BIC
-
-  @Field({ nullable: true, description: 'Country of the bank account' })
-  country?: string // 은행 계좌의 국적
-
-  @Field({ nullable: true, description: 'Cover image of the bank account' })
-  image?: string // 은행 계좌의 커버이미지
-
-  @Field({ nullable: true })
-  cuFlag?: string
-}
-
-@ObjectType()
-export class BankAccountList {
-  @Field(type => [BankAccount])
-  items: BankAccount[]
-
-  @Field(type => Int)
-  total: number
-}

package/server/service/bank-account/bank-account.ts

@@ -1,142 +0,0 @@
-import {
-  CreateDateColumn,
-  UpdateDateColumn,
-  DeleteDateColumn,
-  Entity,
-  Index,
-  Column,
-  RelationId,
-  ManyToOne,
-  VersionColumn,
-  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'
-
-export enum AccountType {
-  Bank = 'Bank',
-  Card = 'Card'
-}
-
-registerEnumType(AccountType, {
-  name: 'AccountType',
-  description: 'Type of the account (Bank or Card)'
-})
-
-export enum OwnerType {
-  Company = 'Company',
-  Vendor = 'Vendor',
-  Employee = 'Employee'
-}
-
-registerEnumType(OwnerType, {
-  name: 'OwnerType',
-  description: 'Type of the owner of the bank account'
-})
-
-@Entity()
-@Index('ix_bank_account_0', (bankAccount: BankAccount) => [bankAccount.domain, bankAccount.name], {
-  where: '"deleted_at" IS NULL',
-  unique: true
-})
-@ObjectType({ description: 'Entity for BankAccount' })
-export class BankAccount {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @VersionColumn()
-  @Field({ nullable: true })
-  version?: number = 1
-
-  @ManyToOne(type => Domain)
-  @Field({ nullable: true })
-  domain?: Domain
-
-  @RelationId((bankAccount: BankAccount) => bankAccount.domain)
-  domainId?: string
-
-  @Column()
-  @Field({ nullable: true })
-  name?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  description?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Name of the account holder' })
-  accountHolderName?: string // 계좌 소유자의 이름
-
-  @Column()
-  @Field({ nullable: true, description: 'Bank account number' })
-  accountNumber?: string
-
-  @Column()
-  @Field({ nullable: true, description: 'Bank name' })
-  bankName?: string
-
-  @Column({ type: 'enum', enum: AccountType })
-  @Field(type => AccountType, { description: 'Type of the account (Bank or Card)' })
-  accountType: AccountType
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Currency of the account' })
-  currency?: string
-
-  @Column({ nullable: false, default: false })
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Column({ type: 'enum', enum: OwnerType })
-  @Field(type => OwnerType, { description: 'Type of the owner of the bank account' })
-  ownerType: OwnerType
-
-  @Column()
-  @Field({ description: 'ID of the owner of the bank account' })
-  ownerId: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'IBAN of the bank account' })
-  iban?: string // 은행 계좌의 IBAN
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'BIC of the bank account' })
-  bic?: string // 은행 계좌의 BIC
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Country of the bank account' })
-  country?: string // 은행 계좌의 국적
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Cover image of the bank account' })
-  image?: string // 은행 계좌의 커버이미지
-
-  @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((bankAccount: BankAccount) => bankAccount.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((bankAccount: BankAccount) => bankAccount.updater)
-  updaterId?: string
-}

package/server/service/bank-account/event-subscriber.ts

@@ -1,17 +0,0 @@
-import { EventSubscriber } from 'typeorm'
-
-import { HistoryEntitySubscriber } from '@operato/typeorm-history'
-
-import { BankAccount } from './bank-account'
-import { BankAccountHistory } from './bank-account-history'
-
-@EventSubscriber()
-export class BankAccountHistoryEntitySubscriber extends HistoryEntitySubscriber<BankAccount, BankAccountHistory> {
-  public get entity() {
-    return BankAccount
-  }
-
-  public get historyEntity() {
-    return BankAccountHistory
-  }
-}

package/server/service/bank-account/index.ts

@@ -1,9 +0,0 @@
-import { BankAccount } from './bank-account'
-import { BankAccountHistory } from './bank-account-history'
-import { BankAccountHistoryEntitySubscriber } from './event-subscriber'
-import { BankAccountQuery } from './bank-account-query'
-import { BankAccountMutation } from './bank-account-mutation'
-
-export const entities = [BankAccount, BankAccountHistory]
-export const resolvers = [BankAccountQuery, BankAccountMutation]
-export const subscribers = [BankAccountHistoryEntitySubscriber]

package/server/service/common-type.ts

@@ -1,12 +0,0 @@
-import { registerEnumType } from 'type-graphql'
-
-export enum FiscalStatus {
-  OPEN = 'OPEN',
-  CLOSED = 'CLOSED',
-  FINALIZED = 'FINALIZED'
-}
-
-registerEnumType(FiscalStatus, {
-  name: 'FiscalStatus',
-  description: 'The status of a fiscal period (OPEN, CLOSED, FINALIZED)'
-})

package/server/service/financial-institution/financial-institution-mutation.ts

@@ -1,198 +0,0 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-import { In } from 'typeorm'
-import { getRepository } from '@things-factory/shell'
-
-import { createAttachment, deleteAttachmentsByRef } from '@things-factory/attachment-base'
-import { FinancialInstitution } from './financial-institution'
-import { NewFinancialInstitution, FinancialInstitutionPatch } from './financial-institution-type'
-
-@Resolver(FinancialInstitution)
-export class FinancialInstitutionMutation {
-  @Directive('@transaction')
-  @Mutation(returns => FinancialInstitution, { description: 'To create new FinancialInstitution' })
-  async createFinancialInstitution(@Arg('financialInstitution') financialInstitution: NewFinancialInstitution, @Ctx() context: ResolverContext): Promise<FinancialInstitution> {
-    const { domain, user, tx } = context.state
-
-    const result = await getRepository(FinancialInstitution, tx).save({
-      ...financialInstitution,
-      domain,
-      creator: user,
-      updater: user
-    })
-
-    if (financialInstitution.thumbnail) {
-      await createAttachment(
-        null,
-        {
-          attachment: {
-            file: financialInstitution.thumbnail,
-            refType: FinancialInstitution.name,
-            refBy: result.id
-          }
-        },
-        context
-      )
-    }
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => FinancialInstitution, { description: 'To modify FinancialInstitution information' })
-  async updateFinancialInstitution(
-    @Arg('id') id: string,
-    @Arg('patch') patch: FinancialInstitutionPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<FinancialInstitution> {
-    const { domain, user, tx } = context.state
-
-    const repository = getRepository(FinancialInstitution, tx)
-    const financialInstitution = await repository.findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-
-    const result = await repository.save({
-      ...financialInstitution,
-      ...patch,
-      updater: user
-    })
-
-    if (patch.thumbnail) {
-      await deleteAttachmentsByRef(null, { refBys: [result.id] }, context)
-      await createAttachment(
-        null,
-        {
-          attachment: {
-            file: patch.thumbnail,
-            refType: FinancialInstitution.name,
-            refBy: result.id
-          }
-        },
-        context
-      )
-    }
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [FinancialInstitution], { description: "To modify multiple FinancialInstitutions' information" })
-  async updateMultipleFinancialInstitution(
-    @Arg('patches', type => [FinancialInstitutionPatch]) patches: FinancialInstitutionPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<FinancialInstitution[]> {
-    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 financialInstitutionRepo = getRepository(FinancialInstitution, tx)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await financialInstitutionRepo.save({
-          ...newRecord,
-          domain,
-          creator: user,
-          updater: user
-        })
-
-        if (newRecord.thumbnail) {
-          await createAttachment(
-            null,
-            {
-              attachment: {
-                file: newRecord.thumbnail,
-                refType: FinancialInstitution.name,
-                refBy: result.id
-              }
-            },
-            context
-          )
-        }
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const updateRecord = _updateRecords[i]
-        const financialInstitution = await financialInstitutionRepo.findOneBy({ id: updateRecord.id })
-
-        const result = await financialInstitutionRepo.save({
-          ...financialInstitution,
-          ...updateRecord,
-          updater: user
-        })
-
-        if (updateRecord.thumbnail) {
-          await deleteAttachmentsByRef(null, { refBys: [result.id] }, context)
-          await createAttachment(
-            null,
-            {
-              attachment: {
-                file: updateRecord.thumbnail,
-                refType: FinancialInstitution.name,
-                refBy: result.id
-              }
-            },
-            context
-          )
-        }
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete FinancialInstitution' })
-  async deleteFinancialInstitution(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await getRepository(FinancialInstitution, tx).delete({ domain: { id: domain.id }, id })
-    await deleteAttachmentsByRef(null, { refBys: [id] }, context)
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple FinancialInstitutions' })
-  async deleteFinancialInstitutions(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await getRepository(FinancialInstitution, tx).delete({
-      domain: { id: domain.id },
-      id: In(ids)
-    })
-
-    await deleteAttachmentsByRef(null, { refBys: ids }, context)
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To import multiple FinancialInstitutions' })
-  async importFinancialInstitutions(
-    @Arg('financialInstitutions', type => [FinancialInstitutionPatch]) financialInstitutions: FinancialInstitutionPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await Promise.all(
-      financialInstitutions.map(async (financialInstitution: FinancialInstitutionPatch) => {
-        const createdFinancialInstitution: FinancialInstitution = await getRepository(FinancialInstitution, tx).save({ domain, ...financialInstitution })
-      })
-    )
-
-    return true
-  }
-}