Merge pull request #1241 from Femaleotaku/feature/femaleotaku-assigned-fixes

feat: build locations, categories, asset status lifecycle, and history audit trail

Author: yusuftomilola

backend/src/app.module.ts

@@ -9,6 +9,9 @@ import { HealthModule } from './health/health.module';
 import { AuthModule } from './auth/auth.module';
 import { BranchesModule } from './branches/branches.module';
 import { DepartmentsModule } from './departments/departments.module';
+import { LocationsModule } from './locations/locations.module';
+import { CategoriesModule } from './categories/categories.module';
+import { AssetsLifecycleModule } from './assets/assets-lifecycle.module';
 
 @Module({
   imports: [
@@ -19,6 +22,9 @@ import { DepartmentsModule } from './departments/departments.module';
     AuthModule,
     BranchesModule,
     DepartmentsModule,
+    LocationsModule,
+    CategoriesModule,
+    AssetsLifecycleModule,
     TypeOrmModule.forRootAsync({
       imports: [ConfigModule],
       useFactory: (configService: ConfigService) => ({

backend/src/assets/asset-lifecycle.service.ts

@@ -0,0 +1,52 @@
+import { Injectable, BadRequestException } from '@nestjs/common';
+
+export enum AssetStatus {
+  AVAILABLE = 'AVAILABLE',
+  ASSIGNED = 'ASSIGNED',
+  IN_MAINTENANCE = 'IN_MAINTENANCE',
+  IN_TRANSIT = 'IN_TRANSIT',
+  RETIRED = 'RETIRED',
+  DISPOSED = 'DISPOSED',
+  LOST = 'LOST',
+}
+
+const ALLOWED_TRANSITIONS: Record<AssetStatus, AssetStatus[]> = {
+  [AssetStatus.AVAILABLE]: [AssetStatus.ASSIGNED, AssetStatus.IN_MAINTENANCE, AssetStatus.IN_TRANSIT, AssetStatus.RETIRED, AssetStatus.LOST],
+  [AssetStatus.ASSIGNED]: [AssetStatus.AVAILABLE, AssetStatus.IN_MAINTENANCE, AssetStatus.IN_TRANSIT, AssetStatus.RETIRED, AssetStatus.LOST],
+  [AssetStatus.IN_MAINTENANCE]: [AssetStatus.AVAILABLE, AssetStatus.ASSIGNED, AssetStatus.RETIRED],
+  [AssetStatus.IN_TRANSIT]: [AssetStatus.AVAILABLE, AssetStatus.ASSIGNED, AssetStatus.LOST],
+  [AssetStatus.RETIRED]: [AssetStatus.DISPOSED],
+  [AssetStatus.DISPOSED]: [],
+  [AssetStatus.LOST]: [AssetStatus.AVAILABLE, AssetStatus.RETIRED, AssetStatus.DISPOSED],
+};
+
+@Injectable()
+export class AssetLifecycleService {
+  private history = new Map<string, any[]>();
+
+  validateTransition(fromStatus: AssetStatus, toStatus: AssetStatus) {
+    if (fromStatus === toStatus) return true;
+    const allowed = ALLOWED_TRANSITIONS[fromStatus] || [];
+    if (!allowed.includes(toStatus)) {
+      throw new BadRequestException(`Cannot transition asset status from ${fromStatus} to ${toStatus}`);
+    }
+    return true;
+  }
+
+  recordHistory(assetId: string, event: { eventType: string; actorUserId: string; note?: string; fieldChanges?: any }) {
+    const list = this.history.get(assetId) || [];
+    const entry = {
+      id: `h_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
+      assetId,
+      ...event,
+      timestamp: new Date(),
+    };
+    list.unshift(entry);
+    this.history.set(assetId, list);
+    return entry;
+  }
+
+  getHistory(assetId: string) {
+    return this.history.get(assetId) || [];
+  }
+}

backend/src/assets/asset-status.controller.ts

@@ -0,0 +1,33 @@
+import { Controller, Get, Patch, Param, Body, Req } from '@nestjs/common';
+import { ApiTags, ApiOperation } from '@nestjs/swagger';
+import { AssetLifecycleService, AssetStatus } from './asset-lifecycle.service';
+
+@ApiTags('assets')
+@Controller('assets')
+export class AssetStatusController {
+  constructor(private readonly lifecycleService: AssetLifecycleService) {}
+
+  @Patch(':id/status')
+  @ApiOperation({ summary: 'Update asset status' })
+  updateStatus(
+    @Param('id') id: string,
+    @Body() body: { currentStatus: AssetStatus; newStatus: AssetStatus; note?: string },
+    @Req() req: any,
+  ) {
+    this.lifecycleService.validateTransition(body.currentStatus, body.newStatus);
+    const actorId = req.user?.id || 'usr-1';
+    const entry = this.lifecycleService.recordHistory(id, {
+      eventType: 'STATUS_CHANGED',
+      actorUserId: actorId,
+      note: body.note,
+      fieldChanges: { status: { from: body.currentStatus, to: body.newStatus } },
+    });
+    return { assetId: id, status: body.newStatus, historyEntry: entry };
+  }
+
+  @Get(':id/history')
+  @ApiOperation({ summary: 'Get asset history and audit trail' })
+  getHistory(@Param('id') id: string) {
+    return this.lifecycleService.getHistory(id);
+  }
+}

backend/src/assets/assets-lifecycle.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { AssetLifecycleService } from './asset-lifecycle.service';
+import { AssetStatusController } from './asset-status.controller';
+
+@Module({
+  providers: [AssetLifecycleService],
+  controllers: [AssetStatusController],
+  exports: [AssetLifecycleService],
+})
+export class AssetsLifecycleModule {}

backend/src/categories/categories.controller.ts

@@ -0,0 +1,39 @@
+import { Controller, Get, Post, Patch, Delete, Body, Param } from '@nestjs/common';
+import { ApiTags, ApiOperation } from '@nestjs/swagger';
+import { CategoriesService } from './categories.service';
+
+@ApiTags('categories')
+@Controller('categories')
+export class CategoriesController {
+  constructor(private readonly categoriesService: CategoriesService) {}
+
+  @Get()
+  @ApiOperation({ summary: 'List all categories' })
+  findAll() {
+    return this.categoriesService.findAll();
+  }
+
+  @Post()
+  @ApiOperation({ summary: 'Create a category' })
+  create(@Body() dto: any) {
+    return this.categoriesService.create(dto);
+  }
+
+  @Get(':id')
+  @ApiOperation({ summary: 'Get category details' })
+  findOne(@Param('id') id: string) {
+    return this.categoriesService.findById(id);
+  }
+
+  @Patch(':id')
+  @ApiOperation({ summary: 'Update a category' })
+  update(@Param('id') id: string, @Body() dto: any) {
+    return this.categoriesService.update(id, dto);
+  }
+
+  @Delete(':id')
+  @ApiOperation({ summary: 'Delete a category' })
+  delete(@Param('id') id: string) {
+    return this.categoriesService.delete(id);
+  }
+}

backend/src/categories/categories.module.ts

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { Category } from './entities/category.entity';
+import { CategoriesService } from './categories.service';
+import { CategoriesController } from './categories.controller';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([Category])],
+  providers: [CategoriesService],
+  controllers: [CategoriesController],
+  exports: [CategoriesService],
+})
+export class CategoriesModule {}

backend/src/categories/categories.service.ts

@@ -0,0 +1,41 @@
+import { Injectable, NotFoundException, BadRequestException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { Category } from './entities/category.entity';
+
+@Injectable()
+export class CategoriesService {
+  constructor(
+    @InjectRepository(Category)
+    private readonly categoryRepo: Repository<Category>,
+  ) {}
+
+  async findAll() {
+    return this.categoryRepo.find();
+  }
+
+  async findById(id: string) {
+    const cat = await this.categoryRepo.findOne({ where: { id } });
+    if (!cat) throw new NotFoundException(`Category ${id} not found`);
+    return cat;
+  }
+
+  async create(dto: Partial<Category>) {
+    const cat = this.categoryRepo.create(dto);
+    return this.categoryRepo.save(cat);
+  }
+
+  async update(id: string, dto: Partial<Category>) {
+    const cat = await this.findById(id);
+    if (dto.parentCategoryId && dto.parentCategoryId === id) {
+      throw new BadRequestException('A category cannot be its own parent');
+    }
+    Object.assign(cat, dto);
+    return this.categoryRepo.save(cat);
+  }
+
+  async delete(id: string) {
+    const cat = await this.findById(id);
+    return this.categoryRepo.remove(cat);
+  }
+}

backend/src/categories/entities/category.entity.ts

@@ -0,0 +1,34 @@
+import { Entity, Column, PrimaryGeneratedColumn, CreateDateColumn, UpdateDateColumn } from 'typeorm';
+
+@Entity('categories')
+export class Category {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column()
+  name: string;
+
+  @Column({ unique: true })
+  code: string;
+
+  @Column({ nullable: true })
+  description?: string;
+
+  @Column({ nullable: true })
+  parentCategoryId?: string;
+
+  @Column({ nullable: true })
+  icon?: string;
+
+  @Column({ type: 'decimal', precision: 5, scale: 2, default: 0 })
+  defaultDepreciationRate: number;
+
+  @Column({ default: 36 })
+  defaultUsefulLifeMonths: number;
+
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
+}

backend/src/femaleotaku.spec.ts

@@ -0,0 +1,37 @@
+import { LocationsService } from './locations/locations.service';
+import { CategoriesService } from './categories/categories.service';
+import { AssetLifecycleService, AssetStatus } from './assets/asset-lifecycle.service';
+
+describe('femaleotaku Modules (BE-88, BE-87, BE-85, BE-84)', () => {
+  it('LocationsService creates location', async () => {
+    const mockRepo = {
+      create: jest.fn().mockImplementation((dto) => dto),
+      save: jest.fn().mockImplementation((dto) => Promise.resolve({ id: 'loc-1', ...dto })),
+    };
+    const service = new LocationsService(mockRepo as any);
+    const loc = await service.create({ name: 'Building A', code: 'BLD-A' });
+    expect(loc.name).toBe('Building A');
+  });
+
+  it('CategoriesService manages depreciation defaults', async () => {
+    const mockRepo = {
+      create: jest.fn().mockImplementation((dto) => dto),
+      save: jest.fn().mockImplementation((dto) => Promise.resolve({ id: 'cat-1', ...dto })),
+    };
+    const service = new CategoriesService(mockRepo as any);
+    const cat = await service.create({ name: 'Laptops', code: 'LAP', defaultDepreciationRate: 20, defaultUsefulLifeMonths: 36 });
+    expect(cat.defaultUsefulLifeMonths).toBe(36);
+  });
+
+  it('AssetLifecycleService validates state transitions and records history', () => {
+    const service = new AssetLifecycleService();
+    expect(service.validateTransition(AssetStatus.AVAILABLE, AssetStatus.ASSIGNED)).toBe(true);
+    expect(() => service.validateTransition(AssetStatus.DISPOSED, AssetStatus.ASSIGNED)).toThrow(
+      'Cannot transition asset status from DISPOSED to ASSIGNED',
+    );
+
+    const history = service.recordHistory('asset-1', { eventType: 'STATUS_CHANGED', actorUserId: 'user-1', note: 'Assigned to Jane' });
+    expect(history.id).toBeDefined();
+    expect(service.getHistory('asset-1').length).toBe(1);
+  });
+});

backend/src/locations/entities/location.entity.ts

@@ -0,0 +1,38 @@
+import { Entity, Column, PrimaryGeneratedColumn, CreateDateColumn, UpdateDateColumn } from 'typeorm';
+
+export enum LocationType {
+  BUILDING = 'BUILDING',
+  FLOOR = 'FLOOR',
+  ROOM = 'ROOM',
+  STORAGE = 'STORAGE',
+}
+
+@Entity('locations')
+export class Location {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column()
+  name: string;
+
+  @Column({ unique: true })
+  code: string;
+
+  @Column({ type: 'enum', enum: LocationType, default: LocationType.BUILDING })
+  type: LocationType;
+
+  @Column({ nullable: true })
+  address?: string;
+
+  @Column({ nullable: true })
+  parentLocationId?: string;
+
+  @Column({ nullable: true })
+  branchId?: string;
+
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
+}