admin.controller.ts

import {
  Controller,
  Get,
  Post,
  Patch,
  Param,
  Body,
  Header,
  HttpCode,
  HttpStatus,
  BadRequestException,
} from '@nestjs/common';
import {
  ApiOperation,
  ApiTags,
  ApiResponse,
  ApiParam,
  ApiBody,
  ApiBearerAuth,
} from '@nestjs/swagger';
import { stringify } from 'csv-stringify/sync';

import { TopcoderMembersService } from 'src/shared/topcoder/members.service';
import { Role } from 'src/core/auth/auth.constants';
import { Roles, User } from 'src/core/auth/decorators';

import { UserInfo } from 'src/dto/user.type';

import { AdminService } from './admin.service';
import { ResponseDto, ResponseStatusType } from 'src/dto/api-response.dto';
import { WinningAuditDto, AuditPayoutDto } from './dto/audit.dto';

import { WinningRequestDto, SearchWinningResult } from 'src/dto/winning.dto';
import { WinningsRepository } from '../repository/winnings.repo';
import { WinningUpdateRequestDto } from './dto/winnings.dto';

@ApiTags('AdminWinnings')
@Controller('/admin')
@ApiBearerAuth()
export class AdminController {
  constructor(
    private readonly adminService: AdminService,
    private readonly winningsRepo: WinningsRepository,
    private readonly tcMembersService: TopcoderMembersService,
  ) {}

  @Post('/winnings/search')
  @Roles(Role.PaymentAdmin, Role.PaymentEditor, Role.PaymentViewer)
  @ApiOperation({
    summary: 'Search winnings with parameters',
    description: 'Roles: Payment Admin, Payment Editor, Payment Viewer',
  })
  @ApiBody({
    description: 'Winning request body',
    type: WinningRequestDto,
  })
  @ApiResponse({
    status: 200,
    description: 'Search winnings successfully.',
    type: ResponseDto<SearchWinningResult>,
  })
  @HttpCode(HttpStatus.OK)
  async searchWinnings(
    @Body() body: WinningRequestDto,
  ): Promise<ResponseDto<SearchWinningResult>> {
    const result = await this.winningsRepo.searchWinnings(body);
    if (result.error) {
      result.status = ResponseStatusType.ERROR;
    }

    result.status = ResponseStatusType.SUCCESS;

    return result;
  }

  @Post('/winnings/export')
  @Roles(Role.PaymentAdmin, Role.PaymentEditor, Role.PaymentViewer)
  @ApiOperation({
    summary: 'Export search winnings result in csv file format',
    description: 'Roles: Payment Admin, Payment Editor, Payment Viewer',
  })
  @ApiBody({
    description: 'Winning request body',
    type: WinningRequestDto,
  })
  @ApiResponse({
    status: 200,
    description: 'Export winnings successfully.',
    type: ResponseDto<SearchWinningResult>,
  })
  @HttpCode(HttpStatus.OK)
  @Header('Content-Type', 'text/csv')
  @Header('Content-Disposition', 'attachment; filename="winnings.csv"')
  async exportWinnings(@Body() body: WinningRequestDto) {
    const result = await this.winningsRepo.searchWinnings({
      ...body,
      limit: 999,
    });

    const handles = await this.tcMembersService.getHandlesByUserIds(
      result.data.winnings.map((d) => d.winnerId),
    );

    const csvRes = result.data.winnings.map((item) => {
      const payment =
        item.details && item.details.length > 0 ? item.details[0] : null;

      return {
        id: item.id,
        winnerId: item.winnerId,
        handle: handles[`${item.winnerId}`] ?? item.winnerId,
        origin: item.origin,
        category: item.category,
        title: item.title,
        description: item.description,
        externalId: item.externalId,
        status: payment?.status,
        totalAmount: payment?.totalAmount,
        datePaid: payment?.datePaid?.toISOString() ?? '',
        createdAt: item.createdAt.toISOString(),
        updatedAt: item.updatedAt?.toISOString() ?? '',
        releaseDate: item.releaseDate?.toISOString() ?? '',
        billingAccount: payment?.billingAccount,
      };
    });

    const output = stringify(csvRes, {
      header: true,
      columns: [
        { key: 'id', header: 'Winnings ID' },
        { key: 'winnerId', header: 'Winner ID' },
        { key: 'handle', header: 'Handle' },
        { key: 'origin', header: 'Origin' },
        { key: 'category', header: 'Category' },
        { key: 'title', header: 'Title' },
        { key: 'description', header: 'Description' },
        { key: 'externalId', header: 'External ID' },
        { key: 'status', header: 'Status' },
        { key: 'totalAmount', header: 'Total Amount' },
        { key: 'datePaid', header: 'Date Paid' },
        { key: 'createdAt', header: 'Created At' },
        { key: 'updatedAt', header: 'Updated At' },
        { key: 'releaseDate', header: 'Release Date' },
        { key: 'billingAccount', header: 'Billing Account' },
      ],
    });

    return output;
  }

