251211:1314 Frontend: reeactor Admin panel

backend/src/modules/contract/contract.controller.ts

@@ -0,0 +1,70 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Body,
+  Patch,
+  Param,
+  Delete,
+  UseGuards,
+  ParseIntPipe,
+  Query,
+} from '@nestjs/common';
+import {
+  ApiTags,
+  ApiOperation,
+  ApiBearerAuth,
+  ApiQuery,
+} from '@nestjs/swagger';
+import { ContractService } from './contract.service.js';
+import { CreateContractDto } from './dto/create-contract.dto.js';
+import { UpdateContractDto } from './dto/update-contract.dto.js';
+import { SearchContractDto } from './dto/search-contract.dto.js';
+import { JwtAuthGuard } from '../../common/guards/jwt-auth.guard.js';
+import { RequirePermission } from '../../common/decorators/require-permission.decorator.js';
+
+@ApiTags('Contracts')
+@ApiBearerAuth()
+@UseGuards(JwtAuthGuard)
+@Controller('contracts')
+export class ContractController {
+  constructor(private readonly contractService: ContractService) {}
+
+  @Post()
+  @RequirePermission('master_data.manage')
+  @ApiOperation({ summary: 'Create Contract' })
+  create(@Body() dto: CreateContractDto) {
+    return this.contractService.create(dto);
+  }
+
+  @Get()
+  @ApiOperation({
+    summary: 'Get All Contracts (Search & Filter)',
+  })
+  findAll(@Query() query: SearchContractDto) {
+    return this.contractService.findAll(query);
+  }
+
+  @Get(':id')
+  @ApiOperation({ summary: 'Get Contract by ID' })
+  findOne(@Param('id', ParseIntPipe) id: number) {
+    return this.contractService.findOne(id);
+  }
+
+  @Patch(':id')
+  @RequirePermission('master_data.manage')
+  @ApiOperation({ summary: 'Update Contract' })
+  update(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() dto: UpdateContractDto
+  ) {
+    return this.contractService.update(id, dto);
+  }
+
+  @Delete(':id')
+  @RequirePermission('master_data.manage')
+  @ApiOperation({ summary: 'Delete Contract' })
+  remove(@Param('id', ParseIntPipe) id: number) {
+    return this.contractService.remove(id);
+  }
+}

backend/src/modules/contract/contract.module.ts

@@ -0,0 +1,18 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { ContractService } from './contract.service';
+import { ContractController } from './contract.controller';
+import { Contract } from './entities/contract.entity';
+import { ContractOrganization } from './entities/contract-organization.entity';
+import { ProjectModule } from '../project/project.module'; // Likely needed for Project entity or service
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([Contract, ContractOrganization]),
+    ProjectModule,
+  ],
+  controllers: [ContractController],
+  providers: [ContractService],
+  exports: [ContractService],
+})
+export class ContractModule {}

backend/src/modules/contract/contract.service.ts

@@ -0,0 +1,101 @@
+import {
+  Injectable,
+  NotFoundException,
+  ConflictException,
+} from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository, Like } from 'typeorm';
+import { Contract } from './entities/contract.entity';
+import { CreateContractDto } from './dto/create-contract.dto.js';
+import { UpdateContractDto } from './dto/update-contract.dto.js';
+
+@Injectable()
+export class ContractService {
+  constructor(
+    @InjectRepository(Contract)
+    private readonly contractRepo: Repository<Contract>
+  ) {}
+
+  async create(dto: CreateContractDto) {
+    const existing = await this.contractRepo.findOne({
+      where: { contractCode: dto.contractCode },
+    });
+    if (existing) {
+      throw new ConflictException(
+        `Contract Code "${dto.contractCode}" already exists`
+      );
+    }
+    const contract = this.contractRepo.create(dto);
+    return this.contractRepo.save(contract);
+  }
+
+  async findAll(params?: any) {
+    const { search, projectId, page = 1, limit = 100 } = params || {};
+    const skip = (page - 1) * limit;
+
+    const findOptions: any = {
+      relations: ['project'],
+      order: { contractCode: 'ASC' },
+      skip,
+      take: limit,
+      where: [],
+    };
+
+    const searchConditions = [];
+    if (search) {
+      searchConditions.push({ contractCode: Like(`%${search}%`) });
+      searchConditions.push({ contractName: Like(`%${search}%`) });
+    }
+
+    if (projectId) {
+      // Combine project filter with search if exists
+      if (searchConditions.length > 0) {
+        findOptions.where = searchConditions.map((cond) => ({
+          ...cond,
+          projectId,
+        }));
+      } else {
+        findOptions.where = { projectId };
+      }
+    } else {
+      if (searchConditions.length > 0) {
+        findOptions.where = searchConditions;
+      } else {
+        delete findOptions.where; // No filters
+      }
+    }
+
+    const [data, total] = await this.contractRepo.findAndCount(findOptions);
+
+    return {
+      data,
+      meta: {
+        total,
+        page,
+        limit,
+        totalPages: Math.ceil(total / limit),
+      },
+    };
+  }
+
+  async findOne(id: number) {
+    const contract = await this.contractRepo.findOne({
+      where: { id },
+      relations: ['project'],
+    });
+    if (!contract) throw new NotFoundException(`Contract ID ${id} not found`);
+    return contract;
+  }
+
+  async update(id: number, dto: UpdateContractDto) {
+    const contract = await this.findOne(id);
+    Object.assign(contract, dto);
+    return this.contractRepo.save(contract);
+  }
+
+  async remove(id: number) {
+    const contract = await this.findOne(id);
+    // Schema doesn't have deleted_at for Contract either.
+    return this.contractRepo.remove(contract);
+  }
+}

