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

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

@@ -1,62 +0,0 @@
-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 { FinancialInstitution } from './financial-institution'
-import { FinancialInstitutionList } from './financial-institution-type'
-
-@Resolver(FinancialInstitution)
-export class FinancialInstitutionQuery {
-  @Query(returns => FinancialInstitution!, { nullable: true, description: 'To fetch a FinancialInstitution' })
-  async financialInstitution(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<FinancialInstitution> {
-    const { domain } = context.state
-
-    return await getRepository(FinancialInstitution).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @Query(returns => FinancialInstitutionList, { description: 'To fetch multiple FinancialInstitutions' })
-  async financialInstitutions(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<FinancialInstitutionList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      domain,
-      params,
-      repository: await getRepository(FinancialInstitution),
-      searchables: ['name', 'description']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => String)
-  async thumbnail(@Root() financialInstitution: FinancialInstitution): Promise<string | undefined> {
-    const attachment: Attachment = await getRepository(Attachment).findOne({
-      where: {
-        domain: { id: financialInstitution.domainId },
-        refType: FinancialInstitution.name,
-        refBy: financialInstitution.id
-      }
-    })
-
-    return attachment?.fullpath
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() financialInstitution: FinancialInstitution): Promise<Domain> {
-    return financialInstitution.domainId && (await getRepository(Domain).findOneBy({ id: financialInstitution.domainId }))
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() financialInstitution: FinancialInstitution): Promise<User> {
-    return financialInstitution.updaterId && (await getRepository(User).findOneBy({ id: financialInstitution.updaterId }))
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() financialInstitution: FinancialInstitution): Promise<User> {
-    return financialInstitution.creatorId && (await getRepository(User).findOneBy({ id: financialInstitution.creatorId }))
-  }
-}

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

@@ -1,91 +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 { FinancialInstitution, FinancialInstitutionType } from './financial-institution'
-
-@InputType()
-export class NewFinancialInstitution {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field(type => FinancialInstitutionType, {
-    description: 'Type of the financial institution (e.g., Bank, Card Company, Insurance Company, etc.)'
-  })
-  type: FinancialInstitutionType
-
-  @Field({ nullable: true, description: 'SWIFT code of the bank (if applicable)' })
-  swiftCode?: string
-
-  @Field({ nullable: true, description: 'Country of the financial institution' })
-  country?: string
-
-  @Field({ nullable: true, description: 'Contact number of the financial institution' })
-  contactNumber?: string
-
-  @Field({ nullable: true, description: 'Website of the financial institution' })
-  website?: string
-
-  @Field({ nullable: true, description: 'Address of the financial institution' })
-  address?: string
-
-  @Field({ nullable: true, description: 'Email of the financial institution' })
-  email?: string
-
-  @Field(type => GraphQLUpload, { nullable: true })
-  thumbnail?: FileUpload
-}
-
-@InputType()
-export class FinancialInstitutionPatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field(type => FinancialInstitutionType, {
-    description: 'Type of the financial institution (e.g., Bank, Card Company, Insurance Company, etc.)'
-  })
-  type: FinancialInstitutionType
-
-  @Field({ nullable: true, description: 'SWIFT code of the bank (if applicable)' })
-  swiftCode?: string
-
-  @Field({ nullable: true, description: 'Country of the financial institution' })
-  country?: string
-
-  @Field({ nullable: true, description: 'Contact number of the financial institution' })
-  contactNumber?: string
-
-  @Field({ nullable: true, description: 'Website of the financial institution' })
-  website?: string
-
-  @Field({ nullable: true, description: 'Address of the financial institution' })
-  address?: string
-
-  @Field({ nullable: true, description: 'Email of the financial institution' })
-  email?: string
-  @Field(type => GraphQLUpload, { nullable: true })
-  thumbnail?: FileUpload
-
-  @Field({ nullable: true })
-  cuFlag?: string
-}
-
-@ObjectType()
-export class FinancialInstitutionList {
-  @Field(type => [FinancialInstitution])
-  items: FinancialInstitution[]
-
-  @Field(type => Int)
-  total: number
-}

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

@@ -1,122 +0,0 @@
-import {
-  CreateDateColumn,
-  UpdateDateColumn,
-  DeleteDateColumn,
-  Entity,
-  Index,
-  Column,
-  RelationId,
-  ManyToOne,
-  PrimaryGeneratedColumn,
-  VersionColumn
-} from 'typeorm'
-import { ObjectType, Field, ID, registerEnumType } from 'type-graphql'
-import { Domain } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-
-export enum FinancialInstitutionType {
-  Bank = 'Bank',
-  CardCompany = 'CardCompany',
-  InsuranceCompany = 'InsuranceCompany',
-  InvestmentCompany = 'InvestmentCompany',
-  SavingsBank = 'SavingsBank',
-  CreditUnion = 'CreditUnion',
-  LoanCompany = 'LoanCompany',
-  SecuritiesFirm = 'SecuritiesFirm'
-}
-
-registerEnumType(FinancialInstitutionType, {
-  name: 'FinancialInstitutionType',
-  description: 'Type of the financial institution (e.g., Bank, Card Company, Insurance Company, etc.)'
-})
-
-@Entity()
-@Index(
-  'ix_financial_institution_0',
-  (financialInstitution: FinancialInstitution) => [financialInstitution.domain, financialInstitution.name],
-  {
-    where: '"deleted_at" IS NULL',
-    unique: true
-  }
-)
-@ObjectType({ description: 'Entity for Financial Institution (e.g., Bank, Card Company, Insurance Company, etc.)' })
-export class FinancialInstitution {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field({ nullable: true })
-  domain?: Domain
-
-  @RelationId((financialInstitution: FinancialInstitution) => financialInstitution.domain)
-  domainId?: string
-
-  @Column()
-  @Field({ nullable: true })
-  name?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  description?: string
-
-  @Column({ type: 'enum', enum: FinancialInstitutionType })
-  @Field(type => FinancialInstitutionType, {
-    description: 'Type of the financial institution (e.g., Bank, Card Company, Insurance Company, etc.)'
-  })
-  type?: FinancialInstitutionType
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'SWIFT code of the bank (if applicable)' })
-  swiftCode?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Country of the financial institution' })
-  country?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Contact number of the financial institution' })
-  contactNumber?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Website of the financial institution' })
-  website?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Address of the financial institution' })
-  address?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Email of the financial institution' })
-  email?: 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((financialInstitution: FinancialInstitution) => financialInstitution.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((financialInstitution: FinancialInstitution) => financialInstitution.updater)
-  updaterId?: string
-
-  @VersionColumn()
-  @Field({ nullable: true })
-  version?: number = 1
-}

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

