Merge pull request #281 from Mkalbani/feat/asset-sub

implemented Asset Subcategory Module

Author: truthixify

backend/package-lock.json

@@ -23,6 +23,7 @@
     "@nestjs/common": "^10.0.0",
     "@nestjs/config": "^3.0.0",
     "@nestjs/core": "^10.0.0",
+    "@nestjs/mapped-types": "^2.1.0",
     "@nestjs/platform-express": "^10.0.0",
     "@nestjs/typeorm": "^10.0.0",
     "class-transformer": "^0.5.1",

backend/package.json

@@ -7,43 +7,30 @@ import { AssetCategoriesModule } from './asset-categories/asset-categories.modul
 import { AssetCategory } from './asset-categories/asset-category.entity';
 import { DepartmentsModule } from './departments/departments.module';
 import { Department } from './departments/department.entity';
+import { AssetSubcategoriesModule } from './asset-subcategories/asset-subcategories.module';
+import { AssetSubcategory } from './asset-subcategories/entities/asset-subcategory.entity';
 
 @Module({
   imports: [
     ConfigModule.forRoot({
       isGlobal: true,
     }),
     TypeOrmModule.forRootAsync({
-      imports: [ConfigModule,
-         // --- ADD THIS CONFIGURATION ---
-      I18nModule.forRoot({
-      fallbackLanguage: 'en',
-      loaderOptions: {
-        path: path.join(__dirname, '/i18n/'), // Directory for translation files
-        watch: true, // Watch for changes in translation files
-      },
-      resolvers: [
-        // Order matters: checks query param, then header, then browser settings
-        new QueryResolver(['lang', 'l']),
-        new HeaderResolver(['x-custom-lang-header']),
-        AcceptLanguageResolver, // Standard 'Accept-Language' header
-      ],
-    }),
-    // --- END OF CONFIGURATION ---
-  ],],
+      imports: [ConfigModule],
       useFactory: (configService: ConfigService) => ({
         type: 'postgres',
         host: configService.get('DB_HOST', 'localhost'),
         port: configService.get('DB_PORT', 5432),
         username: configService.get('DB_USERNAME', 'postgres'),
         password: configService.get('DB_PASSWORD', 'password'),
         database: configService.get('DB_DATABASE', 'manage_assets'),
-        entities: [AssetCategory, Department],
+        entities: [AssetCategory, AssetSubcategory, Department],
         synchronize: configService.get('NODE_ENV') !== 'production', // Only for development
       }),
       inject: [ConfigService],
     }),
     AssetCategoriesModule,
+    AssetSubcategoriesModule,
     DepartmentsModule,
   ],
   controllers: [AppController],

backend/src/app.module.ts

@@ -1,4 +1,5 @@
 import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateColumn, OneToMany } from 'typeorm';
