OMDSCloud/dictation_server/src/repositories/accounts/accounts.repository.service.ts

import { Injectable } from '@nestjs/common';
import { DataSource, UpdateResult } from 'typeorm';
import { User } from '../users/entity/user.entity';
import { Account } from './entity/account.entity';
import { SortCriteria } from '../sort_criteria/entity/sort_criteria.entity';
import {
  getDirection,
  getTaskListSortableAttribute,
} from '../../common/types/sort/util';

export class AccountNotFoundError extends Error {}

@Injectable()
export class AccountsRepositoryService {
  constructor(private dataSource: DataSource) {}

  /**
   * 管理ユーザー無しでアカウントを作成する
   * @param companyName
   * @param country
   * @param dealerAccountId
   * @param tier
   * @returns create
   */
  async create(
    companyName: string,
    country: string,
    dealerAccountId: number | null,
    tier: number,
  ): Promise<Account> {
    const account = new Account();
    {
      account.parent_account_id = dealerAccountId;
      account.company_name = companyName;
      account.country = country;
      account.tier = tier;
    }

    const createdEntity = await this.dataSource.transaction(
      async (entityManager) => {
        const repo = entityManager.getRepository(Account);
        const newAccount = repo.create(account);
        const persisted = await repo.save(newAccount);
        return persisted;
      },
    );
    return createdEntity;
  }

  /**
   * 特定の情報でアカウントを更新する
   * @param account
   * @returns update
   */
  async update(account: Account): Promise<UpdateResult> {
    return await this.dataSource.transaction(async (entityManager) => {
      const repo = entityManager.getRepository(Account);
      return await repo.update({ id: account.id }, account);
    });
  }

  /**
   * プライマリ管理者とアカウントを同時に作成する
   * @param companyName
   * @param country
   * @param dealerAccountId
   * @param tier
   * @param adminExternalUserId
   * @param adminUserRole
   * @param adminUserAcceptedTermsVersion
   * @returns account/admin user
   */
  async createAccount(
    companyName: string,
    country: string,
    dealerAccountId: number | null,
    tier: number,
    adminExternalUserId: string,
    adminUserRole: string,
    adminUserAcceptedTermsVersion: string,
  ): Promise<{ newAccount: Account; adminUser: User }> {
    return await this.dataSource.transaction(async (entityManager) => {
      const account = new Account();
      {
        account.parent_account_id = dealerAccountId;
        account.company_name = companyName;
        account.country = country;
        account.tier = tier;
      }
      const accountsRepo = entityManager.getRepository(Account);
      const newAccount = accountsRepo.create(account);
      const persistedAccount = await accountsRepo.save(newAccount);

      // 作成されたAccountのIDを使用してユーザーを作成
      const user = new User();
      {
        user.account_id = persistedAccount.id;
        user.external_id = adminExternalUserId;
        user.role = adminUserRole;
        user.accepted_terms_version = adminUserAcceptedTermsVersion;
      }
      const usersRepo = entityManager.getRepository(User);
      const newUser = usersRepo.create(user);
      const persistedUser = await usersRepo.save(newUser);

      // アカウントに管理者を設定して更新
      persistedAccount.primary_admin_user_id = persistedUser.id;

      const result = await accountsRepo.update(
        { id: persistedAccount.id },
        persistedAccount,
      );

      // 想定外の更新が行われた場合はロールバックを行った上でエラー送出
      if (result.affected !== 1) {
        throw new Error(`invalid update. result.affected=${result.affected}`);
      }

      // ユーザーのタスクソート条件を作成
      const sortCriteria = new SortCriteria();
      {
        sortCriteria.parameter = getTaskListSortableAttribute('JOB_NUMBER');
        sortCriteria.direction = getDirection('ASC');
        sortCriteria.user_id = persistedUser.id;
      }
      const sortCriteriaRepo = entityManager.getRepository(SortCriteria);
      const newSortCriteria = sortCriteriaRepo.create(sortCriteria);
      await sortCriteriaRepo.save(newSortCriteria);

      return { newAccount: persistedAccount, adminUser: persistedUser };
    });
  }

  /**
   * アカウントIDからアカウント情報を取得する
   * @param id
   * @returns account
   */
  async findAccountById(id: number): Promise<Account> {
    const account = await this.dataSource.getRepository(Account).findOne({
      where: {
        id: id,
      },
    });

    if (!account) {
      throw new AccountNotFoundError();
    }
    return account;
  }
}