@things-factory/accounting 7.0.2 → 7.1.2

package/server/migrations/1725200507196-seed-fiscal-entities.ts

@@ -0,0 +1,106 @@
+import { MigrationInterface, QueryRunner } from 'typeorm'
+import { Domain, getRepository } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { FiscalYear } from '../service/fiscal-year/fiscal-year'
+import { FiscalQuarter } from '../service/fiscal-quarter/fiscal-quarter'
+import { FiscalMonth } from '../service/fiscal-month/fiscal-month'
+import { FiscalStatus } from '../service/common-type'
+
+export class SeedFiscalEntities1725200507196 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    const domainRepository = getRepository(Domain)
+    const userRepository = getRepository(User)
+    const fiscalYearRepository = getRepository(FiscalYear)
+    const fiscalQuarterRepository = getRepository(FiscalQuarter)
+    const fiscalMonthRepository = getRepository(FiscalMonth)
+
+    const domain: Domain | null = await domainRepository.findOne({
+      where: { name: 'SYSTEM' }
+    })
+
+    if (!domain) {
+      throw new Error('SYSTEM domain not found')
+    }
+
+    const user = await userRepository.findOne({ where: { id: domain.owner } })
+
+    if (!user) {
+      throw new Error('Domain owner not found')
+    }
+
+    const currentYear = new Date().getFullYear()
+
+    try {
+      // Fiscal Year 생성
+      const fiscalYear = await fiscalYearRepository.save({
+        domain,
+        year: currentYear,
+        startDate: `${currentYear}-01-01`, // 문자열로 저장
+        endDate: `${currentYear}-12-31`, // 문자열로 저장
+        status: FiscalStatus.OPEN,
+        creator: user,
+        updater: user
+      })
+
+      // Fiscal Quarters 생성
+      for (let quarter = 1; quarter <= 4; quarter++) {
+        const startMonth = (quarter - 1) * 3 + 1
+        const endMonth = quarter * 3
+
+        const fiscalQuarter = await fiscalQuarterRepository.save({
+          domain,
+          year: currentYear,
+          quarter,
+          startDate: `${currentYear}-${String(startMonth).padStart(2, '0')}-01`, // 문자열로 저장
+          endDate: `${currentYear}-${String(endMonth).padStart(2, '0')}-31`, // 임시로 월의 마지막 날을 31일로 설정
+          status: FiscalStatus.OPEN,
+          creator: user,
+          updater: user
+        })
+
+        // Fiscal Months 생성
+        for (let month = startMonth; month <= endMonth; month++) {
+          const startDate = `${currentYear}-${String(month).padStart(2, '0')}-01`
+          const endDate = `${currentYear}-${String(month).padStart(2, '0')}-${new Date(currentYear, month, 0).getDate()}`
+
+          await fiscalMonthRepository.save({
+            domain,
+            year: currentYear,
+            quarter,
+            month,
+            startDate,
+            endDate,
+            status: FiscalStatus.OPEN,
+            creator: user,
+            updater: user
+          })
+        }
+      }
+    } catch (error) {
+      console.error('Failed to seed fiscal entities:', error)
+      throw error
+    }
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    const domainRepository = getRepository(Domain)
+    const fiscalYearRepository = getRepository(FiscalYear)
+    const fiscalQuarterRepository = getRepository(FiscalQuarter)
+    const fiscalMonthRepository = getRepository(FiscalMonth)
+
+    const domain: Domain | null = await domainRepository.findOne({
+      where: { name: 'SYSTEM' }
+    })
+
+    if (!domain) {
+      throw new Error('SYSTEM domain not found')
+    }
+
+    const currentYear = new Date().getFullYear()
+
+    // FiscalMonth, FiscalQuarter, FiscalYear 삭제
+    await fiscalMonthRepository.delete({ domain: { id: domain.id }, year: currentYear })
+    await fiscalQuarterRepository.delete({ domain: { id: domain.id }, year: currentYear })
+    await fiscalYearRepository.delete({ domain: { id: domain.id }, year: currentYear })
+  }
+}

package/server/migrations/1725201467183-seed-accounts.ts

