changes

apps/edr-freight-api/src/modules/rule-engine/services/priority-configs.service.ts

@@ -0,0 +1,98 @@
+import { BadRequestException, Inject, Injectable, NotFoundException } from '@nestjs/common';
+import { CreatePriorityConfigDto } from '../dto/create-priority-config.dto';
+import { UpdatePriorityConfigDto } from '../dto/update-priority-config.dto';
+import { PriorityConfig } from '../entities/priority-config.entity';
+import {
+  IPriorityConfigsRepository,
+  PRIORITY_CONFIGS_REPOSITORY,
+} from '../interfaces/priority-configs.repository.interface';
+import { DisplayOrderService } from './display-order.service';
+
+@Injectable()
+export class PriorityConfigsService {
+  constructor(
+    @Inject(PRIORITY_CONFIGS_REPOSITORY)
+    private readonly repository: IPriorityConfigsRepository,
+    private readonly displayOrder: DisplayOrderService,
+  ) {}
+
+  async findAll(filter: {
+    type?: 'WAGON' | 'CURRENCY';
+    isActive?: boolean;
+    page?: number;
+    pageSize?: number;
+  }): Promise<{ data: PriorityConfig[]; meta: { total: number; page: number; pageSize: number; totalPages: number } }> {
+    const page = filter.page ?? 1;
+    const pageSize = filter.pageSize ?? 20;
+    const where: Record<string, unknown> = {};
+    if (filter.type !== undefined) where.type = filter.type;
+    if (filter.isActive !== undefined) where.isActive = filter.isActive;
+
+    const [data, total] = await this.repository.findAndCount({
+      where,
+      order: { displayOrder: 'ASC' },
+      skip: (page - 1) * pageSize,
+      take: pageSize,
+    });
+    return { data, meta: { total, page, pageSize, totalPages: Math.ceil(total / pageSize) } };
+  }
+
+  async findById(id: string): Promise<PriorityConfig> {
+    const entity = await this.repository.findById(id);
+    if (!entity) throw new NotFoundException(`Priority config ${id} not found`);
+    return entity;
+  }
+
+  async create(dto: CreatePriorityConfigDto): Promise<PriorityConfig> {
+    this.validateCurrencyField(dto.type, dto.currency);
+
+    const displayOrder = await this.displayOrder.resolveCreateOrder(PriorityConfig, 'displayOrder', {});
+
+    return this.repository.create({
+      type: dto.type,
+      label: dto.label,
+      currency: dto.currency ?? null,
+      minWagonCount: dto.minWagonCount,
+      maxWagonCount: dto.maxWagonCount,
+      scorePoints: dto.scorePoints ?? 0,
+      isActive: dto.isActive ?? false,
+      displayOrder,
+    });
+  }
+
+  async update(id: string, dto: UpdatePriorityConfigDto): Promise<PriorityConfig> {
+    const existing = await this.findById(id);
+
+    const type = dto.type ?? existing.type;
+    const currency = dto.currency !== undefined ? dto.currency : existing.currency;
+    this.validateCurrencyField(type, currency);
+
+    const { ...patch } = dto;
+    const updated = await this.repository.update(id, patch);
+    if (!updated) throw new NotFoundException(`Priority config ${id} not found`);
+    return updated;
+  }
+
+  async remove(id: string): Promise<void> {
+    await this.findById(id);
+    await this.repository.softDelete(id);
+  }
+
+  async reorder(ids: string[]): Promise<void> {
+    await this.displayOrder.reorderByIds(PriorityConfig, 'displayOrder', ids);
+  }
+
+  async moveOrder(id: string, direction: 'up' | 'down'): Promise<void> {
+    await this.findById(id);
+    await this.displayOrder.moveOne(PriorityConfig, 'displayOrder', id, direction);
+  }
+
+  private validateCurrencyField(type: 'WAGON' | 'CURRENCY', currency: string | undefined | null): void {
+    if (type === 'CURRENCY' && !currency) {
+      throw new BadRequestException('currency field is required when type is CURRENCY');
+    }
+    if (type === 'WAGON' && currency) {
+      throw new BadRequestException('currency field must be null when type is WAGON');
+    }
+  }
+}

apps/edr-freight-api/src/modules/rule-engine/services/priority-rules.service.ts

@@ -1,75 +0,0 @@
-import { ConflictException, Inject, Injectable, NotFoundException } from '@nestjs/common';
-import { generateCode } from '../../../common/utils/generate-code.util';
-import { CreatePriorityRuleDto } from '../dto/create-priority-rule.dto';
-import { UpdatePriorityRuleDto } from '../dto/update-priority-rule.dto';
-import { PriorityRule } from '../entities/priority-rule.entity';
-import {
-  IPriorityRulesRepository,
-  PRIORITY_RULES_REPOSITORY,
-} from '../interfaces/priority-rules.repository.interface';
-
-@Injectable()
-export class PriorityRulesService {
-  constructor(
-    @Inject(PRIORITY_RULES_REPOSITORY)
-    private readonly repository: IPriorityRulesRepository,
-  ) {}
-
-  /** List priority rules with pagination. */
-  async findAll(filter: {
-    isActive?: boolean;
-    page?: number;
-    pageSize?: number;
-  }): Promise<{ data: PriorityRule[]; meta: { total: number; page: number; pageSize: number; totalPages: number } }> {
-    const page = filter.page ?? 1;
-    const pageSize = filter.pageSize ?? 20;
-    const where: Record<string, unknown> = {};
-    if (filter.isActive !== undefined) where.isActive = filter.isActive;
-
-    const [data, total] = await this.repository.findAndCount({
-      where,
-      order: { label: 'ASC' },
-      skip: (page - 1) * pageSize,
-      take: pageSize,
-    });
-    return { data, meta: { total, page, pageSize, totalPages: Math.ceil(total / pageSize) } };
-  }
-
-  /** Get a single priority rule by ID. */
-  async findById(id: string): Promise<PriorityRule> {
-    const entity = await this.repository.findById(id);
-    if (!entity) throw new NotFoundException(`Priority rule ${id} not found`);
-    return entity;
-  }
-
-  /** Create a new priority rule. */
-  async create(dto: CreatePriorityRuleDto): Promise<PriorityRule> {
-    const code = generateCode(dto.label);
-    const existing = await this.repository.findAll({ where: { code } });
-    if (existing.length > 0) {
-      throw new ConflictException(`Priority rule with label "${dto.label}" conflicts with existing code "${code}"`);
-    }
-    return this.repository.create({
-      code,
-      label: dto.label,
-      score: dto.score,
-      conditionCurrency: dto.conditionCurrency ?? null,
-      isActive: dto.isActive ?? false,
-    });
-  }
-
-  /** Update an existing priority rule. */
-  async update(id: string, dto: UpdatePriorityRuleDto): Promise<PriorityRule> {
-    await this.findById(id);
-    const { ...patch } = dto;
-    const updated = await this.repository.update(id, patch);
-    if (!updated) throw new NotFoundException(`Priority rule ${id} not found`);
-    return updated;
-  }
-
-  /** Soft-delete a priority rule. */
-  async remove(id: string): Promise<void> {
-    await this.findById(id);
-    await this.repository.softDelete(id);
-  }
-}