Merge pull request #353 from nafiuishaaq/feat/AssetAudit

Feat/asset audit

Author: yusuftomilola

backend/src/app.module.ts

@@ -7,6 +7,7 @@ import { AuthModule } from './auth/auth.module';
 import { UsersModule } from './users/users.module';
 import { EmailModule } from './email/email.module';
 import { NewsletterModule } from './newsletter/newsletter.module';
+import { AssetAuditsModule } from './asset-audits/asset-audits.module';
 import { APP_GUARD } from '@nestjs/core';
 import { JwtAuthGuard } from './auth/guards/jwt.guard';
 import { ThrottlerModule, ThrottlerGuard } from '@nestjs/throttler';
@@ -65,6 +66,7 @@ import { CountriesCurrenciesModule } from './countries-currencies/countries-curr
     NewsletterModule,
     InventoryItemsModule,
     CountriesCurrenciesModule,
+    AssetAuditsModule,
   ],
   controllers: [AppController],
   providers: [

backend/src/asset-audits/asset-audits.controller.ts

@@ -0,0 +1,39 @@
+import { Controller, Get, Post, Body, Patch, Param, Delete } from '@nestjs/common';
+import { AssetAuditsService } from './asset-audits.service';
+import { CreateAssetAuditDto } from './dto/create-asset-audit.dto';
+import { UpdateAssetAuditDto } from './dto/update-asset-audit.dto';
+
+@Controller('asset-audits')
+export class AssetAuditsController {
+  constructor(private readonly assetAuditsService: AssetAuditsService) {}
+
+  @Post()
+  create(@Body() createAssetAuditDto: CreateAssetAuditDto) {
+    return this.assetAuditsService.create(createAssetAuditDto);
+  }
+
+  @Get()
+  findAll() {
+    return this.assetAuditsService.findAll();
+  }
+
+  @Get(':id')
+  findOne(@Param('id') id: string) {
+    return this.assetAuditsService.findOne(id);
+  }
+
+  @Patch(':id')
+  update(@Param('id') id: string, @Body() updateAssetAuditDto: UpdateAssetAuditDto) {
+    return this.assetAuditsService.update(id, updateAssetAuditDto);
+  }
+
+  @Delete(':id')
+  remove(@Param('id') id: string) {
+    return this.assetAuditsService.remove(id);
+  }
+
+  @Get('report/audited-vs-missing')
+  getAuditedVsMissingReport() {
+    return this.assetAuditsService.getAuditedVsMissingReport();
+  }
+}

backend/src/asset-audits/asset-audits.module.ts

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { AssetAudit } from './entities/asset-audit.entity';
+import { AssetAuditsService } from './asset-audits.service';
+import { AssetAuditsController } from './asset-audits.controller';
+import { AssetsModule } from '../assets/assets.module';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([AssetAudit]), AssetsModule],
+  providers: [AssetAuditsService],
+  controllers: [AssetAuditsController],
+})
+export class AssetAuditsModule {}

backend/src/asset-audits/asset-audits.service.ts

@@ -0,0 +1,65 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { AssetAudit } from './entities/asset-audit.entity';
+import { CreateAssetAuditDto } from './dto/create-asset-audit.dto';
+import { UpdateAssetAuditDto } from './dto/update-asset-audit.dto';
+import { AssetsService } from '../assets/assets.service';
+
+@Injectable()
+export class AssetAuditsService {
+  constructor(
+    @InjectRepository(AssetAudit) private readonly assetAuditRepository: Repository<AssetAudit>,
+    private readonly assetsService: AssetsService,
+  ) {}
+
+  async create(createAssetAuditDto: CreateAssetAuditDto): Promise<AssetAudit> {
+    const { assetId } = createAssetAuditDto;
+    const asset = await this.assetsService.findOne(assetId);
+    if (!asset) {
+      throw new NotFoundException(`Asset with ID ${assetId} not found.`);
+    }
+    const assetAudit = this.assetAuditRepository.create({ ...createAssetAuditDto, asset });
+    return this.assetAuditRepository.save(assetAudit);
+  }
+
+  async findAll(): Promise<AssetAudit[]> {
+    return this.assetAuditRepository.find({ relations: ['asset'] });
+  }
+
+  async findOne(id: string): Promise<AssetAudit> {
+    const assetAudit = await this.assetAuditRepository.findOne({ where: { id }, relations: ['asset'] });
+    if (!assetAudit) {
+      throw new NotFoundException(`Asset Audit with ID ${id} not found.`);
+    }
+    return assetAudit;
+  }
+
+  async update(id: string, updateAssetAuditDto: UpdateAssetAuditDto): Promise<AssetAudit> {
+    const assetAudit = await this.findOne(id);
+    const updated = Object.assign(assetAudit, updateAssetAuditDto);
+    return this.assetAuditRepository.save(updated);
+  }
+
+  async remove(id: string): Promise<void> {
+    const result = await this.assetAuditRepository.delete(id);
+    if (result.affected === 0) {
+      throw new NotFoundException(`Asset Audit with ID ${id} not found.`);
+    }
+  }
+
+  async getAuditedVsMissingReport(): Promise<any> {
+    const totalAssets = await this.assetsService.countAll();
+    const auditedAssets = await this.assetAuditRepository.count();
+    
+    const missingAssets = totalAssets - auditedAssets;
+
+    return {
+      totalAssets,
+      auditedAssets,
+      missingAssets,
+      percentageAudited: totalAssets > 0 ? (auditedAssets / totalAssets) * 100 : 0,
+      percentageMissing: totalAssets > 0 ? (missingAssets / totalAssets) * 100 : 0,
+    };
+  }
+}

