@things-factory/accounting 8.0.0 → 9.0.0-beta.3

package/server/service/payment/payment.ts

@@ -1,123 +0,0 @@
-import {
-  CreateDateColumn,
-  UpdateDateColumn,
-  DeleteDateColumn,
-  Entity,
-  Index,
-  Column,
-  RelationId,
-  ManyToOne,
-  VersionColumn,
-  PrimaryGeneratedColumn
-} from 'typeorm'
-import { ObjectType, Field, ID, registerEnumType } from 'type-graphql'
-
-import { Domain } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { Transaction } from '../transaction/transaction'
-
-export enum PaymentDirection {
-  Incoming = 'Incoming', // 수금
-  Outgoing = 'Outgoing' // 지출
-}
-
-registerEnumType(PaymentDirection, {
-  name: 'PaymentDirection',
-  description: 'Indicates whether the payment is incoming (received) or outgoing (paid)' // 결제 방향을 나타냅니다 (수금 또는 지출)
-})
-
-@Entity()
-@Index('ix_payment_0', (payment: Payment) => [payment.domain, payment.transaction, payment.paidAt], {
-  where: '"deleted_at" IS NULL',
-  unique: true
-})
-@Index(
-  'ix_payment_1',
-  (payment: Payment) => [payment.domain, payment.year, payment.quarter, payment.month, payment.paidAt],
-  {
-    unique: true,
-    where: '"deleted_at" IS NULL'
-  }
-)
-@ObjectType({ description: 'Entity representing a Payment record in the system' }) // 시스템 내에서 결제 기록을 나타내는 엔티티
-export class Payment {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID, { description: 'Unique identifier for the payment record' })
-  readonly id: string // 고유 식별자 (UUID)
-
-  @VersionColumn()
-  @Field({ nullable: true, description: 'Version number used for optimistic locking' })
-  version?: number = 1 // 낙관적 잠금을 위한 버전 관리 필드
-
-  @ManyToOne(type => Domain)
-  @Field({ nullable: true, description: 'The domain to which this payment belongs' })
-  domain?: Domain // 결제가 속한 도메인
-
-  @RelationId((payment: Payment) => payment.domain)
-  domainId?: string // 도메인의 ID
-
-  @ManyToOne(type => Transaction, transaction => transaction.payments)
-  @Field(type => Transaction, { description: 'The transaction associated with this payment' })
-  transaction: Transaction // 결제와 연결된 트랜잭션
-
-  @RelationId((payment: Payment) => payment.transaction)
-  transactionId: string // 연결된 트랜잭션의 ID
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'The currency used in the payment' })
-  currency?: string // 결제에 사용된 통화
-
-  @Column({ nullable: false })
-  @Field({ nullable: false, description: 'The amount of money involved in the payment' })
-  amount: number // 결제된 금액
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Fiscal year in which the payment was made' })
-  year?: number // 결제가 발생한 회계 연도
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Fiscal quarter in which the payment was made' })
-  quarter?: number // 결제가 발생한 회계 분기
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Fiscal month in which the payment was made' })
-  month?: number // 결제가 발생한 회계 월
-
-  @Column({ nullable: false })
-  @Field({ nullable: false, description: 'The date and time when the payment was made' })
-  paidAt: Date // 결제가 이루어진 날짜 및 시간
-
-  @Column({ nullable: false })
-  @Field(type => PaymentDirection, { description: 'Direction of the payment (Incoming or Outgoing)' })
-  direction: PaymentDirection // 결제 방향 (수금 또는 지출)
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Additional notes or comments about the payment' })
-  note?: string // 결제에 대한 추가 설명 또는 메모
-
-  @CreateDateColumn()
-  @Field({ nullable: true, description: 'The date and time when the payment record was created' })
-  createdAt?: Date // 결제 레코드가 생성된 날짜 및 시간
-
-  @UpdateDateColumn()
-  @Field({ nullable: true, description: 'The date and time when the payment record was last updated' })
-  updatedAt?: Date // 결제 레코드가 마지막으로 업데이트된 날짜 및 시간
-
-  @DeleteDateColumn()
-  @Field({ nullable: true, description: 'The date and time when the payment record was deleted' })
-  deletedAt?: Date // 결제 레코드가 삭제된 날짜 및 시간
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true, description: 'The user who created the payment record' })
-  creator?: User // 결제 레코드를 생성한 사용자
-
-  @RelationId((payment: Payment) => payment.creator)
-  creatorId?: string // 결제 레코드를 생성한 사용자의 ID
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true, description: 'The user who last updated the payment record' })
-  updater?: User // 결제 레코드를 마지막으로 업데이트한 사용자
-
-  @RelationId((payment: Payment) => payment.updater)
-  updaterId?: string // 결제 레코드를 업데이트한 사용자의 ID
-}

