feat: complete PO lifecycle, add PO line items, and branch CRUD

- BE-118: TransferStatus.COMPLETED and CANCELLED are now reachable via complete() and cancel() methods on TransfersService
- BE-119: PurchaseOrdersService now supports full DRAFT -> SUBMITTED -> APPROVED -> RECEIVED lifecycle with submit(), approve(), and guarded receive()
- BE-120: Added PurchaseOrderLineItem entity; totalAmount is computed from line items; added update() for draft POs and cancel() for draft/submitted POs
- BE-121: BranchesService gains update() and delete() with referential integrity check; BranchesController gains PATCH and DELETE routes

Closes #1260
Closes #1261
Closes #1262
Closes #1263

Author: hikmat67-code

backend/src/branches/branches.controller.ts

@@ -1,4 +1,4 @@
-import { Controller, Get, Post, Body, Param } from '@nestjs/common';
+import { Controller, Get, Post, Patch, Delete, Body, Param } from '@nestjs/common';
 import {
   ApiTags,
   ApiOperation,
@@ -34,4 +34,18 @@ export class BranchesController {
   findOne(@Param('id') id: string) {
     return this.branchesService.findById(id);
   }
+
+  @Patch(':id')
+  @ApiOperation({ summary: 'Update a branch' })
+  @ApiResponse({ status: 200, description: 'Branch updated' })
+  update(@Param('id') id: string, @Body() dto: any) {
+    return this.branchesService.update(id, dto);
+  }
+
+  @Delete(':id')
+  @ApiOperation({ summary: 'Delete a branch' })
+  @ApiResponse({ status: 200, description: 'Branch deleted' })
+  delete(@Param('id') id: string) {
+    return this.branchesService.delete(id);
+  }
 }

backend/src/branches/branches.module.ts

@@ -1,11 +1,12 @@
 import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { Branch } from './entities/branch.entity';
+import { Asset } from '../assets/entities/asset.entity';
 import { BranchesService } from './branches.service';
 import { BranchesController } from './branches.controller';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([Branch])],
+  imports: [TypeOrmModule.forFeature([Branch, Asset])],
   providers: [BranchesService],
   controllers: [BranchesController],
   exports: [BranchesService],

backend/src/branches/branches.service.ts

@@ -1,13 +1,20 @@
-import { Injectable, NotFoundException } from '@nestjs/common';
+import {
+  Injectable,
+  NotFoundException,
+  BadRequestException,
+} from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Repository } from 'typeorm';
 import { Branch } from './entities/branch.entity';
