@things-factory/accounting 7.0.6 → 7.1.2

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

@@ -1,7 +1,6 @@
 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 { IncomeStatement } from './income-statement'
 import { NewIncomeStatement, IncomeStatementPatch } from './income-statement-type'
@@ -9,6 +8,7 @@ import { NewIncomeStatement, IncomeStatementPatch } from './income-statement-typ
 @Resolver(IncomeStatement)
 export class IncomeStatementMutation {
   @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
   @Mutation(returns => IncomeStatement, { description: 'To create new IncomeStatement' })
   async createIncomeStatement(
     @Arg('incomeStatement') incomeStatement: NewIncomeStatement,
@@ -16,7 +16,7 @@ export class IncomeStatementMutation {
   ): Promise<IncomeStatement> {
     const { domain, user, tx } = context.state
 
-    const result = await tx.getRepository(IncomeStatement).save({
+    const result = await getRepository(IncomeStatement, tx).save({
       ...incomeStatement,
       domain,
       creator: user,
@@ -27,6 +27,7 @@ export class IncomeStatementMutation {
   }
 
   @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
   @Mutation(returns => IncomeStatement, { description: 'To modify IncomeStatement information' })
   async updateIncomeStatement(
     @Arg('id') id: string,
@@ -35,7 +36,7 @@ export class IncomeStatementMutation {
   ): Promise<IncomeStatement> {
     const { domain, user, tx } = context.state
 
-    const repository = tx.getRepository(IncomeStatement)
+    const repository = getRepository(IncomeStatement, tx)
     const incomeStatement = await repository.findOne({
       where: { domain: { id: domain.id }, id }
     })
@@ -50,6 +51,7 @@ export class IncomeStatementMutation {
   }
 
   @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
   @Mutation(returns => [IncomeStatement], { description: "To modify multiple IncomeStatements' information" })
   async updateMultipleIncomeStatement(
     @Arg('patches', type => [IncomeStatementPatch]) patches: IncomeStatementPatch[],
@@ -60,7 +62,7 @@ export class IncomeStatementMutation {
     let results = []
     const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
     const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const incomeStatementRepo = tx.getRepository(IncomeStatement)
+    const incomeStatementRepo = getRepository(IncomeStatement, tx)
 
     if (_createRecords.length > 0) {
       for (let i = 0; i < _createRecords.length; i++) {
@@ -96,17 +98,18 @@ export class IncomeStatementMutation {
   }
 
   @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
   @Mutation(returns => Boolean, { description: 'To delete IncomeStatement' })
   async deleteIncomeStatement(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
-    await tx.getRepository(IncomeStatement).delete({ domain: { id: domain.id }, id })
-    await deleteAttachmentsByRef(null, { refBys: [id] }, context)
+    await getRepository(IncomeStatement, tx).delete({ domain: { id: domain.id }, id })
 
     return true
   }
 
   @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
   @Mutation(returns => Boolean, { description: 'To delete multiple IncomeStatements' })
   async deleteIncomeStatements(
     @Arg('ids', type => [String]) ids: string[],
@@ -114,17 +117,16 @@ export class IncomeStatementMutation {
   ): Promise<boolean> {
     const { domain, tx } = context.state
 
-    await tx.getRepository(IncomeStatement).delete({
+    await getRepository(IncomeStatement, 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 IncomeStatements' })
   async importIncomeStatements(
     @Arg('incomeStatements', type => [IncomeStatementPatch]) incomeStatements: IncomeStatementPatch[],

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

@@ -6,6 +6,7 @@ import { IncomeStatementList } from './income-statement-type'
 
 @Resolver(IncomeStatement)
 export class IncomeStatementQuery {
+  @Directive('@privilege(category: "accounting", privilege: "query")')
   @Query(returns => IncomeStatement!, { nullable: true, description: 'To fetch a IncomeStatement' })
   async incomeStatement(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<IncomeStatement> {
     const { domain } = context.state
@@ -15,11 +16,9 @@ export class IncomeStatementQuery {
     })
   }
 
+  @Directive('@privilege(category: "accounting", privilege: "query")')
   @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

@@ -7,14 +7,17 @@ import {
   Column,
   RelationId,
   ManyToOne,
+  OneToMany,
   PrimaryGeneratedColumn,
   VersionColumn
 } from 'typeorm'
-import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
+import { ObjectType, Field, ID, registerEnumType } from 'type-graphql'
 
 import { Domain } from '@things-factory/shell'
 import { User } from '@things-factory/auth-base'
 
+import { IncomeStatementLineItem } from './income-statement-line-item'
+
 export enum IncomeStatementStatus {
   STATUS_A = 'STATUS_A',
   STATUS_B = 'STATUS_B'
@@ -22,84 +25,96 @@ export enum IncomeStatementStatus {
 
 registerEnumType(IncomeStatementStatus, {
   name: 'IncomeStatementStatus',
-  description: 'state enumeration of a incomeStatement'
+  description: 'State enumeration of an income statement' // 손익계산서의 상태 열거형
 })
 
-// 손익계산서
+// 손익계산서 (Income Statement)
 @Entity()
 @Index(
   'ix_income_statement_0',
-  (incomeStatement: IncomeStatement) => [incomeStatement.domain, incomeStatement.deletedAt],
-  { unique: true }
+  (incomeStatement: IncomeStatement) => [
+    incomeStatement.domain,
+    incomeStatement.year,
+    incomeStatement.quarter,
+    incomeStatement.month
+  ],
+  {
+    unique: true,
+    where: '"deleted_at" IS NULL' // 삭제되지 않은 경우에만 유니크
+  }
 )
-@ObjectType({ description: 'Entity for IncomeStatement' })
+@ObjectType({ description: 'Entity for IncomeStatement, representing the profit and loss report' }) // 손익계산서 엔티티
 export class IncomeStatement {
   @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
+  @Field(type => ID, { description: 'Unique identifier for the income statement' })
+  readonly id: string // 고유 식별자 (UUID)
 
   @VersionColumn()
-  @Field({ nullable: true })
-  version?: number = 1
+  @Field({ nullable: true, description: 'Version number for optimistic locking' })
+  version?: number = 1 // 낙관적 잠금을 위한 버전 관리 필드
 
   @ManyToOne(type => Domain)
-  @Field(type => Domain)
-  domain?: Domain
+  @Field({ nullable: true, description: 'The domain to which this income statement belongs' })
+  domain?: Domain // 이 손익계산서가 속한 도메인
 
   @RelationId((incomeStatement: IncomeStatement) => incomeStatement.domain)
-  domainId?: string
+  domainId?: string // 도메인의 ID
 
   @Column({ nullable: true })
-  @Field({ nullable: true, description: 'fiscal year' })
-  year?: number
+  @Field({ nullable: true, description: 'Fiscal year of the income statement' })
+  year?: number // 회계 연도
 
   @Column({ nullable: true })
-  @Field({ nullable: true, description: 'fiscal quarter' })
-  quarter?: number
+  @Field({ nullable: true, description: 'Fiscal quarter of the income statement' })
+  quarter?: number // 회계 분기
 
   @Column({ nullable: true })
-  @Field({ nullable: true })
-  month?: number
+  @Field({ nullable: true, description: 'Fiscal month of the income statement' })
+  month?: number // 회계 월
 
   @Column({ nullable: true })
-  @Field({ nullable: true })
-  revenue?: number
+  @Field({ nullable: true, description: 'Total revenue recorded in the income statement' })
+  revenue?: number // 손익계산서에 기록된 총수익
 
   @Column({ nullable: true })
-  @Field({ nullable: true })
-  expense?: number
+  @Field({ nullable: true, description: 'Total expenses recorded in the income statement' })
+  expense?: number // 손익계산서에 기록된 총비용
 
   @Column({ nullable: true })
-  @Field({ nullable: true })
-  netIncome?: number
+  @Field({ nullable: true, description: 'Net income calculated as revenue minus expenses' })
+  netIncome?: number // 총수익에서 총비용을 뺀 순이익
 
   @Column({ nullable: true })
-  @Field({ nullable: true })
-  active?: boolean
+  @Field({ nullable: true, description: 'Indicates whether this income statement is active' })
+  active?: boolean // 이 손익계산서가 활성 상태인지 여부
+
+  @OneToMany(type => IncomeStatementLineItem, lineItem => lineItem.statement)
+  @Field(type => [IncomeStatementLineItem], { nullable: true })
+  lineItems?: IncomeStatementLineItem[] // 계정별 브레이크다운
 
   @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt?: Date
+  @Field({ nullable: true, description: 'The date and time when the income statement was created' })
+  createdAt?: Date // 손익계산서가 생성된 날짜 및 시간
 
   @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt?: Date
+  @Field({ nullable: true, description: 'The date and time when the income statement was last updated' })
+  updatedAt?: Date // 손익계산서가 마지막으로 업데이트된 날짜 및 시간
 
   @DeleteDateColumn()
-  @Field({ nullable: true })
-  deletedAt?: Date
+  @Field({ nullable: true, description: 'The date and time when the income statement was deleted' })
+  deletedAt?: Date // 손익계산서가 삭제된 날짜 및 시간
 
   @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  creator?: User
+  @Field(type => User, { nullable: true, description: 'The user who created the income statement' })
+  creator?: User // 손익계산서를 생성한 사용자
 
   @RelationId((incomeStatement: IncomeStatement) => incomeStatement.creator)
-  creatorId?: string
+  creatorId?: string // 손익계산서를 생성한 사용자의 ID
 
   @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
+  @Field(type => User, { nullable: true, description: 'The user who last updated the income statement' })
+  updater?: User // 손익계산서를 마지막으로 업데이트한 사용자
 
   @RelationId((incomeStatement: IncomeStatement) => incomeStatement.updater)
-  updaterId?: string
+  updaterId?: string // 손익계산서를 업데이트한 사용자의 ID
 }

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

@@ -1,9 +1,10 @@
 import { IncomeStatement } from './income-statement'
+import { IncomeStatementLineItem } from './income-statement-line-item'
 import { IncomeStatementHistory } from './income-statement-history'
 import { IncomeStatementQuery } from './income-statement-query'
 import { IncomeStatementMutation } from './income-statement-mutation'
 import { IncomeStatementHistoryEntitySubscriber } from './event-subscriber'
 
-export const entities = [IncomeStatement, IncomeStatementHistory]
+export const entities = [IncomeStatement, IncomeStatementLineItem, IncomeStatementHistory]
 export const resolvers = [IncomeStatementQuery, IncomeStatementMutation]
 export const subscribers = [IncomeStatementHistoryEntitySubscriber]

package/server/service/index.ts

@@ -3,7 +3,12 @@ export * from './income-statement/income-statement'
 export * from './financial-statement/financial-statement'
 export * from './accounting-category/accounting-category'
 export * from './transaction/transaction'
+export * from './payment/payment'
 export * from './account/account'
+export * from './accounting-document/accounting-document'
+export * from './fiscal-month/fiscal-month'
+export * from './fiscal-quarter/fiscal-quarter'
+export * from './fiscal-year/fiscal-year'
 
 /* IMPORT ENTITIES AND RESOLVERS */
 import {
@@ -26,11 +31,36 @@ import {
   resolvers as TransactionResolvers,
   subscribers as TransactionSubscribers
 } from './transaction'
+import {
+  entities as PaymentEntities,
+  resolvers as PaymentResolvers,
+  subscribers as PaymentSubscribers
+} from './payment'
 import {
   entities as AccountEntities,
   resolvers as AccountResolvers,
   subscribers as AccountSubscribers
 } from './account'
+import {
+  entities as AccountingDocumentEntities,
+  resolvers as AccountingDocumentResolvers,
+  subscribers as AccountingDocumentSubscribers
+} from './accounting-document'
+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 +68,12 @@ export const entities = [
   ...FinancialStatementEntities,
   ...AccountingCategoryEntities,
   ...TransactionEntities,
-  ...AccountEntities
+  ...AccountEntities,
+  ...AccountingDocumentEntities,
+  ...PaymentEntities,
+  ...FiscalMonthEntities,
+  ...FiscalQuarterEntities,
+  ...FiscalYearEntities
 ]
 
 export const subscribers = [
@@ -47,7 +82,13 @@ export const subscribers = [
   ...FinancialStatementSubscribers,
   ...AccountingCategorySubscribers,
   ...TransactionSubscribers,
-  ...AccountSubscribers
+  ...PaymentSubscribers,
+  ...AccountSubscribers,
+  ...AccountingDocumentSubscribers,
+  ...FiscalYearSubscribers,
+  ...FiscalMonthSubscribers,
+  ...FiscalQuarterSubscribers,
+  ...FiscalYearSubscribers
 ]
 
 export const schema = {
@@ -57,6 +98,11 @@ export const schema = {
     ...FinancialStatementResolvers,
     ...AccountingCategoryResolvers,
     ...TransactionResolvers,
-    ...AccountResolvers
+    ...PaymentResolvers,
+    ...AccountResolvers,
+    ...AccountingDocumentResolvers,
+    ...FiscalMonthResolvers,
+    ...FiscalQuarterResolvers,
+    ...FiscalYearResolvers
   ]
 }

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

@@ -0,0 +1,17 @@
+import { EventSubscriber } from 'typeorm'
+
+import { HistoryEntitySubscriber } from '@operato/typeorm-history'
+
+import { Payment } from './payment'
+import { PaymentHistory } from './payment-history'
+
+@EventSubscriber()
+export class PaymentHistoryEntitySubscriber extends HistoryEntitySubscriber<Payment, PaymentHistory> {
+  public get entity() {
+    return Payment
+  }
+
+  public get historyEntity() {
+    return PaymentHistory
+  }
+}

package/server/service/payment/index.ts

@@ -0,0 +1,9 @@
+import { Payment } from './payment'
+import { PaymentHistory } from './payment-history'
+import { PaymentHistoryEntitySubscriber } from './event-subscriber'
+import { PaymentQuery } from './payment-query'
+import { PaymentMutation } from './payment-mutation'
+
+export const entities = [Payment, PaymentHistory]
+export const resolvers = [PaymentQuery, PaymentMutation]
+export const subscribers = [PaymentHistoryEntitySubscriber]

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

@@ -0,0 +1,126 @@
+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 } from '../transaction/transaction'
+import { Payment, PaymentDirection } from './payment'
+
+const ORMCONFIG = config.get('ormconfig', {})
+const DATABASE_TYPE = ORMCONFIG.type
+
+@Entity()
+@Index(
+  'ix_payment_history_0',
+  (paymentHistory: PaymentHistory) => [paymentHistory.originalId, paymentHistory.version],
+  { unique: true }
+)
+@Index(
+  'ix_payment_history_1',
+  (paymentHistory: PaymentHistory) => [paymentHistory.domain, paymentHistory.originalId, paymentHistory.version],
+  { unique: true }
+)
+@ObjectType({ description: 'History Entity of Payment' })
+export class PaymentHistory implements HistoryEntityInterface<Payment> {
+  @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((payment: Payment) => payment.domain)
+  domainId?: string
+
+  @ManyToOne(type => Transaction, transaction => transaction.payments)
+  @Field(type => Transaction)
+  transaction: Transaction
+
+  @RelationId((payment: Payment) => payment.transaction)
+  transactionId: string
+
+  @Column({ nullable: false })
+  @Field({ nullable: false })
+  amount: number
+
+  @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 })
+  paidAt: Date
+
+  @Column({ nullable: false })
+  @Field(type => PaymentDirection)
+  direction: PaymentDirection
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  note?: string
+
+  @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(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((payment: Payment) => payment.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((payment: Payment) => payment.updater)
+  updaterId?: string
+
+  @Field(type => String, { nullable: true })
+  thumbnail?: string
+
+  @HistoryOriginalIdColumn()
+  public originalId!: string
+
+  @HistoryActionColumn({
+    nullable: false,
+    type:
+      DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
+        ? 'enum'
+        : DATABASE_TYPE == 'oracle'
+          ? 'varchar2'
+          : 'smallint',
+    enum: HistoryActionType
+  })
+  public action!: HistoryActionType
+}

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

@@ -0,0 +1,139 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { In } from 'typeorm'
+import { getRepository } from '@things-factory/shell'
+
+import { Payment } from './payment'
+import { NewPayment, PaymentPatch } from './payment-type'
+
+@Resolver(Payment)
+export class PaymentMutation {
+  @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
+  @Mutation(returns => Payment, { description: 'To create new Payment' })
+  async createPayment(@Arg('payment') payment: NewPayment, @Ctx() context: ResolverContext): Promise<Payment> {
+    const { domain, user, tx } = context.state
+
+    const result = await getRepository(Payment, tx).save({
+      ...payment,
+      domain,
+      creator: user,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
+  @Mutation(returns => Payment, { description: 'To modify Payment information' })
+  async updatePayment(
+    @Arg('id') id: string,
+    @Arg('patch') patch: PaymentPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<Payment> {
+    const { domain, user, tx } = context.state
+
+    const repository = getRepository(Payment, tx)
+    const payment = await repository.findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+
+    const result = await repository.save({
+      ...payment,
+      ...patch,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
+  @Mutation(returns => [Payment], { description: "To modify multiple Payments' information" })
+  async updateMultiplePayment(
+    @Arg('patches', type => [PaymentPatch]) patches: PaymentPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<Payment[]> {
+    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 paymentRepo = getRepository(Payment, tx)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await paymentRepo.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 payment = await paymentRepo.findOneBy({ id: updateRecord.id })
+
+        const result = await paymentRepo.save({
+          ...payment,
+          ...updateRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
+  @Mutation(returns => Boolean, { description: 'To delete Payment' })
+  async deletePayment(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await getRepository(Payment, tx).delete({ domain: { id: domain.id }, id })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "accounting", privilege: "mutation")')
+  @Mutation(returns => Boolean, { description: 'To delete multiple Payments' })
+  async deletePayments(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await getRepository(Payment, 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 Payments' })
+  async importPayments(
+    @Arg('payments', type => [PaymentPatch]) payments: PaymentPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await Promise.all(
+      payments.map(async (payment: PaymentPatch) => {
+        const createdPayment: Payment = await getRepository(Payment, tx).save({ domain, ...payment })
+      })
+    )
+
+    return true
+  }
+}