backend/src/modules/contract/dto/create-contract.dto.ts

@@ -0,0 +1,49 @@
+import {
+  IsString,
+  IsNotEmpty,
+  IsBoolean,
+  IsOptional,
+  Length,
+  IsInt,
+  IsDateString,
+} from 'class-validator';
+import { ApiProperty } from '@nestjs/swagger';
+
+export class CreateContractDto {
+  @ApiProperty({ example: 1 })
+  @IsInt()
+  @IsNotEmpty()
+  projectId!: number;
+
+  @ApiProperty({ example: 'C-001' })
+  @IsString()
+  @IsNotEmpty()
+  @Length(1, 50)
+  contractCode!: string;
+
+  @ApiProperty({ example: 'Main Construction Contract' })
+  @IsString()
+  @IsNotEmpty()
+  @Length(1, 255)
+  contractName!: string;
+
+  @ApiProperty({ example: 'Description of the contract', required: false })
+  @IsOptional()
+  @IsString()
+  description?: string;
+
+  @ApiProperty({ example: '2024-01-01', required: false })
+  @IsOptional()
+  @IsDateString()
+  startDate?: string; // Receive as string, TypeORM handles date
+
+  @ApiProperty({ example: '2025-12-31', required: false })
+  @IsOptional()
+  @IsDateString()
+  endDate?: string;
+
+  @ApiProperty({ example: true, required: false })
+  @IsOptional()
+  @IsBoolean()
+  isActive?: boolean;
+}

backend/src/modules/contract/dto/search-contract.dto.ts

@@ -0,0 +1,30 @@
+import { IsOptional, IsString, IsInt, Min } from 'class-validator';
+import { Type } from 'class-transformer';
+import { ApiPropertyOptional } from '@nestjs/swagger';
+
+export class SearchContractDto {
+  @ApiPropertyOptional({ description: 'Search term (code or name)' })
+  @IsOptional()
+  @IsString()
+  search?: string;
+
+  @ApiPropertyOptional({ description: 'Filter by Project ID' })
+  @IsOptional()
+  @IsInt()
+  @Type(() => Number)
+  projectId?: number;
+
+  @ApiPropertyOptional({ description: 'Page number', default: 1 })
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  @Type(() => Number)
+  page?: number = 1;
+
+  @ApiPropertyOptional({ description: 'Items per page', default: 100 })
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  @Type(() => Number)
+  limit?: number = 100;
+}

backend/src/modules/contract/dto/update-contract.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from '@nestjs/swagger';
+import { CreateContractDto } from './create-contract.dto.js';
+
+export class UpdateContractDto extends PartialType(CreateContractDto) {}

backend/src/modules/contract/entities/contract-organization.entity.ts

@@ -0,0 +1,25 @@
+import { Entity, Column, PrimaryColumn, ManyToOne, JoinColumn } from 'typeorm';
+import { Contract } from './contract.entity';
+import { Organization } from '../../organization/entities/organization.entity';
+
+@Entity('contract_organizations')
+export class ContractOrganization {
+  @PrimaryColumn({ name: 'contract_id' })
+  contractId!: number;
+
+  @PrimaryColumn({ name: 'organization_id' })
+  organizationId!: number;
+
+  @Column({ name: 'role_in_contract', nullable: true, length: 100 })
+  roleInContract?: string;
+
+  // Relation ไปยัง Contract
+  @ManyToOne(() => Contract, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'contract_id' })
+  contract?: Contract;
+
+  // Relation ไปยัง Organization
+  @ManyToOne(() => Organization, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'organization_id' })
+  organization?: Organization;
+}

backend/src/modules/contract/entities/contract.entity.ts

@@ -0,0 +1,41 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  ManyToOne,
+  JoinColumn,
+} from 'typeorm';
+import { BaseEntity } from '../../../common/entities/base.entity';
+import { Project } from '../../project/entities/project.entity';
+
+@Entity('contracts')
+export class Contract extends BaseEntity {
+  @PrimaryGeneratedColumn()
+  id!: number;
+
+  @Column({ name: 'project_id' })
+  projectId!: number;
+
+  @Column({ name: 'contract_code', unique: true, length: 50 })
+  contractCode!: string;
+
+  @Column({ name: 'contract_name', length: 255 })
+  contractName!: string;
+
+  @Column({ type: 'text', nullable: true })
+  description?: string;
+
+  @Column({ name: 'start_date', type: 'date', nullable: true })
+  startDate?: Date;
+
+  @Column({ name: 'end_date', type: 'date', nullable: true })
+  endDate?: Date;
+
+  @Column({ name: 'is_active', default: true })
+  isActive!: boolean;
+
+  // Relation
+  @ManyToOne(() => Project)
+  @JoinColumn({ name: 'project_id' })
+  project?: Project;
+}