backend/src/asset-audits/dto/create-asset-audit.dto.ts

@@ -0,0 +1,23 @@
+import { IsUUID, IsDateString, IsString, IsNotEmpty, IsOptional } from 'class-validator';
+
+export class CreateAssetAuditDto {
+  @IsUUID()
+  @IsNotEmpty()
+  assetId: string;
+
+  @IsDateString()
+  @IsOptional()
+  auditDate?: Date;
+
+  @IsString()
+  @IsNotEmpty()
+  auditedBy: string;
+
+  @IsString()
+  @IsNotEmpty()
+  status: string;
+
+  @IsString()
+  @IsOptional()
+  remarks?: string;
+}

backend/src/asset-audits/dto/update-asset-audit.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from '@nestjs/mapped-types';
+import { CreateAssetAuditDto } from './create-asset-audit.dto';
+
+export class UpdateAssetAuditDto extends PartialType(CreateAssetAuditDto) {}

backend/src/asset-audits/entities/asset-audit.entity.ts

@@ -0,0 +1,26 @@
+import { Entity, PrimaryGeneratedColumn, Column, ManyToOne } from 'typeorm';
+import { Asset } from '../../assets/assets.entity';
+
+@Entity('asset_audits')
+export class AssetAudit {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @ManyToOne(() => Asset, (asset) => asset.audits)
+  asset: Asset;
+
+  @Column({ type: 'uuid' })
+  assetId: string;
+
+  @Column({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP' })
+  auditDate: Date;
+
+  @Column()
+  auditedBy: string;
+
+  @Column()
+  status: string; // e.g., 'compliant', 'non-compliant', 'missing'
+
+  @Column({ nullable: true })
+  remarks: string;
+}

backend/src/assets/assets.entity.ts

@@ -1,6 +1,7 @@
 import { Entity, PrimaryGeneratedColumn, Column, ManyToOne, OneToMany } from 'typeorm';
 import { Supplier } from '../suppliers/suppliers.entity';
 import { AssetDisposal } from 'src/asset-disposals/entities/asset-disposal.entity';
+import { AssetAudit } from '../asset-audits/entities/asset-audit.entity';
 
 @Entity('assets')
 export class Asset {
@@ -19,6 +20,9 @@ export class Asset {
   @OneToMany(() => AssetDisposal, (disposal) => disposal.asset)
   disposals: AssetDisposal[];
 
+  @OneToMany(() => AssetAudit, (assetAudit) => assetAudit.asset)
+  audits: AssetAudit[];
+
   @Column({ default: 'active' })
   status: 'active' | 'disposed';
 }

backend/src/assets/assets.module.ts

@@ -0,0 +1,11 @@
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { Module } from '@nestjs/common';
+import { Asset } from './assets.entity';
+import { AssetsService } from './assets.service';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([Asset])],
+  providers: [AssetsService],
+  exports: [AssetsService], // Export AssetsService
+})
+export class AssetsModule {}

backend/src/assets/assets.service.ts

@@ -1,16 +1,44 @@
-import { Injectable } from "@nestjs/common";
-import { InjectRepository } from "@nestjs/typeorm";
-import { Repository } from "typeorm";
-import { Asset } from "./assets.entity";
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { Asset } from './assets.entity';
 
 @Injectable()
-export class AssetService {
-constructor(
-    @InjectRepository(Asset)
-    private assetRepo: Repository<Asset>,
-) {}
+export class AssetsService {
+  constructor(
+    @InjectRepository(Asset) private readonly assetRepository: Repository<Asset>,
+  ) {}
 
-async findActive() {
-  return this.assetRepo.find({ where: { status: 'active' } });
-}
+  async create(asset: Partial<Asset>): Promise<Asset> {
+    const newAsset = this.assetRepository.create(asset);
+    return this.assetRepository.save(newAsset);
+  }
+
+  async findAll(): Promise<Asset[]> {
+    return this.assetRepository.find();
+  }
+
+  async findOne(id: string): Promise<Asset> {
+    const asset = await this.assetRepository.findOne({ where: { id } });
+    if (!asset) {
+      throw new NotFoundException(`Asset with ID ${id} not found`);
+    }
+    return asset;
+  }
+
+  async update(id: string, asset: Partial<Asset>): Promise<Asset> {
+    await this.assetRepository.update(id, asset);
+    return this.findOne(id);
+  }
+
+  async remove(id: string): Promise<void> {
+    const result = await this.assetRepository.delete(id);
+    if (result.affected === 0) {
+      throw new NotFoundException(`Asset with ID ${id} not found`);
+    }
+  }
+
+  async countAll(): Promise<number> {
+    return this.assetRepository.count();
+  }
 }