@@ -0,0 +1,339 @@
+import { MigrationInterface, QueryRunner } from 'typeorm'
+import { Domain, getRepository } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { Account } from '../service/account/account'
+import { AccountingCategory } from '../service/accounting-category/accounting-category'
+
+export class SeedAccounts1725201467183 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    const domainRepository = getRepository(Domain)
+    const userRepository = getRepository(User)
+    const accountingCategoryRepository = getRepository(AccountingCategory)
+    const accountRepository = getRepository(Account)
+
+    const domain: Domain | null = await domainRepository.findOne({
+      where: { name: 'SYSTEM' }
+    })
+
+    if (!domain) {
+      throw new Error('SYSTEM domain not found')
+    }
+
+    const user = await userRepository.findOne({ where: { id: domain.owner } })
+
+    if (!user) {
+      throw new Error('Domain owner not found')
+    }
+
+    try {
+      // 최상위 카테고리 생성
+      const topLevelCategories = {
+        자산: await accountingCategoryRepository.save({
+          domain,
+          code: 'ASSET',
+          name: '자산',
+          description: '기업이 소유하고 있는 자산',
+          creator: user,
+          updater: user
+        }),
+        부채: await accountingCategoryRepository.save({
+          domain,
+          code: 'LIABILITY',
+          name: '부채',
+          description: '기업이 갚아야 할 빚',
+          creator: user,
+          updater: user
+        }),
+        자본: await accountingCategoryRepository.save({
+          domain,
+          code: 'EQUITY',
+          name: '자본',
+          description: '기업 소유주의 자산',
+          creator: user,
+          updater: user
+        }),
+        수익: await accountingCategoryRepository.save({
+          domain,
+          code: 'REVENUE',
+          name: '수익',
+          description: '기업이 벌어들인 돈',
+          creator: user,
+          updater: user
+        }),
+        비용: await accountingCategoryRepository.save({
+          domain,
+          code: 'EXPENSE',
+          name: '비용',
+          description: '기업 운영에 사용된 돈',
+          creator: user,
+          updater: user
+        })
+      }
+
+      // 유동자산 및 비유동자산과 같은 하위 카테고리 생성
+      const subCategories = {
+        유동자산: await accountingCategoryRepository.save({
+          domain,
+          code: 'CURRENT_ASSET',
+          name: '유동자산',
+          description: '쉽게 현금화할 수 있는 자산',
+          parent: topLevelCategories.자산,
+          creator: user,
+          updater: user
+        }),
+        비유동자산: await accountingCategoryRepository.save({
+          domain,
+          code: 'NON_CURRENT_ASSET',
+          name: '비유동자산',
+          description: '장기 보유 자산',
+          parent: topLevelCategories.자산,
+          creator: user,
+          updater: user
+        }),
+        유동부채: await accountingCategoryRepository.save({
+          domain,
+          code: 'CURRENT_LIABILITY',
+          name: '유동부채',
+          description: '단기간에 상환해야 하는 부채',
+          parent: topLevelCategories.부채,
+          creator: user,
+          updater: user
+        }),
+        비유동부채: await accountingCategoryRepository.save({
+          domain,
+          code: 'NON_CURRENT_LIABILITY',
+          name: '비유동부채',
+          description: '장기 부채',
+          parent: topLevelCategories.부채,
+          creator: user,
+          updater: user
+        })
+      }
+
+      // 이제 유형자산, 무형자산, 단기금융부채 같은 하위 카테고리를 subCategories 객체를 사용하여 생성합니다.
+      const furtherSubCategories = {
+        유형자산: await accountingCategoryRepository.save({
+          domain,
+          code: 'TANGIBLE_ASSET',
+          name: '유형자산',
+          description: '물리적 형태가 있는 자산',
+          parent: subCategories.비유동자산,
+          creator: user,
+          updater: user
+        }),
+        무형자산: await accountingCategoryRepository.save({
+          domain,
+          code: 'INTANGIBLE_ASSET',
+          name: '무형자산',
+          description: '물리적 형태가 없는 자산',
+          parent: subCategories.비유동자산,
+          creator: user,
+          updater: user
+        }),
+        단기금융부채: await accountingCategoryRepository.save({
+          domain,
+          code: 'SHORT_TERM_FINANCIAL_LIABILITY',
+          name: '단기금융부채',
+          description: '단기적으로 갚아야 할 금융부채',
+          parent: subCategories.유동부채,
+          creator: user,
+          updater: user
+        })
+      }
+
+      // 계정 생성 및 하위 카테고리 연결
+      const accounts = [
+        // 유동자산 계정
+        {
+          code: '101',
+          name: '현금 및 현금성 자산',
+          description: '현금, 예금 및 기타 현금성 자산',
+          category: subCategories.유동자산
+        },
+        {
+          code: '102',
+          name: '매출채권',
+          description: '상품 또는 서비스의 판매로 인해 발생한 채권',
+          category: subCategories.유동자산
+        },
+        {
+          code: '103',
+          name: '재고자산',
+          description: '판매를 목적으로 보유한 상품, 제품, 원재료 등',
+          category: subCategories.유동자산
+        },
+        {
+          code: '104',
+          name: '단기금융상품',
+          description: '단기투자 목적으로 보유한 금융상품',
+          category: subCategories.유동자산
+        },
+        {
+          code: '105',
+          name: '선급금',
+          description: '상품, 서비스 제공을 위해 미리 지급한 금액',
+          category: subCategories.유동자산
+        },
+
+        // 비유동자산 계정
+        {
+          code: '201',
+          name: '건물',
+          description: '기업이 소유한 건물',
+          category: furtherSubCategories.유형자산
+        },
+        {
+          code: '202',
+          name: '토지',
+          description: '기업이 소유한 토지',
+          category: furtherSubCategories.유형자산
+        },
+        {
+          code: '203',
+          name: '기계장치',
+          description: '생산을 위해 사용되는 기계 및 장치',
+          category: furtherSubCategories.유형자산
+        },
+        {
+          code: '204',
+          name: '무형자산',
+          description: '특허권, 상표권 등의 무형자산',
+          category: furtherSubCategories.무형자산
+        },
+
+        // 유동부채 계정
+        {
+          code: '301',
+          name: '매입채무',
+          description: '상품 또는 서비스의 구매로 인해 발생한 채무',
+          category: subCategories.유동부채
+        },
+        {
+          code: '302',
+          name: '단기차입금',
+          description: '단기 대출금',
+          category: furtherSubCategories.단기금융부채
+        },
+        {
+          code: '303',
+          name: '미지급금',
+          description: '이미 발생한 비용에 대한 지급할 금액',
+          category: subCategories.유동부채
+        },
+        {
+          code: '304',
+          name: '선수금',
+          description: '고객으로부터 미리 받은 금액',
+          category: subCategories.유동부채
+        },
+
+        // 비유동부채 계정
+        { code: '401', name: '장기차입금', description: '장기 대출금', category: subCategories.비유동부채 },
+        {
+          code: '402',
+          name: '퇴직급여충당부채',
+          description: '퇴직급여 지급을 위해 설정한 부채',
+          category: subCategories.비유동부채
+        },
+
+        // 자본 계정
+        { code: '501', name: '자본금', description: '주주가 납입한 자본', category: topLevelCategories.자본 },
+        { code: '502', name: '이익잉여금', description: '이익의 축적', category: topLevelCategories.자본 },
+
+        // 수익 계정
+        {
+          code: '601',
+          name: '제품매출',
+          description: '제품의 판매로 인한 수익',
+          category: topLevelCategories.수익
+        },
+        {
+          code: '602',
+          name: '상품매출',
+          description: '상품의 판매로 인한 수익',
+          category: topLevelCategories.수익
+        },
+        {
+          code: '603',
+          name: '용역매출',
+          description: '용역 제공으로 인한 수익',
+          category: topLevelCategories.수익
+        },
+        {
+          code: '604',
+          name: '이자수익',
+          description: '금융 자산에서 발생한 이자수익',
+          category: topLevelCategories.수익
+        },
+        {
+          code: '605',
+          name: '배당금수익',
+          description: '주식 투자로 인한 배당금 수익',
+          category: topLevelCategories.수익
+        },
+
+        // 비용 계정
+        {
+          code: '701',
+          name: '매출원가',
+          description: '제품, 상품, 용역 제공에 대한 원가',
+          category: topLevelCategories.비용
+        },
+        { code: '702', name: '급여', description: '직원 급여 비용', category: topLevelCategories.비용 },
+        { code: '703', name: '임대료', description: '건물 및 설비 임차료', category: topLevelCategories.비용 },
+        {
+          code: '704',
+          name: '감가상각비',
+          description: '유형자산의 감가상각비용',
+          category: topLevelCategories.비용
+        },
+        {
+          code: '705',
+          name: '이자비용',
+          description: '차입금에 대한 이자비용',
+          category: topLevelCategories.비용
+        },
+        {
+          code: '706',
+          name: '판매비 및 관리비',
+          description: '기업 운영에 필요한 비용',
+          category: topLevelCategories.비용
+        },
+        { code: '707', name: '법인세비용', description: '법인세 납부 비용', category: topLevelCategories.비용 }
+      ]
+
+      // 계정 저장
+      for (const account of accounts) {
+        await accountRepository.save({
+          domain,
+          ...account,
+          creator: user,
+          updater: user
+        })
+      }
+    } catch (error) {
+      console.error('Failed to seed accounting categories and accounts:', error)
+      throw error
+    }
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    const domainRepository = getRepository(Domain)
+    const accountingCategoryRepository = getRepository(AccountingCategory)
+    const accountRepository = getRepository(Account)
+
+    const domain: Domain | null = await domainRepository.findOne({
+      where: { name: 'SYSTEM' }
+    })
+
+    if (!domain) {
+      throw new Error('SYSTEM domain not found')
+    }
+
+    // Accounts 삭제
+    await accountRepository.softDelete({ domain: { id: domain.id } })
+
+    // AccountingCategories 삭제
+    await accountingCategoryRepository.softDelete({ domain: { id: domain.id } })
+  }
+}

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