+import { Asset } from '../assets/entities/asset.entity';
 
 @Injectable()
 export class BranchesService {
   constructor(
     @InjectRepository(Branch)
     private readonly branchRepo: Repository<Branch>,
+    @InjectRepository(Asset)
+    private readonly assetRepo: Repository<Asset>,
   ) {}
 
   async findAll() {
@@ -24,4 +31,23 @@ export class BranchesService {
     const branch = this.branchRepo.create(dto);
     return this.branchRepo.save(branch);
   }
+
+  async update(id: string, dto: Partial<Branch>) {
+    const branch = await this.findById(id);
+    Object.assign(branch, dto);
+    return this.branchRepo.save(branch);
+  }
+
+  async delete(id: string) {
+    const branch = await this.findById(id);
+    const assetCount = await this.assetRepo.count({
+      where: { branchId: id },
+    });
+    if (assetCount > 0) {
+      throw new BadRequestException(
+        `Cannot delete branch: ${assetCount} asset(s) are still assigned to it`,
+      );
+    }
+    return this.branchRepo.remove(branch);
+  }
 }

backend/src/purchase-orders/entities/purchase-order.entity.ts

@@ -4,6 +4,7 @@ import {
   PrimaryGeneratedColumn,
   CreateDateColumn,
   UpdateDateColumn,
+  OneToMany,
 } from 'typeorm';
 
 export enum POStatus {
@@ -14,6 +15,33 @@ export enum POStatus {
   CANCELLED = 'CANCELLED',
 }
 
+@Entity('purchase_order_line_items')
+export class PurchaseOrderLineItem {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column()
+  purchaseOrderId: string;
+
+  @Column()
+  description: string;
+
+  @Column({ type: 'integer', default: 1 })
+  quantity: number;
+
+  @Column({ type: 'integer', default: 0 })
+  unitCost: number;
+
+  @Column({ nullable: true })
+  category?: string;
+
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
+}
+
 @Entity('purchase_orders')
 export class PurchaseOrder {
   @PrimaryGeneratedColumn('uuid')
@@ -37,6 +65,13 @@ export class PurchaseOrder {
   @Column({ nullable: true })
   createdByUserId?: string;
 
+  @OneToMany(
+    () => PurchaseOrderLineItem,
+    (item) => item.purchaseOrderId,
+    { cascade: true },
+  )
+  lineItems?: PurchaseOrderLineItem[];
+
   @CreateDateColumn()
   createdAt: Date;
 

backend/src/purchase-orders/purchase-orders.controller.ts

@@ -1,4 +1,4 @@
-import { Controller, Get, Post, Param, Body } from '@nestjs/common';
+import { Controller, Get, Post, Patch, Param, Body, Req } from '@nestjs/common';
 import {
   ApiTags,
   ApiOperation,
@@ -35,10 +35,39 @@ export class PurchaseOrdersController {
     return this.poService.findById(id);
   }
 
+  @Patch(':id')
+  @ApiOperation({ summary: 'Update a draft purchase order' })
+  @ApiResponse({ status: 200, description: 'Purchase order updated' })
+  update(@Param('id') id: string, @Body() dto: any) {
+    return this.poService.update(id, dto);
+  }
+
+  @Post(':id/submit')
+  @ApiOperation({ summary: 'Submit a draft purchase order for approval' })
+  @ApiResponse({ status: 200, description: 'Purchase order submitted' })
+  submit(@Param('id') id: string) {
+    return this.poService.submit(id);
+  }
+
+  @Post(':id/approve')
+  @ApiOperation({ summary: 'Approve a submitted purchase order' })
+  @ApiResponse({ status: 200, description: 'Purchase order approved' })
+  approve(@Param('id') id: string, @Req() req: any) {
+    const approverId = req.user?.id || 'usr-1';
+    return this.poService.approve(id, approverId);
+  }
+
   @Post(':id/receive')
   @ApiOperation({ summary: 'Receive purchase order line items' })
   @ApiResponse({ status: 200, description: 'Purchase order received' })
   receive(@Param('id') id: string) {
     return this.poService.receive(id);
   }
+
+  @Post(':id/cancel')
+  @ApiOperation({ summary: 'Cancel a draft or submitted purchase order' })
+  @ApiResponse({ status: 200, description: 'Purchase order cancelled' })
+  cancel(@Param('id') id: string) {
+    return this.poService.cancel(id);
+  }
 }

backend/src/purchase-orders/purchase-orders.module.ts

@@ -1,11 +1,14 @@
 import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
-import { PurchaseOrder } from './entities/purchase-order.entity';
+import {
+  PurchaseOrder,
+  PurchaseOrderLineItem,
+} from './entities/purchase-order.entity';
 import { PurchaseOrdersService } from './purchase-orders.service';
 import { PurchaseOrdersController } from './purchase-orders.controller';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([PurchaseOrder])],
+  imports: [TypeOrmModule.forFeature([PurchaseOrder, PurchaseOrderLineItem])],
   providers: [PurchaseOrdersService],
   controllers: [PurchaseOrdersController],
   exports: [PurchaseOrdersService],

backend/src/purchase-orders/purchase-orders.service.ts

@@ -1,35 +1,131 @@
-import { Injectable, NotFoundException } from '@nestjs/common';
+import {
+  Injectable,
+  NotFoundException,
+  BadRequestException,
+} from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Repository } from 'typeorm';
-import { PurchaseOrder, POStatus } from './entities/purchase-order.entity';
+import {
+  PurchaseOrder,
+  PurchaseOrderLineItem,
+  POStatus,
+} from './entities/purchase-order.entity';
 
 @Injectable()
 export class PurchaseOrdersService {
   constructor(
     @InjectRepository(PurchaseOrder)
     private readonly poRepo: Repository<PurchaseOrder>,
+    @InjectRepository(PurchaseOrderLineItem)
+    private readonly lineItemRepo: Repository<PurchaseOrderLineItem>,
   ) {}
 
   async findAll() {
-    return this.poRepo.find();
+    return this.poRepo.find({ relations: ['lineItems'] });
   }
 
   async findById(id: string) {
-    const po = await this.poRepo.findOne({ where: { id } });
+    const po = await this.poRepo.findOne({
+      where: { id },
+      relations: ['lineItems'],
+    });
     if (!po) throw new NotFoundException(`PO ${id} not found`);
     return po;
   }
 
-  async create(dto: Partial<PurchaseOrder>) {
+  async create(dto: Partial<PurchaseOrder> & { lineItems?: Partial<PurchaseOrderLineItem>[] }) {
     const count = await this.poRepo.count();
     const poNumber = dto.poNumber || `PO-${String(count + 1).padStart(5, '0')}`;
-    const po = this.poRepo.create({ ...dto, poNumber });
+    const { lineItems, ...poData } = dto;
+    const po = this.poRepo.create({ ...poData, poNumber, status: POStatus.DRAFT });
+    const saved = await this.poRepo.save(po);
+
+    if (lineItems && lineItems.length > 0) {
+      const items = lineItems.map((item) =>
+        this.lineItemRepo.create({ ...item, purchaseOrderId: saved.id }),
+      );
+      await this.lineItemRepo.save(items);
+      saved.totalAmount = items.reduce(
+        (sum, item) => sum + item.quantity * item.unitCost,
+        0,
+      );
+      await this.poRepo.save(saved);
+    }
+
+    return this.findById(saved.id);
+  }
+
+  async update(
+    id: string,
+    dto: Partial<PurchaseOrder> & { lineItems?: Partial<PurchaseOrderLineItem>[] },
+  ) {
+    const po = await this.findById(id);
+    if (po.status !== POStatus.DRAFT) {
+      throw new BadRequestException('Only draft purchase orders can be edited');
+    }
+
+    const { lineItems, ...poData } = dto;
+    Object.assign(po, poData);
+
+    if (lineItems) {
+      await this.lineItemRepo.delete({ purchaseOrderId: id });
+      const items = lineItems.map((item) =>
+        this.lineItemRepo.create({ ...item, purchaseOrderId: id }),
+      );
+      await this.lineItemRepo.save(items);
+      po.totalAmount = items.reduce(
+        (sum, item) => sum + item.quantity * item.unitCost,
+        0,
+      );
+    }
+
+    await this.poRepo.save(po);
+    return this.findById(id);
+  }
+
+  async submit(id: string) {
+    const po = await this.findById(id);
+    if (po.status !== POStatus.DRAFT) {
+      throw new BadRequestException('Only draft purchase orders can be submitted');
+    }
+    po.status = POStatus.SUBMITTED;
+    return this.poRepo.save(po);
+  }
+
+  async approve(id: string, approverUserId: string) {
+    const po = await this.findById(id);
+    if (po.status !== POStatus.SUBMITTED) {
+      throw new BadRequestException(
+        'Only submitted purchase orders can be approved',
+      );
+    }
+    po.status = POStatus.APPROVED;
+    po.createdByUserId = approverUserId;
     return this.poRepo.save(po);
   }
 
   async receive(id: string) {
     const po = await this.findById(id);
+    if (po.status !== POStatus.APPROVED) {
+      throw new BadRequestException(
+        'Only approved purchase orders can be received',
+      );
+    }
     po.status = POStatus.RECEIVED;
     return this.poRepo.save(po);
   }
+
+  async cancel(id: string) {
+    const po = await this.findById(id);
+    if (
+      po.status !== POStatus.DRAFT &&
+      po.status !== POStatus.SUBMITTED
+    ) {
+      throw new BadRequestException(
+        'Only draft or submitted purchase orders can be cancelled',
+      );
+    }
+    po.status = POStatus.CANCELLED;
+    return this.poRepo.save(po);
+  }
 }

backend/src/transfers/transfers.controller.ts

@@ -49,4 +49,18 @@ export class TransfersController {
   reject(@Param('id') id: string, @Body('reason') reason: string) {
     return this.transfersService.reject(id, reason || 'Rejected by manager');
   }
+
+  @Post(':id/cancel')
+  @ApiOperation({ summary: 'Cancel a pending asset transfer' })
+  @ApiResponse({ status: 200, description: 'Transfer cancelled' })
+  cancel(@Param('id') id: string) {
+    return this.transfersService.cancel(id);
+  }
+
+  @Post(':id/complete')
+  @ApiOperation({ summary: 'Mark an approved transfer as completed' })
+  @ApiResponse({ status: 200, description: 'Transfer completed' })
+  complete(@Param('id') id: string) {
+    return this.transfersService.complete(id);
+  }
 }

backend/src/transfers/transfers.service.ts

@@ -54,4 +54,24 @@ export class TransfersService {
     tr.rejectionReason = reason;
     return this.transferRepo.save(tr);
   }
+
+  async cancel(id: string) {
+    const tr = await this.findById(id);
+    if (tr.status !== TransferStatus.PENDING) {
+      throw new BadRequestException('Only pending transfers can be cancelled');
+    }
+    tr.status = TransferStatus.CANCELLED;
+    return this.transferRepo.save(tr);
+  }
+
+  async complete(id: string) {
+    const tr = await this.findById(id);
+    if (tr.status !== TransferStatus.APPROVED) {
+      throw new BadRequestException(
+        'Only approved transfers can be completed',
+      );
+    }
+    tr.status = TransferStatus.COMPLETED;
+    return this.transferRepo.save(tr);
+  }
 }