+import { AssetSubcategory } from '../asset-subcategories/entities/asset-subcategory.entity';
 
 @Entity('asset_categories')
 export class AssetCategory {
@@ -17,8 +18,7 @@ export class AssetCategory {
   @UpdateDateColumn()
   updatedAt: Date;
 
-  // Relationship with assets (one-to-many)
-  // This will be uncommented when the Asset entity is created
-  // @OneToMany(() => Asset, asset => asset.category)
-  // assets: Asset[];
+    // Relationship with subcategories
+    @OneToMany(() => AssetSubcategory, subcategory => subcategory.parentCategory)
+    subcategories: AssetSubcategory[];
 }

backend/src/asset-categories/asset-category.entity.ts

@@ -0,0 +1,34 @@
+import { Controller, Get, Post, Body, Param, Patch, Delete } from '@nestjs/common';
+import { AssetSubcategoriesService } from './asset-subcategories.service';
+import { CreateAssetSubcategoryDto } from './dto/create-asset-subcategory.dto';
+import { UpdateAssetSubcategoryDto } from './dto/update-asset-subcategory.dto';
+
+@Controller('asset-subcategories')
+export class AssetSubcategoriesController {
+  constructor(private readonly service: AssetSubcategoriesService) {}
+
+  @Post()
+  create(@Body() dto: CreateAssetSubcategoryDto) {
+    return this.service.create(dto);
+  }
+
+  @Get()
+  findAll() {
+    return this.service.findAll();
+  }
+
+  @Get(':id')
+  findOne(@Param('id') id: string) {
+    return this.service.findOne(Number(id));
+  }
+
+  @Patch(':id')
+  update(@Param('id') id: string, @Body() dto: UpdateAssetSubcategoryDto) {
+    return this.service.update(Number(id), dto);
+  }
+
+  @Delete(':id')
+  remove(@Param('id') id: string) {
+    return this.service.remove(Number(id));
+  }
+}

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

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { AssetSubcategory } from './entities/asset-subcategory.entity';
+import { AssetSubcategoriesService } from './asset-subcategories.service';
+import { AssetSubcategoriesController } from './asset-subcategories.controller';
+
+@Module({
+	imports: [TypeOrmModule.forFeature([AssetSubcategory])],
+	providers: [AssetSubcategoriesService],
+	controllers: [AssetSubcategoriesController],
+})
+export class AssetSubcategoriesModule {}

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

@@ -0,0 +1,48 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { AssetSubcategory } from './entities/asset-subcategory.entity';
+import { CreateAssetSubcategoryDto } from './dto/create-asset-subcategory.dto';
+import { UpdateAssetSubcategoryDto } from './dto/update-asset-subcategory.dto';
+import { AssetCategory } from '../asset-categories/asset-category.entity';
+
+@Injectable()
+export class AssetSubcategoriesService {
+  constructor(
+    @InjectRepository(AssetSubcategory)
+    private readonly subcategoryRepo: Repository<AssetSubcategory>,
+    @InjectRepository(AssetCategory)
+    private readonly categoryRepo: Repository<AssetCategory>,
+  ) {}
+
+  async create(dto: CreateAssetSubcategoryDto): Promise<AssetSubcategory> {
+    const parentCategory = await this.categoryRepo.findOne({ where: { id: dto.parentCategoryId } });
+    if (!parentCategory) throw new NotFoundException('Parent category not found');
+    const subcategory = this.subcategoryRepo.create({ ...dto, parentCategory });
+    return this.subcategoryRepo.save(subcategory);
+  }
+
+  findAll(): Promise<AssetSubcategory[]> {
+    return this.subcategoryRepo.find({ relations: ['parentCategory'] });
+  }
+
+  findOne(id: number): Promise<AssetSubcategory> {
+    return this.subcategoryRepo.findOne({ where: { id }, relations: ['parentCategory'] });
+  }
+
+  async update(id: number, dto: UpdateAssetSubcategoryDto): Promise<AssetSubcategory> {
+    const subcategory = await this.subcategoryRepo.findOne({ where: { id } });
+    if (!subcategory) throw new NotFoundException('Subcategory not found');
+    if (dto.parentCategoryId) {
+      const parentCategory = await this.categoryRepo.findOne({ where: { id: dto.parentCategoryId } });
+      if (!parentCategory) throw new NotFoundException('Parent category not found');
+      subcategory.parentCategory = parentCategory;
+    }
+    if (dto.name) subcategory.name = dto.name;
+    return this.subcategoryRepo.save(subcategory);
+  }
+
+  async remove(id: number): Promise<void> {
+    await this.subcategoryRepo.delete(id);
+  }
+}

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

@@ -0,0 +1,11 @@
+import { IsInt, IsNotEmpty, IsString } from 'class-validator';
+
+export class CreateAssetSubcategoryDto {
+  @IsNotEmpty()
+  @IsString()
+  name: string;
+
+  @IsNotEmpty()
+  @IsInt()
+  parentCategoryId: number;
+}

backend/src/asset-subcategories/dto/create-asset-subcategory.dto.ts

@@ -0,0 +1,7 @@
+import { PartialType } from '@nestjs/mapped-types';
+import { CreateAssetSubcategoryDto } from './create-asset-subcategory.dto';
+
+export class UpdateAssetSubcategoryDto extends PartialType(CreateAssetSubcategoryDto) {
+	name?: string;
+	parentCategoryId?: number;
+}

backend/src/asset-subcategories/dto/update-asset-subcategory.dto.ts

@@ -0,0 +1,14 @@
+import { Column, Entity, ManyToOne, PrimaryGeneratedColumn } from 'typeorm';
+import { AssetCategory } from '../../asset-categories/asset-category.entity';
+
+@Entity('asset_subcategories')
+export class AssetSubcategory {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column()
+  name: string;
+
+  @ManyToOne(() => AssetCategory, category => category.subcategories, { nullable: false })
+  parentCategory: AssetCategory;
+}