Assist_Design/apps/bff/src/orders/orders.controller.ts

import { Body, Controller, Get, Param, Post, UseGuards, Request, BadRequestException } from "@nestjs/common";
import { OrderOrchestrator } from "./services/order-orchestrator.service";
import { ApiBearerAuth, ApiOperation, ApiParam, ApiResponse, ApiTags } from "@nestjs/swagger";
import { JwtAuthGuard } from "../auth/guards/jwt-auth.guard";
import { RequestWithUser } from "../auth/auth.types";
import { Logger } from "nestjs-pino";
import { IsString, IsArray, IsIn, IsNotEmpty, IsOptional, IsObject, ValidateNested } from "class-validator";
import { Type } from "class-transformer";

class OrderConfigurations {
  // Activation (All order types)
  @IsOptional()
  @IsIn(["Immediate", "Scheduled"])
  activationType?: "Immediate" | "Scheduled";
  
  @IsOptional()
  @IsString()
  scheduledAt?: string;

  // Internet specific
  @IsOptional()
  @IsIn(["IPoE-BYOR", "IPoE-HGW", "PPPoE"])
  accessMode?: "IPoE-BYOR" | "IPoE-HGW" | "PPPoE";

  // SIM specific
  @IsOptional()
  @IsIn(["eSIM", "Physical SIM"])
  simType?: "eSIM" | "Physical SIM";

  @IsOptional()
  @IsString()
  eid?: string; // Required for eSIM

  // MNP/Porting
  @IsOptional()
  @IsString()
  isMnp?: string; // "true" | "false"

  @IsOptional()
  @IsString()
  mnpNumber?: string;

  @IsOptional()
  @IsString()
  mnpExpiry?: string;

  @IsOptional()
  @IsString()
  mnpPhone?: string;

  @IsOptional()
  @IsString()
  mvnoAccountNumber?: string;

  @IsOptional()
  @IsString()
  portingLastName?: string;

  @IsOptional()
  @IsString()
  portingFirstName?: string;

  @IsOptional()
  @IsString()
  portingLastNameKatakana?: string;

  @IsOptional()
  @IsString()
  portingFirstNameKatakana?: string;

  @IsOptional()
  @IsIn(["Male", "Female", "Corporate/Other"])
  portingGender?: "Male" | "Female" | "Corporate/Other";

  @IsOptional()
  @IsString()
  portingDateOfBirth?: string;

  // VPN region is inferred from product VPN_Region__c field, no user input needed
}

class CreateOrderBody {
  @IsString()
  @IsNotEmpty()
  @IsIn(["Internet", "SIM", "VPN", "Other"])
  orderType: "Internet" | "SIM" | "VPN" | "Other";

  @IsArray()
  @IsString({ each: true })
  @IsNotEmpty({ each: true })
  skus: string[];

  @IsOptional()
  @IsObject()
  @ValidateNested()
  @Type(() => OrderConfigurations)
  configurations?: OrderConfigurations;
}

@ApiTags("orders")
@Controller("orders")
export class OrdersController {
  constructor(
    private orderOrchestrator: OrderOrchestrator,
    private readonly logger: Logger
  ) {}

  @UseGuards(JwtAuthGuard)
  @ApiBearerAuth()
  @Post()
  @ApiOperation({ summary: "Create Salesforce Order using clean architecture" })
  @ApiResponse({ status: 201 })
  async create(@Request() req: RequestWithUser, @Body() body: CreateOrderBody) {
    this.logger.log({ 
      body, 
      userId: req.user?.id,
      orderType: body?.orderType,
      skus: body?.skus,
      configurations: body?.configurations
    }, "Order creation request received");
    
    try {
      return await this.orderOrchestrator.createOrder(req.user.id, body);
    } catch (error) {
      this.logger.error({ 
        error: error instanceof Error ? error.message : String(error), 
        body, 
        userId: req.user?.id 
      }, "Order creation failed");
      throw error;
    }
  }

  @UseGuards(JwtAuthGuard)
  @ApiBearerAuth()
  @Get("user")
  @ApiOperation({ summary: "Get user's orders" })
  async getUserOrders(@Request() req: RequestWithUser) {
    return this.orderOrchestrator.getOrdersForUser(req.user.id);
  }

  @UseGuards(JwtAuthGuard)
  @ApiBearerAuth()
  @Get(":sfOrderId")
  @ApiOperation({ summary: "Get order summary/status" })
  @ApiParam({ name: "sfOrderId", type: String })
  async get(@Request() req: RequestWithUser, @Param("sfOrderId") sfOrderId: string) {
    return this.orderOrchestrator.getOrder(sfOrderId);
  }

  @UseGuards(JwtAuthGuard)
  @ApiBearerAuth()
  @Post(":sfOrderId/provision")
  @ApiOperation({ summary: "Trigger provisioning for an approved order" })
  @ApiParam({ name: "sfOrderId", type: String })
  async provision(@Request() req: RequestWithUser, @Param("sfOrderId") sfOrderId: string) {
    return this.orderOrchestrator.provisionOrder(req.user.id, sfOrderId);
  }
}