API/src/controller/order.controller.ts

import {
  Body,
  Controller,
  Del,
  Get,
  Inject,
  Param,
  Post,
  Put,
  Query,
} from '@midwayjs/core';
import { ApiOkResponse } from '@midwayjs/swagger';
import {
  BooleanRes,
  OrderDetailRes,
  OrderListRes,
  OrderSaleListRes,
} from '../dto/reponse.dto';
import { OrderService } from '../service/order.service';
import { errorResponse, successResponse } from '../utils/response.util';
import {
  CreateOrderNoteDTO,
  QueryOrderDTO,
  QueryOrderSalesDTO,
} from '../dto/order.dto';
import { User } from '../decorator/user.decorator';
import { ErpOrderStatus } from '../enums/base.enum';

@Controller('/order')
export class OrderController {
  @Inject()
  orderService: OrderService;

  @ApiOkResponse({
    type: BooleanRes,
  })
  @Post('/syncOrder/:siteId')
  async syncOrder(@Param('siteId') siteId: string) {
    try {
      await this.orderService.syncOrders(siteId);
      return successResponse(true);
    } catch (error) {
      console.log(error);
      return errorResponse('同步失败');
    }
  }

  @ApiOkResponse({
    type: BooleanRes,
  })
  @Post('/syncOrder/:siteId/order/:orderId')
  async syncOrderById(
    @Param('siteId') siteId: string,
    @Param('orderId') orderId: string
  ) {
    try {
      await this.orderService.syncOrderById(siteId, orderId);
      return successResponse(true);
    } catch (error) {
      console.log(error);
      return errorResponse('同步失败');
    }
  }

  @ApiOkResponse({
    type: OrderListRes,
  })
  @Get('/getOrders')
  async getOrders(
    @Query()
    param: QueryOrderDTO,
    @User() user
  ) {
    try {
      const count = await this.orderService.getOrderStatus(param);
      const data = await this.orderService.getOrders(param, user);
      return successResponse({
        ...data,
        count,
      });
    } catch (error) {
      return errorResponse(error?.message || '获取失败');
    }
  }

  @ApiOkResponse({
    type: OrderSaleListRes,
  })
  @Get('/getOrderSales')
  async getOrderSales(@Query() param: QueryOrderSalesDTO) {
    try {
      if (param.isSource)
        return successResponse(await this.orderService.getOrderItems(param));
      return successResponse(await this.orderService.getOrderSales(param));
    } catch (error) {
      return errorResponse(error?.message || '获取失败');
    }
  }

  @ApiOkResponse({
    type: OrderDetailRes,
  })
  @Get('/:orderId')
  async getOrderDetail(@Param('orderId') orderId: number) {
    try {
      return successResponse(await this.orderService.getOrderDetail(orderId));
    } catch (error) {
      return errorResponse(error?.message || '获取失败');
    }
  }

  @ApiOkResponse({
    type: BooleanRes,
  })
  @Post('/updateOrderItems/:orderId')
  async updateOrderItems(
    @Param('orderId') orderId: number, 
    @Body() data: any
  ) {
    try {
      const res = await this.orderService.updateOrderSales(orderId, data);
      return successResponse(res);
    } catch (error) {
      return errorResponse(error?.message || '更新失败');
    }
  }

  @ApiOkResponse({
    type: BooleanRes,
  })
  @Del('/:id')
  async delOrder(@Param('id') id: number) {
    try {
      return successResponse(await this.orderService.delOrder(id));
    } catch (error) {
      return errorResponse(error?.message || '删除失败');
    }
  }

  @ApiOkResponse({
    type: BooleanRes,
  })
  @Post('/createNote')
  async createNote(@Body() data: CreateOrderNoteDTO, @User() user) {
    try {
      return successResponse(await this.orderService.createNote(user.id, data));
    } catch (error) {
      return errorResponse(error?.message || '创建失败');
    }
  }

  @ApiOkResponse()
  @Post('/getOrderByNumber')
  async getOrderByNumber(@Body('number') number: string) {
    try {
      return successResponse(await this.orderService.getOrderByNumber(number));
    } catch (error) {
      return errorResponse(error?.message || '创建失败');
    }
  }

  @ApiOkResponse()
  @Post('/order/cancel/:id')
  async cancelOrder(@Param('id') id: number) {
    try {
      return successResponse(await this.orderService.cancelOrder(id));
    } catch (error) {
      return errorResponse(error?.message || '创建失败');
    }
  }

  @ApiOkResponse()
  @Post('/order/refund/:id')
  async refundOrder(@Param('id') id: number) {
    try {
      return successResponse(await this.orderService.refundOrder(id));
    } catch (error) {
      return errorResponse(error?.message || '创建失败');
    }
  }

  @ApiOkResponse()
  @Post('/order/completed/:id')
  async completedOrder(@Param('id') id: number) {
    try {
      return successResponse(await this.orderService.completedOrder(id));
    } catch (error) {
      return errorResponse(error?.message || '创建失败');
    }
  }

  @ApiOkResponse()
  @Put('/order/status/:id')
  async changeStatus(
    @Param('id') id: number,
    @Body('status') status: ErpOrderStatus
  ) {
    try {
      return successResponse(await this.orderService.changeStatus(id, status));
    } catch (error) {
      return errorResponse(error?.message || '创建失败');
    }
  }

  @ApiOkResponse()
  @Post('/order/create')
  async createOrder(@Body() data: Record<string, any>) {
    try {
      return successResponse(await this.orderService.createOrder(data));
    } catch (error) {
      return errorResponse(error?.message || '创建失败');
    }
  }

  @ApiOkResponse()
  @Post('/order/pengding/items')
  async pengdingItems(@Body() data: Record<string, any>) {
    try {
      return successResponse(await this.orderService.pengdingItems(data));
    } catch (error) {
      return errorResponse(error?.message || '获取失败');
    }
  }
}