@@ -1,7 +0,0 @@
-import { FinancialInstitution } from './financial-institution'
-import { FinancialInstitutionQuery } from './financial-institution-query'
-import { FinancialInstitutionMutation } from './financial-institution-mutation'
-
-export const entities = [FinancialInstitution]
-export const resolvers = [FinancialInstitutionQuery, FinancialInstitutionMutation]
-export const subscribers = []

package/server/service/financial-statement/event-subscriber.ts

@@ -1,17 +0,0 @@
-import { EventSubscriber } from 'typeorm'
-
-import { HistoryEntitySubscriber } from '@operato/typeorm-history'
-
-import { FinancialStatement } from './financial-statement'
-import { FinancialStatementHistory } from './financial-statement-history'
-
-@EventSubscriber()
-export class FinancialStatementHistoryEntitySubscriber extends HistoryEntitySubscriber<FinancialStatement, FinancialStatementHistory> {
-  public get entity() {
-    return FinancialStatement
-  }
-
-  public get historyEntity() {
-    return FinancialStatementHistory
-  }
-}

package/server/service/financial-statement/financial-statement-history.ts

@@ -1,129 +0,0 @@
-import { Field, ID, ObjectType } from 'type-graphql'
-import { Column, Entity, Index, ManyToOne, OneToMany, PrimaryGeneratedColumn, RelationId } from 'typeorm'
-
-import {
-  HistoryActionColumn,
-  HistoryActionType,
-  HistoryEntityInterface,
-  HistoryOriginalIdColumn
-} from '@operato/typeorm-history'
-import { Role, User } from '@things-factory/auth-base'
-import { config } from '@things-factory/env'
-import { Domain } from '@things-factory/shell'
-
-import { FinancialStatement } from './financial-statement'
-import { FinancialStatementLineItem } from './financial-statement-line-item'
-
-const ORMCONFIG = config.get('ormconfig', {})
-const DATABASE_TYPE = ORMCONFIG.type
-
-@Entity()
-@Index(
-  'ix_financial-statement_history_0',
-  (financialStatementHistory: FinancialStatementHistory) => [
-    financialStatementHistory.originalId,
-    financialStatementHistory.version
-  ],
-  { unique: true }
-)
-@Index(
-  'ix_financial-statement_history_1',
-  (financialStatementHistory: FinancialStatementHistory) => [
-    financialStatementHistory.domain,
-    financialStatementHistory.originalId,
-    financialStatementHistory.version
-  ],
-  { unique: true }
-)
-@ObjectType({ description: 'History Entity of FinancialStatement' })
-export class FinancialStatementHistory implements HistoryEntityInterface<FinancialStatement> {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @Column({ nullable: true, default: 1 })
-  @Field({ nullable: true })
-  version?: number = 1
-
-  @ManyToOne(type => Domain)
-  @Field({ nullable: true })
-  domain?: Domain
-
-  @RelationId((financialStatementHistory: FinancialStatementHistory) => financialStatementHistory.domain)
-  domainId?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Fiscal year of the financial statement' })
-  year?: number // 회계 연도
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Fiscal quarter of the financial statement' })
-  quarter?: number // 회계 분기
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Fiscal month of the financial statement' })
-  month?: number // 회계 월
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Total assets recorded in the financial statement' })
-  asset?: number // 재무제표에 기록된 총자산
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Total liabilities recorded in the financial statement' })
-  liability?: number // 재무제표에 기록된 총부채
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Total equity recorded in the financial statement' })
-  equity?: number // 재무제표에 기록된 총자본
-
-  @OneToMany(type => FinancialStatementLineItem, lineItem => lineItem.statement)
-  @Field(type => [FinancialStatementLineItem], { nullable: true })
-  lineItems?: FinancialStatementLineItem[] // 계정별 브레이크다운
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  updatedAt?: Date
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  deletedAt?: Date
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field({ nullable: true })
-  creator?: User
-
-  @RelationId((financialStatementHistory: FinancialStatementHistory) => financialStatementHistory.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field({ nullable: true })
-  updater?: User
-
-  @RelationId((financialStatementHistory: FinancialStatementHistory) => financialStatementHistory.updater)
-  updaterId?: string
-
-  @HistoryOriginalIdColumn()
-  public originalId!: string
-
-  @HistoryActionColumn({
-    nullable: false,
-    type:
-      DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
-        ? 'enum'
-        : DATABASE_TYPE == 'oracle'
-          ? 'varchar2'
-          : DATABASE_TYPE == 'mssql'
-            ? 'nvarchar'
-            : 'varchar',
-    enum:
-      DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
-        ? HistoryActionType
-        : undefined,
-    length: DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb' ? undefined : 10
-  })
-  public action!: HistoryActionType
-}

package/server/service/financial-statement/financial-statement-line-item.ts

@@ -1,82 +0,0 @@
-import {
-  CreateDateColumn,
-  UpdateDateColumn,
-  DeleteDateColumn,
-  Entity,
-  Index,
-  Column,
-  RelationId,
-  ManyToOne,
-  PrimaryGeneratedColumn,
-  VersionColumn
-} from 'typeorm'
-import { ObjectType, Field, ID } from 'type-graphql'
-
-import { Domain } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { Account } from '../account/account'
-import { FinancialStatement } from './financial-statement'
-
-@ObjectType({ description: 'Line item for a financial statement, representing the breakdown of financial accounts' })
-@Entity()
-@Index(
-  'ix_financial_statement_line_item_0',
-  (lineItem: FinancialStatementLineItem) => [lineItem.statement, lineItem.account],
-  {
-    unique: false,
-    where: '"deleted_at" IS NULL'
-  }
-)
-export class FinancialStatementLineItem {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string // 고유 식별자 (UUID)
-
-  @ManyToOne(type => FinancialStatement, statement => statement.lineItems)
-  @Field(type => FinancialStatement, { description: 'The financial statement this line item is associated with' })
-  statement: FinancialStatement // 연결된 재무제표
-
-  @RelationId((lineItem: FinancialStatementLineItem) => lineItem.statement)
-  statementId: string // 재무제표의 ID
-
-  @ManyToOne(type => Account)
-  @Field(type => Account, { description: 'The financial account associated with this line item' })
-  account: Account // 라인 아이템과 연결된 계정
-
-  @RelationId((lineItem: FinancialStatementLineItem) => lineItem.account)
-  accountId: string // 계정의 ID
-
-  @Column({ nullable: false })
-  @Field({ nullable: false, description: 'The monetary amount related to the financial account for this line item' })
-  amount: number // 계정에 대한 금액
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Optional description or notes for this line item' })
-  description?: string // 라인 아이템에 대한 선택적 설명 또는 메모
-
-  @CreateDateColumn()
-  @Field({ nullable: true, description: 'The date and time when this line item was created' })
-  createdAt?: Date // 라인 아이템이 생성된 날짜 및 시간
-
-  @UpdateDateColumn()
-  @Field({ nullable: true, description: 'The date and time when this line item was last updated' })
-  updatedAt?: Date // 라인 아이템이 마지막으로 업데이트된 날짜 및 시간
-
-  @DeleteDateColumn()
-  @Field({ nullable: true, description: 'The date and time when this line item was deleted' })
-  deletedAt?: Date // 라인 아이템이 삭제된 날짜 및 시간
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true, description: 'The user who created this line item' })
-  creator?: User // 라인 아이템을 생성한 사용자
-
-  @RelationId((lineItem: FinancialStatementLineItem) => lineItem.creator)
-  creatorId?: string // 생성자의 ID
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true, description: 'The user who last updated this line item' })
-  updater?: User // 라인 아이템을 마지막으로 업데이트한 사용자
-
-  @RelationId((lineItem: FinancialStatementLineItem) => lineItem.updater)
-  updaterId?: string // 업데이트한 사용자의 ID
-}

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