@@ -12,6 +12,7 @@ import { config } from '@things-factory/env'
 import { Domain } from '@things-factory/shell'
 
 import { Account } from './account'
+import { AccountingCategory } from '../accounting-category/accounting-category'
 
 const ORMCONFIG = config.get('ormconfig', {})
 const DATABASE_TYPE = ORMCONFIG.type
@@ -38,15 +39,15 @@ export class AccountHistory implements HistoryEntityInterface<Account> {
   version?: number = 1
 
   @ManyToOne(type => Domain)
-  @Field(type => Domain)
+  @Field({ nullable: true })
   domain?: Domain
 
-  @RelationId((account: Account) => account.domain)
+  @RelationId((accountHistory: AccountHistory) => accountHistory.domain)
   domainId?: string
 
   @Column({ nullable: true })
   @Field({ nullable: true })
-  controlNumber?: string
+  code?: string
 
   @Column({ nullable: true })
   @Field({ nullable: true })
@@ -60,6 +61,13 @@ export class AccountHistory implements HistoryEntityInterface<Account> {
   @Field({ nullable: true })
   active?: boolean
 
+  @ManyToOne(type => AccountingCategory)
+  @Field(type => AccountingCategory, { nullable: true })
+  category?: AccountingCategory
+
+  @RelationId((accountHistory: AccountHistory) => accountHistory.category)
+  categoryId?: string
+
   @Column({ nullable: true })
   @Field({ nullable: true })
   createdAt?: Date
@@ -73,17 +81,17 @@ export class AccountHistory implements HistoryEntityInterface<Account> {
   deletedAt?: Date
 
   @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
+  @Field({ nullable: true })
   creator?: User
 
-  @RelationId((account: Account) => account.creator)
+  @RelationId((accountHistory: AccountHistory) => accountHistory.creator)
   creatorId?: string
 
   @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
+  @Field({ nullable: true })
   updater?: User
 
-  @RelationId((account: Account) => account.updater)
+  @RelationId((accountHistory: AccountHistory) => accountHistory.updater)
   updaterId?: string
 
   @HistoryOriginalIdColumn()

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

@@ -1,7 +1,7 @@
 import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
 import { In } from 'typeorm'
 
-import { createAttachment, deleteAttachmentsByRef } from '@things-factory/attachment-base'
+import { getRepository } from '@things-factory/shell'
 
 import { Account } from './account'
 import { NewAccount, AccountPatch } from './account-type'
@@ -9,11 +9,12 @@ import { NewAccount, AccountPatch } from './account-type'
 @Resolver(Account)
 export class AccountMutation {
   @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
   @Mutation(returns => Account, { description: 'To create new Account' })
   async createAccount(@Arg('account') account: NewAccount, @Ctx() context: ResolverContext): Promise<Account> {
     const { domain, user, tx } = context.state
 
-    const result = await tx.getRepository(Account).save({
+    const result = await getRepository(Account, tx).save({
       ...account,
       domain,
       creator: user,
@@ -24,6 +25,7 @@ export class AccountMutation {
   }
 
   @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
   @Mutation(returns => Account, { description: 'To modify Account information' })
   async updateAccount(
     @Arg('id') id: string,
@@ -32,7 +34,7 @@ export class AccountMutation {
   ): Promise<Account> {
     const { domain, user, tx } = context.state
 
-    const repository = tx.getRepository(Account)
+    const repository = getRepository(Account, tx)
     const account = await repository.findOne({
       where: { domain: { id: domain.id }, id }
     })
@@ -47,6 +49,7 @@ export class AccountMutation {
   }
 
   @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
   @Mutation(returns => [Account], { description: "To modify multiple Accounts' information" })
   async updateMultipleAccount(
     @Arg('patches', type => [AccountPatch]) patches: AccountPatch[],
@@ -57,7 +60,7 @@ export class AccountMutation {
     let results = []
     const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
     const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const accountRepo = tx.getRepository(Account)
+    const accountRepo = getRepository(Account, tx)
 
     if (_createRecords.length > 0) {
       for (let i = 0; i < _createRecords.length; i++) {
@@ -93,32 +96,32 @@ export class AccountMutation {
   }
 
   @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
   @Mutation(returns => Boolean, { description: 'To delete Account' })
   async deleteAccount(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
-    await tx.getRepository(Account).delete({ domain: { id: domain.id }, id })
-    await deleteAttachmentsByRef(null, { refBys: [id] }, context)
+    await getRepository(Account, tx).delete({ domain: { id: domain.id }, id })
 
     return true
   }
 
   @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
   @Mutation(returns => Boolean, { description: 'To delete multiple Accounts' })
   async deleteAccounts(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
-    await tx.getRepository(Account).delete({
+    await getRepository(Account, tx).delete({
       domain: { id: domain.id },
       id: In(ids)
     })
 
-    await deleteAttachmentsByRef(null, { refBys: ids }, context)
-
     return true
   }
 
   @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
   @Mutation(returns => Boolean, { description: 'To import multiple Accounts' })
   async importAccounts(
     @Arg('accounts', type => [AccountPatch]) accounts: AccountPatch[],
@@ -128,7 +131,7 @@ export class AccountMutation {
 
     await Promise.all(
       accounts.map(async (account: AccountPatch) => {
-        const createdAccount: Account = await tx.getRepository(Account).save({ domain, ...account })
+        const createdAccount: Account = await getRepository(Account, tx).save({ domain, ...account })
       })
     )
 

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

@@ -7,6 +7,7 @@ import { AccountList } from './account-type'
 
 @Resolver(Account)
 export class AccountQuery {
+  @Directive('@privilege(category: "accounting", privilege: "query")')
   @Query(returns => Account!, { nullable: true, description: 'To fetch a Account' })
   async account(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Account> {
     const { domain } = context.state
@@ -16,8 +17,9 @@ export class AccountQuery {
     })
   }
 
+  @Directive('@privilege(category: "accounting", privilege: "query")')
   @Query(returns => AccountList, { description: 'To fetch multiple Accounts' })
-  async accounts(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<AccountList> {
+  async accounts(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<AccountList> {
     const { domain } = context.state
 
     const queryBuilder = getQueryBuilderFromListParams({

package/server/service/account/account.ts

@@ -17,7 +17,18 @@ import { User } from '@things-factory/auth-base'
 import { AccountingCategory } from '../accounting-category/accounting-category'
 
 @Entity()
-@Index('ix_account_0', (account: Account) => [account.domain, account.name, account.deletedAt], { unique: true })
+@Index('ix_account_0', (account: Account) => [account.domain, account.name], {
+  unique: true,
+  where: '"deleted_at" IS NULL'
+})
+@Index('ix_account_1', (account: Account) => [account.domain, account.code], {
+  unique: true,
+  where: '"deleted_at" IS NULL'
+})
+@Index('ix_account_2', (account: Account) => [account.domain, account.category], {
+  unique: false,
+  where: '"deleted_at" IS NULL'
+})
 @ObjectType({ description: 'Entity for Account' })
 export class Account {
   @PrimaryGeneratedColumn('uuid')
@@ -29,15 +40,15 @@ export class Account {
   version?: number = 1
 
   @ManyToOne(type => Domain)
-  @Field(type => Domain)
+  @Field({ nullable: true })
   domain?: Domain
 
   @RelationId((account: Account) => account.domain)
   domainId?: string
 
   @Column()
-  @Field({ nullable: true, description: 'Account control number' })
-  controlNumber?: string
+  @Field({ nullable: true, description: 'Account code number' })
+  code?: string
 
   @Column()
   @Field({ nullable: true, description: 'Account name' })
@@ -51,7 +62,7 @@ export class Account {
   @Field({ nullable: true })
   active?: boolean
 
-  @Column({ nullable: true })
+  @ManyToOne(type => AccountingCategory)
   @Field(type => AccountingCategory, { nullable: true })
   category?: AccountingCategory