package/server/service/transaction/event-subscriber.ts

@@ -1,17 +0,0 @@
-import { EventSubscriber } from 'typeorm'
-
-import { HistoryEntitySubscriber } from '@operato/typeorm-history'
-
-import { Transaction } from './transaction'
-import { TransactionHistory } from './transaction-history'
-
-@EventSubscriber()
-export class TransactionHistoryEntitySubscriber extends HistoryEntitySubscriber<Transaction, TransactionHistory> {
-  public get entity() {
-    return Transaction
-  }
-
-  public get historyEntity() {
-    return TransactionHistory
-  }
-}

package/server/service/transaction/index.ts

@@ -1,9 +0,0 @@
-import { Transaction } from './transaction'
-import { TransactionHistory } from './transaction-history'
-import { TransactionQuery } from './transaction-query'
-import { TransactionMutation } from './transaction-mutation'
-import { TransactionHistoryEntitySubscriber } from './event-subscriber'
-
-export const entities = [Transaction, TransactionHistory]
-export const resolvers = [TransactionQuery, TransactionMutation]
-export const subscribers = [TransactionHistoryEntitySubscriber]

package/server/service/transaction/transaction-history.ts

@@ -1,161 +0,0 @@
-import { Field, ID, ObjectType } from 'type-graphql'
-import { Column, Entity, Index, ManyToOne, 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 { Transaction, TransactionCategory, TransactionStatus, TransactionType } from './transaction'
-import { Account } from '../account/account'
-
-const ORMCONFIG = config.get('ormconfig', {})
-const DATABASE_TYPE = ORMCONFIG.type
-
-@Entity()
-@Index(
-  'ix_transaction_history_0',
-  (transactionHistory: TransactionHistory) => [transactionHistory.originalId, transactionHistory.version],
-  { unique: true }
-)
-@Index(
-  'ix_transaction_history_1',
-  (transactionHistory: TransactionHistory) => [
-    transactionHistory.domain,
-    transactionHistory.originalId,
-    transactionHistory.version
-  ],
-  { unique: true }
-)
-@ObjectType({ description: 'History Entity of Transaction' })
-export class TransactionHistory implements HistoryEntityInterface<Transaction> {
-  @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((transactionHistory: TransactionHistory) => transactionHistory.domain)
-  domainId?: string
-
-  @Column()
-  @Field({ nullable: true })
-  name?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  description?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  currency?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  amount?: number = 0
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  type?: TransactionType
-
-  @Column({ nullable: false })
-  @Field(type => TransactionCategory, { nullable: false })
-  category: TransactionCategory // 트랜잭션의 카테고리 (확정, 전망)
-
-  @Column({ nullable: false })
-  @Field(type => TransactionStatus, { nullable: false })
-  status: TransactionStatus // 트랜잭션의 상태 (예: Paid, Delayed 등)
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'The probability of the forecast being realized (0 to 100)' })
-  probability?: number // 예측이 실현될 확률 (0 ~ 100)
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Additional notes or comments about the forecast' })
-  forecastNotes?: string // 전망에 대한 추가 설명이나 메모
-
-  @ManyToOne(type => Account)
-  @Field({ nullable: true })
-  account?: Account
-
-  @RelationId((transactionHistory: TransactionHistory) => transactionHistory.account)
-  accountId?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'fiscal year' })
-  year?: number
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'fiscal quarter' })
-  quarter?: number
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'fiscal month' })
-  month?: number
-
-  @Column({ nullable: false })
-  @Field({ nullable: false, description: 'The date the transaction occurs or is scheduled (in string format)' })
-  transactionDate: string // 트랜잭션이 발생하거나 발생할 날짜
-
-  @Column()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @Column()
-  @Field({ nullable: true })
-  updatedAt?: Date
-
-  @Column()
-  @Field({ nullable: true })
-  deletedAt?: Date
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  creator?: User
-
-  @RelationId((transactionHistory: TransactionHistory) => transactionHistory.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((transactionHistory: TransactionHistory) => transactionHistory.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/transaction/transaction-mutation.ts

@@ -1,146 +0,0 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { getRepository } from '@things-factory/shell'
-
-import { Transaction } from './transaction'
-import { NewTransaction, TransactionPatch } from './transaction-type'
-
-@Resolver(Transaction)
-export class TransactionMutation {
-  @Directive('@transaction')
-  @Directive('@privilege(category: "accounting", privilege: "mutation")')
-  @Mutation(returns => Transaction, { description: 'To create new Transaction' })
-  async createTransaction(
-    @Arg('transaction') transaction: NewTransaction,
-    @Ctx() context: ResolverContext
-  ): Promise<Transaction> {
-    const { domain, user, tx } = context.state
-
-    const result = await getRepository(Transaction, tx).save({
-      ...transaction,
-      domain,
-      creator: user,
-      updater: user
-    })
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "accounting", privilege: "mutation")')
-  @Mutation(returns => Transaction, { description: 'To modify Transaction information' })
-  async updateTransaction(
-    @Arg('id') id: string,
-    @Arg('patch') patch: TransactionPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<Transaction> {
-    const { domain, user, tx } = context.state
-
-    const repository = getRepository(Transaction, tx)
-    const transaction = await repository.findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-
-    const result = await repository.save({
-      ...transaction,
-      ...patch,
-      updater: user
-    })
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "accounting", privilege: "mutation")')
-  @Mutation(returns => [Transaction], { description: "To modify multiple Transactions' information" })
-  async updateMultipleTransaction(
-    @Arg('patches', type => [TransactionPatch]) patches: TransactionPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<Transaction[]> {
-    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 transactionRepo = getRepository(Transaction, tx)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await transactionRepo.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 transaction = await transactionRepo.findOneBy({ id: updateRecord.id })
-
-        const result = await transactionRepo.save({
-          ...transaction,
-          ...updateRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "accounting", privilege: "mutation")')
-  @Mutation(returns => Boolean, { description: 'To delete Transaction' })
-  async deleteTransaction(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await getRepository(Transaction, tx).delete({ domain: { id: domain.id }, id })
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "accounting", privilege: "mutation")')
-  @Mutation(returns => Boolean, { description: 'To delete multiple Transactions' })
-  async deleteTransactions(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await getRepository(Transaction, 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 Transactions' })
-  async importTransactions(
-    @Arg('transactions', type => [TransactionPatch]) transactions: TransactionPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await Promise.all(
-      transactions.map(async (transaction: TransactionPatch) => {
-        const createdTransaction: Transaction = await getRepository(Transaction, tx).save({ domain, ...transaction })
-      })
-    )
-
-    return true
-  }
-}

package/server/service/transaction/transaction-query.ts

@@ -1,50 +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 { Transaction } from './transaction'
-import { TransactionList } from './transaction-type'
-
-@Resolver(Transaction)
-export class TransactionQuery {
-  @Directive('@privilege(category: "accounting", privilege: "query")')
-  @Query(returns => Transaction!, { nullable: true, description: 'To fetch a Transaction' })
-  async transaction(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Transaction> {
-    const { domain } = context.state
-
-    return await getRepository(Transaction).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @Directive('@privilege(category: "accounting", privilege: "query")')
-  @Query(returns => TransactionList, { description: 'To fetch multiple Transactions' })
-  async transactions(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<TransactionList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      domain,
-      params,
-      repository: await getRepository(Transaction),
-      searchables: ['name', 'description']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() transaction: Transaction): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: transaction.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() transaction: Transaction): Promise<User> {
-    return await getRepository(User).findOneBy({ id: transaction.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() transaction: Transaction): Promise<User> {
-    return await getRepository(User).findOneBy({ id: transaction.creatorId })
-  }
-}

package/server/service/transaction/transaction-type.ts

@@ -1,48 +0,0 @@
-import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-graphql'
-
-import { Transaction, TransactionType } from './transaction'
-
-@InputType()
-export class NewTransaction {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field(type => TransactionType, { nullable: true })
-  type?: TransactionType
-
-  @Field({ nullable: true })
-  active?: boolean
-}
-
-@InputType()
-export class TransactionPatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field(type => TransactionType, { nullable: true })
-  type?: TransactionType
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field({ nullable: true })
-  cuFlag?: string
-}
-
-@ObjectType()
-export class TransactionList {
-  @Field(type => [Transaction])
-  items: Transaction[]
-
-  @Field(type => Int)
-  total: number
-}