@@ -1,148 +0,0 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { getRepository } from '@things-factory/shell'
-
-import { FinancialStatement } from './financial-statement'
-import { NewFinancialStatement, FinancialStatementPatch } from './financial-statement-type'
-
-@Resolver(FinancialStatement)
-export class FinancialStatementMutation {
-  @Directive('@transaction')
-  @Directive('@privilege(category: "accounting", privilege: "mutation")')
-  @Mutation(returns => FinancialStatement, { description: 'To create new FinancialStatement' })
-  async createFinancialStatement(
-    @Arg('financialStatement') financialStatement: NewFinancialStatement,
-    @Ctx() context: ResolverContext
-  ): Promise<FinancialStatement> {
-    const { domain, user, tx } = context.state
-
-    const result = await getRepository(FinancialStatement, tx).save({
-      ...financialStatement,
-      domain,
-      creator: user,
-      updater: user
-    })
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "accounting", privilege: "mutation")')
-  @Mutation(returns => FinancialStatement, { description: 'To modify FinancialStatement information' })
-  async updateFinancialStatement(
-    @Arg('id') id: string,
-    @Arg('patch') patch: FinancialStatementPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<FinancialStatement> {
-    const { domain, user, tx } = context.state
-
-    const repository = getRepository(FinancialStatement, tx)
-    const financialStatement = await repository.findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-
-    const result = await repository.save({
-      ...financialStatement,
-      ...patch,
-      updater: user
-    })
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "accounting", privilege: "mutation")')
-  @Mutation(returns => [FinancialStatement], { description: "To modify multiple FinancialStatements' information" })
-  async updateMultipleFinancialStatement(
-    @Arg('patches', type => [FinancialStatementPatch]) patches: FinancialStatementPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<FinancialStatement[]> {
-    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 financialStatementRepo = getRepository(FinancialStatement, tx)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await financialStatementRepo.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 financialStatement = await financialStatementRepo.findOneBy({ id: updateRecord.id })
-
-        const result = await financialStatementRepo.save({
-          ...financialStatement,
-          ...updateRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "accounting", privilege: "mutation")')
-  @Mutation(returns => Boolean, { description: 'To delete FinancialStatement' })
-  async deleteFinancialStatement(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await getRepository(FinancialStatement, tx).delete({ domain: { id: domain.id }, id })
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "accounting", privilege: "mutation")')
-  @Mutation(returns => Boolean, { description: 'To delete multiple FinancialStatements' })
-  async deleteFinancialStatements(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await getRepository(FinancialStatement, tx).delete({
-      domain: { id: domain.id },
-      id: In(ids)
-    })
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "accounting", privilege: "mutation")')
-  @Mutation(returns => Boolean, { description: 'To import multiple FinancialStatements' })
-  async importFinancialStatements(
-    @Arg('financialStatements', type => [FinancialStatementPatch]) financialStatements: FinancialStatementPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await Promise.all(
-      financialStatements.map(async (financialStatement: FinancialStatementPatch) => {
-        const createdFinancialStatement: FinancialStatement = await tx
-          .getRepository(FinancialStatement)
-          .save({ domain, ...financialStatement })
-      })
-    )
-
-    return true
-  }
-}