@things-factory/accounting 7.0.2 → 8.0.0-alpha.1

package/server/service/fiscal-year/fiscal-year-mutation.ts

@@ -0,0 +1,137 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { In } from 'typeorm'
+import { getRepository } from '@things-factory/shell'
+
+import { FiscalYear } from './fiscal-year'
+import { NewFiscalYear, FiscalYearPatch } from './fiscal-year-type'
+
+@Resolver(FiscalYear)
+export class FiscalYearMutation {
+  @Directive('@transaction')
+  @Mutation(returns => FiscalYear, { description: 'To create new FiscalYear' })
+  async createFiscalYear(@Arg('fiscalYear') fiscalYear: NewFiscalYear, @Ctx() context: ResolverContext): Promise<FiscalYear> {
+    const { domain, user, tx } = context.state
+
+    const result = await getRepository(FiscalYear, tx).save({
+      ...fiscalYear,
+      domain,
+      creator: user,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => FiscalYear, { description: 'To modify FiscalYear information' })
+  async updateFiscalYear(
+    @Arg('id') id: string,
+    @Arg('patch') patch: FiscalYearPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<FiscalYear> {
+    const { domain, user, tx } = context.state
+
+    const repository = getRepository(FiscalYear, tx)
+    const fiscalYear = await repository.findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+
+    const result = await repository.save({
+      ...fiscalYear,
+      ...patch,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [FiscalYear], { description: "To modify multiple FiscalYears' information" })
+  async updateMultipleFiscalYear(
+    @Arg('patches', type => [FiscalYearPatch]) patches: FiscalYearPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<FiscalYear[]> {
+    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 fiscalYearRepo = getRepository(FiscalYear, tx)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await fiscalYearRepo.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 fiscalYear = await fiscalYearRepo.findOneBy({ id: updateRecord.id })
+
+        const result = await fiscalYearRepo.save({
+          ...fiscalYear,
+          ...updateRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete FiscalYear' })
+  async deleteFiscalYear(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await getRepository(FiscalYear, tx).delete({ domain: { id: domain.id }, id })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple FiscalYears' })
+  async deleteFiscalYears(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await getRepository(FiscalYear, tx).delete({
+      domain: { id: domain.id },
+      id: In(ids)
+    })
+
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To import multiple FiscalYears' })
+  async importFiscalYears(
+    @Arg('fiscalYears', type => [FiscalYearPatch]) fiscalYears: FiscalYearPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await Promise.all(
+      fiscalYears.map(async (fiscalYear: FiscalYearPatch) => {
+        const createdFiscalYear: FiscalYear = await getRepository(FiscalYear, tx).save({ domain, ...fiscalYear })
+      })
+    )
+
+    return true
+  }
+}

package/server/service/fiscal-year/fiscal-year-query.ts

@@ -0,0 +1,51 @@
+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 { FiscalYear } from './fiscal-year'
+import { FiscalYearList } from './fiscal-year-type'
+
+@Resolver(FiscalYear)
+export class FiscalYearQuery {
+  @Query(returns => FiscalYear!, { nullable: true, description: 'To fetch a FiscalYear by year' })
+  async fiscalYear(@Arg('year') year: number, @Ctx() context: ResolverContext): Promise<FiscalYear | undefined> {
+    const { domain } = context.state
+
+    return await getRepository(FiscalYear).findOne({
+      where: { domain: { id: domain.id }, year }
+    })
+  }
+
+  @Query(returns => FiscalYearList, { description: 'To fetch multiple FiscalYears' })
+  async fiscalYears(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<FiscalYearList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: await getRepository(FiscalYear),
+      searchables: []
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() fiscalYear: FiscalYear): Promise<Domain> {
+    return fiscalYear.domainId && (await getRepository(Domain).findOneBy({ id: fiscalYear.domainId }))
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() fiscalYear: FiscalYear): Promise<User> {
+    return fiscalYear.updaterId && (await getRepository(User).findOneBy({ id: fiscalYear.updaterId }))
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() fiscalYear: FiscalYear): Promise<User> {
+    return fiscalYear.creatorId && (await getRepository(User).findOneBy({ id: fiscalYear.creatorId }))
+  }
+}

package/server/service/fiscal-year/fiscal-year-type.ts

@@ -0,0 +1,54 @@
+import { InputType, ObjectType, Field, ID, Int } from 'type-graphql'
+import { FiscalYear } from './fiscal-year'
+import { FiscalStatus } from '../common-type'
+
+@InputType()
+export class NewFiscalYear {
+  @Field(type => Int)
+  year: number // 회계연도 (예: 2023)
+
+  @Field(type => String, { description: 'The start date of the fiscal month in YYYY-MM-DD format' })
+  startDate: string // 월의 시작일
+
+  @Field(type => String, { description: 'The end date of the fiscal month in YYYY-MM-DD format' })
+  endDate: string // 월의 종료일
+
+  @Field(type => FiscalStatus, { nullable: true })
+  status?: FiscalStatus // 회계연도의 상태 (OPEN, CLOSED, FINALIZED)
+
+  @Field({ nullable: true })
+  notes?: string // 회계연도에 대한 설명이나 주석
+}
+
+@InputType()
+export class FiscalYearPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field(type => Int, { nullable: true })
+  year?: number // 회계연도 (예: 2023)
+
+  @Field(type => String, { description: 'The start date of the fiscal month in YYYY-MM-DD format' })
+  startDate: string // 월의 시작일
+
+  @Field(type => String, { description: 'The end date of the fiscal month in YYYY-MM-DD format' })
+  endDate: string // 월의 종료일
+
+  @Field(type => FiscalStatus, { nullable: true })
+  status?: FiscalStatus // 회계연도의 상태 (OPEN, CLOSED, FINALIZED)
+
+  @Field({ nullable: true })
+  notes?: string // 회계연도에 대한 설명이나 주석
+
+  @Field({ nullable: true })
+  cuFlag?: string // Create/Update Flag
+}
+
+@ObjectType()
+export class FiscalYearList {
+  @Field(type => [FiscalYear])
+  items: FiscalYear[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/fiscal-year/fiscal-year.ts

@@ -0,0 +1,76 @@
+import {
+  CreateDateColumn,
+  DeleteDateColumn,
+  UpdateDateColumn,
+  Entity,
+  Index,
+  Column,
+  ManyToOne,
+  RelationId,
+  PrimaryGeneratedColumn
+} from 'typeorm'
+import { ObjectType, Field, Int, ID } from 'type-graphql'
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { FiscalStatus } from '../common-type'
+
+@ObjectType({ description: 'Entity representing a fiscal year' })
+@Entity()
+export class FiscalYear {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((fiscalYear: FiscalYear) => fiscalYear.domain)
+  domainId?: string
+
+  @Column()
+  @Field(type => Int, { description: 'The fiscal year (e.g., 2023)' })
+  year: number // 회계연도 (예: 2023)
+
+  @Column()
+  @Field(type => String, { description: 'The start date of the fiscal year in YYYY-MM-DD format' })
+  startDate: string // 회계연도 시작일
+
+  @Column()
+  @Field(type => String, { description: 'The end date of the fiscal year in YYYY-MM-DD format' })
+  endDate: string // 회계연도 종료일
+
+  @Column({ type: 'enum', enum: FiscalStatus, default: FiscalStatus.OPEN })
+  @Field(type => FiscalStatus, { description: 'The status of the fiscal year (OPEN, CLOSED, FINALIZED)' })
+  status: FiscalStatus // 회계연도의 상태 (OPEN, CLOSED, FINALIZED)
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'Notes or comments about the fiscal year' })
+  notes?: 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((fiscalYear: FiscalYear) => fiscalYear.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((fiscalYear: FiscalYear) => fiscalYear.updater)
+  updaterId?: string
+}

package/server/service/fiscal-year/index.ts

@@ -0,0 +1,7 @@
+import { FiscalYear } from './fiscal-year'
+import { FiscalYearQuery } from './fiscal-year-query'
+import { FiscalYearMutation } from './fiscal-year-mutation'
+
+export const entities = [FiscalYear]
+export const resolvers = [FiscalYearQuery, FiscalYearMutation]
+export const subscribers = []

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

@@ -45,7 +45,7 @@ export class IncomeStatementHistory implements HistoryEntityInterface<IncomeStat
   version?: number = 1
 
   @ManyToOne(type => Domain)
-  @Field(type => Domain)
+  @Field({ nullable: true })
   domain?: Domain
 
   @RelationId((incomeStatement: IncomeStatement) => incomeStatement.domain)
@@ -84,14 +84,14 @@ export class IncomeStatementHistory implements HistoryEntityInterface<IncomeStat
   deletedAt?: Date
 
   @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
+  @Field({ nullable: true })
   creator?: User
 
   @RelationId((incomeStatement: IncomeStatement) => incomeStatement.creator)
   creatorId?: string
 
   @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
+  @Field({ nullable: true })
   updater?: User
 
   @RelationId((incomeStatement: IncomeStatement) => incomeStatement.updater)
@@ -106,8 +106,8 @@ export class IncomeStatementHistory implements HistoryEntityInterface<IncomeStat
       DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
         ? 'enum'
         : DATABASE_TYPE == 'oracle'
-          ? 'varchar2'
-          : 'smallint',
+        ? 'varchar2'
+        : 'smallint',
     enum: HistoryActionType
   })
   public action!: HistoryActionType

package/server/service/income-statement/income-statement-query.ts

@@ -16,10 +16,7 @@ export class IncomeStatementQuery {
   }
 
   @Query(returns => IncomeStatementList, { description: 'To fetch multiple IncomeStatements' })
-  async incomeStatements(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<IncomeStatementList> {
+  async incomeStatements(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<IncomeStatementList> {
     const { domain } = context.state
 
     const queryBuilder = getQueryBuilderFromListParams({

package/server/service/income-statement/income-statement.ts

@@ -30,7 +30,7 @@ registerEnumType(IncomeStatementStatus, {
 @Index(
   'ix_income_statement_0',
   (incomeStatement: IncomeStatement) => [incomeStatement.domain, incomeStatement.deletedAt],
-  { unique: true }
+  { unique: false, where: '"deleted_at" IS NULL' }
 )
 @ObjectType({ description: 'Entity for IncomeStatement' })
 export class IncomeStatement {
@@ -43,7 +43,7 @@ export class IncomeStatement {
   version?: number = 1
 
   @ManyToOne(type => Domain)
-  @Field(type => Domain)
+  @Field({ nullable: true })
   domain?: Domain
 
   @RelationId((incomeStatement: IncomeStatement) => incomeStatement.domain)
@@ -58,7 +58,7 @@ export class IncomeStatement {
   quarter?: number
 
   @Column({ nullable: true })
-  @Field({ nullable: true })
+  @Field({ nullable: true, description: 'fiscal month' })
   month?: number
 
   @Column({ nullable: true })

package/server/service/index.ts

@@ -4,6 +4,9 @@ export * from './financial-statement/financial-statement'
 export * from './accounting-category/accounting-category'
 export * from './transaction/transaction'
 export * from './account/account'
+export * from './fiscal-month/fiscal-month'
+export * from './fiscal-quarter/fiscal-quarter'
+export * from './fiscal-year/fiscal-year'
 
 /* IMPORT ENTITIES AND RESOLVERS */
 import {
@@ -31,6 +34,21 @@ import {
   resolvers as AccountResolvers,
   subscribers as AccountSubscribers
 } from './account'
+import {
+  entities as FiscalMonthEntities,
+  resolvers as FiscalMonthResolvers,
+  subscribers as FiscalMonthSubscribers
+} from './fiscal-month'
+import {
+  entities as FiscalQuarterEntities,
+  resolvers as FiscalQuarterResolvers,
+  subscribers as FiscalQuarterSubscribers
+} from './fiscal-quarter'
+import {
+  entities as FiscalYearEntities,
+  resolvers as FiscalYearResolvers,
+  subscribers as FiscalYearSubscribers
+} from './fiscal-year'
 
 export const entities = [
   /* ENTITIES */
@@ -38,7 +56,10 @@ export const entities = [
   ...FinancialStatementEntities,
   ...AccountingCategoryEntities,
   ...TransactionEntities,
-  ...AccountEntities
+  ...AccountEntities,
+  ...FiscalMonthEntities,
+  ...FiscalQuarterEntities,
+  ...FiscalYearEntities
 ]
 
 export const subscribers = [
@@ -47,7 +68,11 @@ export const subscribers = [
   ...FinancialStatementSubscribers,
   ...AccountingCategorySubscribers,
   ...TransactionSubscribers,
-  ...AccountSubscribers
+  ...AccountSubscribers,
+  ...FiscalYearSubscribers,
+  ...FiscalMonthSubscribers,
+  ...FiscalQuarterSubscribers,
+  ...FiscalYearSubscribers
 ]
 
 export const schema = {
@@ -57,6 +82,9 @@ export const schema = {
     ...FinancialStatementResolvers,
     ...AccountingCategoryResolvers,
     ...TransactionResolvers,
-    ...AccountResolvers
+    ...AccountResolvers,
+    ...FiscalMonthResolvers,
+    ...FiscalQuarterResolvers,
+    ...FiscalYearResolvers
   ]
 }

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

@@ -12,6 +12,7 @@ import { config } from '@things-factory/env'
 import { Domain } from '@things-factory/shell'
 
 import { Transaction, TransactionType } from './transaction'
+import { Account } from '../account/account'
 
 const ORMCONFIG = config.get('ormconfig', {})
 const DATABASE_TYPE = ORMCONFIG.type
@@ -42,20 +43,28 @@ export class TransactionHistory implements HistoryEntityInterface<Transaction> {
   version?: number = 1
 
   @ManyToOne(type => Domain)
-  @Field(type => Domain)
+  @Field({ nullable: true })
   domain?: Domain
 
   @RelationId((transaction: Transaction) => transaction.domain)
   domainId?: string
 
   @Column()
-  @Field()
-  name: string
+  @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
@@ -64,19 +73,38 @@ export class TransactionHistory implements HistoryEntityInterface<Transaction> {
   @Field({ nullable: true })
   type?: TransactionType
 
-  @Column({ nullable: true })
+  @ManyToOne(type => Account)
   @Field({ nullable: true })
-  params?: string
+  account?: Account
+
+  @RelationId((transaction: Transaction) => transaction.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({ type: 'timestamp', nullable: false })
+  @Field({ nullable: false, description: 'The exact date and time the transaction occurred' })
+  occurredAt: Date // 트랜잭션이 발생한 실제 시점(날짜와 시간)
+
+  @Column()
   @Field({ nullable: true })
   createdAt?: Date
 
-  @Column({ nullable: true })
+  @Column()
   @Field({ nullable: true })
   updatedAt?: Date
 
-  @Column({ nullable: true })
+  @Column()
   @Field({ nullable: true })
   deletedAt?: Date
 

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

@@ -16,10 +16,7 @@ export class TransactionQuery {
   }
 
   @Query(returns => TransactionList, { description: 'To fetch multiple Transactions' })
-  async transactions(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<TransactionList> {
+  async transactions(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<TransactionList> {
     const { domain } = context.state
 
     const queryBuilder = getQueryBuilderFromListParams({

package/server/service/transaction/transaction.ts

@@ -17,25 +17,32 @@ import { User } from '@things-factory/auth-base'
 import { Account } from '../account/account'
 
 export enum TransactionType {
-  Income, // 회사가 받은 돈을 나타냅니다. 예를 들어, 제품 판매 수익 등이 해당됩니다.
-  Expense, // 회사가 지불한 돈을 나타냅니다. 예를 들어, 임금, 재고 구매 비용, 건물 임대료 등이 해당됩니다.
-  Asset, // 회사가 소유한 자산을 나타냅니다. 예를 들어, 토지, 건물, 차량 등이 해당됩니다.
-  Liability, // 회사가 지불해야 하는 부채를 나타냅니다. 예를 들어, 대출, 미지급금 등이 해당됩니다.
-  Equity // 회사의 자본을 나타냅니다. 예를 들어, 자본금, 이익 잉여금 등이 해당됩니다.
+  Income,
+  Expense,
+  Asset,
+  Liability,
+  Equity
 }
 
 registerEnumType(TransactionType, {
   name: 'TransactionType',
-  description: 'type enumeration of a transaction'
+  description: 'Type enumeration of a transaction'
 })
 
+@ObjectType({ description: 'Entity for Transaction' })
 @Entity()
+@Index('ix_transaction_0', (transaction: Transaction) => [transaction.domain, transaction.occurredAt], {
+  unique: true,
+  where: '"deleted_at" IS NULL'
+})
 @Index(
-  'ix_transaction_0',
-  (transaction: Transaction) => [transaction.domain, transaction.name, transaction.deletedAt],
-  { unique: true }
+  'ix_transaction_1',
+  (transaction: Transaction) => [transaction.domain, transaction.year, transaction.quarter, transaction.month],
+  {
+    unique: true,
+    where: '"deleted_at" IS NULL'
+  }
 )
-@ObjectType({ description: 'Entity for Transaction' })
 export class Transaction {
   @PrimaryGeneratedColumn('uuid')
   @Field(type => ID)
@@ -46,7 +53,7 @@ export class Transaction {
   version?: number = 1
 
   @ManyToOne(type => Domain)
-  @Field(type => Domain)
+  @Field({ nullable: true })
   domain?: Domain
 
   @RelationId((transaction: Transaction) => transaction.domain)
@@ -60,10 +67,6 @@ export class Transaction {
   @Field({ nullable: true })
   description?: string
 
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  date?: Date
-
   @Column({ nullable: true })
   @Field({ nullable: true })
   currency?: string
@@ -87,6 +90,22 @@ export class Transaction {
   @RelationId((transaction: Transaction) => transaction.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({ type: 'timestamp', nullable: false })
+  @Field({ nullable: false, description: 'The exact date and time the transaction occurred' })
+  occurredAt: Date // 트랜잭션이 발생한 실제 시점(날짜와 시간)
+
   @CreateDateColumn()
   @Field({ nullable: true })
   createdAt?: Date

package/things-factory.config.js

@@ -10,7 +10,9 @@ export default {
     { tagname: 'transaction-list-page', page: 'transaction-list' },
     { tagname: 'accounting-category-list-page', page: 'accounting-category-list' },
     { tagname: 'financial-statement-list-page', page: 'financial-statement-list' },
-    { tagname: 'income-statement-list-page', page: 'income-statement-list' }
+    { tagname: 'income-statement-list-page', page: 'income-statement-list' },
+    { tagname: 'fiscal-year-list-page', page: 'fiscal-year-list' },
+    { tagname: 'fiscal-month-list-page', page: 'fiscal-month-list' }
   ],
   bootstrap
 }