@things-factory/accounting 6.0.46

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

@@ -0,0 +1,143 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { createAttachment, deleteAttachmentsByRef } from '@things-factory/attachment-base'
+
+import { Transaction } from './transaction'
+import { NewTransaction, TransactionPatch } from './transaction-type'
+
+@Resolver(Transaction)
+export class TransactionMutation {
+  @Directive('@transaction')
+  @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 tx.getRepository(Transaction).save({
+      ...transaction,
+      domain,
+      creator: user,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @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 = tx.getRepository(Transaction)
+    const transaction = await repository.findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+
+    const result = await repository.save({
+      ...transaction,
+      ...patch,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @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 = tx.getRepository(Transaction)
+
+    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')
+  @Mutation(returns => Boolean, { description: 'To delete Transaction' })
+  async deleteTransaction(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Transaction).delete({ domain: { id: domain.id }, id })
+    await deleteAttachmentsByRef(null, { refBys: [id] }, context)
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @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 tx.getRepository(Transaction).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 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 tx.getRepository(Transaction).save({ domain, ...transaction })
+      })
+    )
+
+    return true
+  }
+}

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

@@ -0,0 +1,48 @@
+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 {
+  @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 }
+    })
+  }
+
+  @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

@@ -0,0 +1,48 @@
+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
+}

package/server/service/transaction/transaction.ts

@@ -0,0 +1,115 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  DeleteDateColumn,
+  Entity,
+  Index,
+  Column,
+  RelationId,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  VersionColumn
+} from 'typeorm'
+import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
+
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { Account } from '../account/account'
+
+export enum TransactionType {
+  Income, // 회사가 받은 돈을 나타냅니다. 예를 들어, 제품 판매 수익 등이 해당됩니다.
+  Expense, // 회사가 지불한 돈을 나타냅니다. 예를 들어, 임금, 재고 구매 비용, 건물 임대료 등이 해당됩니다.
+  Asset, // 회사가 소유한 자산을 나타냅니다. 예를 들어, 토지, 건물, 차량 등이 해당됩니다.
+  Liability, // 회사가 지불해야 하는 부채를 나타냅니다. 예를 들어, 대출, 미지급금 등이 해당됩니다.
+  Equity // 회사의 자본을 나타냅니다. 예를 들어, 자본금, 이익 잉여금 등이 해당됩니다.
+}
+
+registerEnumType(TransactionType, {
+  name: 'TransactionType',
+  description: 'type enumeration of a transaction'
+})
+
+@Entity()
+@Index(
+  'ix_transaction_0',
+  (transaction: Transaction) => [transaction.domain, transaction.name, transaction.deletedAt],
+  { unique: true }
+)
+@ObjectType({ description: 'Entity for Transaction' })
+export class Transaction {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @VersionColumn()
+  @Field({ nullable: true })
+  version?: number = 1
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((transaction: Transaction) => transaction.domain)
+  domainId?: string
+
+  @Column()
+  @Field({ nullable: true })
+  name?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  date?: Date
+
+  @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
+
+  @ManyToOne(type => Account)
+  @Field({ nullable: true })
+  account?: Account
+
+  @RelationId((transaction: Transaction) => transaction.account)
+  accountId?: 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((transaction: Transaction) => transaction.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((transaction: Transaction) => transaction.updater)
+  updaterId?: string
+}

package/server/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig-base.json",
+  "compilerOptions": {
+    "strict": false,
+    "module": "commonjs",
+    "outDir": "../dist-server",
+    "baseUrl": "./"
+  },
+  "include": ["./**/*"]
+}

package/things-factory.config.js

@@ -0,0 +1,16 @@
+import route from './dist-client/route'
+import bootstrap from './dist-client/bootstrap'
+
+export default {
+  route,
+  routes: [
+    { tagname: 'accounting-main', page: 'accounting-main' },
+    { tagname: 'ledger-list-page', page: 'ledger-list' },
+    { tagname: 'account-list-page', page: 'account-list' },
+    { 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' }
+  ],
+  bootstrap
+}

package/translations/en.json

@@ -0,0 +1 @@
+{}

package/translations/ko.json

@@ -0,0 +1 @@
+{}

package/translations/ms.json

@@ -0,0 +1 @@
+{}

package/translations/zh.json

@@ -0,0 +1 @@
+{}