  @Patch('/winnings')
  @Roles(Role.PaymentAdmin, Role.PaymentEditor)
  @ApiOperation({
    summary: 'Update winnings with given parameter',
    description:
      'User with role "Payment Admin" or "Payment Editor" can access. \n paymentStatus, releaseDate and paymentAmount cannot be null at the same time.r',
  })
  @ApiResponse({
    status: 200,
    description: 'Update winning data successfully.',
    type: ResponseDto<string>,
  })
  async updateWinning(
    @Body() body: WinningUpdateRequestDto,
    @User() user: UserInfo,
  ): Promise<ResponseDto<string>> {
    if (!body.paymentAmount && !body.releaseDate && !body.paymentStatus) {
      throw new BadRequestException(
        'paymentStatus, releaseDate and paymentAmount cannot be null at the same time.',
      );
    }

    const result = await this.adminService.updateWinnings(body, user.id);
    if (result.error) {
      result.status = ResponseStatusType.ERROR;
    }

    result.status = ResponseStatusType.SUCCESS;

    return result;
  }

  @Get('/winnings/:winningID/audit')
  @Roles(Role.PaymentAdmin, Role.PaymentEditor, Role.PaymentViewer)
  @ApiOperation({
    summary: 'List winning audit logs with given winning id',
    description: 'Roles: Payment Admin, Payment Editor, Payment Viewer',
  })
  @ApiParam({
    name: 'winningID',
    description: 'The ID of the winning',
    example: '2ccba36d-8db7-49da-94c9-b6c5b7bf47fb',
  })
  @ApiResponse({
    status: 200,
    description: 'List winning audit logs successfully.',
    type: ResponseDto<WinningAuditDto[]>,
  })
  async getWinningAudit(
    @Param('winningID') winningId: string,
  ): Promise<ResponseDto<WinningAuditDto[]>> {
    const result = await this.adminService.getWinningAudit(winningId);
    if (result.error) {
      result.status = ResponseStatusType.ERROR;
    }

    result.status = ResponseStatusType.SUCCESS;

    return result;
  }

  @Get('/winnings/:winningID/audit-payout')
  @Roles(Role.PaymentAdmin, Role.PaymentEditor, Role.PaymentViewer)
  @ApiOperation({
    summary: 'Fetch winnings payout audit logs with given winning id.',
    description:
      'User with role "Payment Admin", "Payment Editor" or "Payment Viewer" can access.',
  })
  @ApiParam({
    name: 'winningID',
    description: 'The ID of the winning',
    example: '2ccba36d-8db7-49da-94c9-b6c5b7bf47fb',
  })
  @ApiResponse({
    status: 200,
    description: 'List winning payout audit logs successfully.',
    type: ResponseDto<AuditPayoutDto[]>,
  })
  async getWinningAuditPayout(
    @Param('winningID') winningId: string,
  ): Promise<ResponseDto<AuditPayoutDto[]>> {
    const result = await this.adminService.getWinningAuditPayout(winningId);
    if (result.error) {
      result.status = ResponseStatusType.ERROR;
    }

    result.status = ResponseStatusType.SUCCESS;

    return result;
  }
}