order

database/migrations/.snapshot-negareh.json

@@ -703,6 +703,16 @@
           "nullable": true,
           "length": 6,
           "mappedType": "datetime"
+        },
+        "title": {
+          "name": "title",
+          "type": "varchar(255)",
+          "unsigned": false,
+          "autoincrement": false,
+          "primary": false,
+          "nullable": false,
+          "length": 255,
+          "mappedType": "string"
         }
       },
       "name": "order_prints",
@@ -2063,24 +2073,6 @@
           "nullable": false,
           "length": 26,
           "mappedType": "character"
-        },
-        "description": {
-          "name": "description",
-          "type": "text",
-          "unsigned": false,
-          "autoincrement": false,
-          "primary": false,
-          "nullable": true,
-          "mappedType": "text"
-        },
-        "attachments": {
-          "name": "attachments",
-          "type": "jsonb",
-          "unsigned": false,
-          "autoincrement": false,
-          "primary": false,
-          "nullable": true,
-          "mappedType": "json"
         }
       },
       "name": "request_items",
@@ -2509,8 +2501,8 @@
           "nullable": false,
           "mappedType": "integer"
         },
-        "confirm_status": {
+        "status": {
-          "name": "confirm_status",
+          "name": "status",
           "type": "text",
           "unsigned": false,
           "autoincrement": false,
@@ -2520,7 +2512,8 @@
           "enumItems": [
             "pending",
             "partially_confirmed",
-            "confirmed"
+            "confirmed",
+            "archived"
           ],
           "mappedType": "enum"
         },
@@ -3213,6 +3206,16 @@
       "name": "orders",
       "schema": "public",
       "indexes": [
+        {
+          "columnNames": [
+            "invoice_item_id"
+          ],
+          "composite": false,
+          "keyName": "orders_invoice_item_id_unique",
+          "constraint": true,
+          "primary": false,
+          "unique": true
+        },
         {
           "columnNames": [
             "print_id"

database/migrations/Migration20260626140000.ts

@@ -15,7 +15,7 @@ export class Migration20260626140000 extends Migration {
         v_total int;
         v_paid int;
         v_enable_tax boolean;
-        v_confirm_status text;
+        v_status text;
     BEGIN
 
         v_invoice_id := COALESCE(NEW.invoice_id, OLD.invoice_id);
@@ -68,7 +68,7 @@ export class Migration20260626140000 extends Migration {
             ) THEN 'confirmed'
             ELSE 'partially_confirmed'
         END
-        INTO v_confirm_status;
+        INTO v_status;
 
         UPDATE invoices
         SET
@@ -78,8 +78,9 @@ export class Migration20260626140000 extends Migration {
             total = v_total,
             paid_amount = v_paid,
             balance = v_total - v_paid,
-            confirm_status = v_confirm_status
+            status = v_status
-        WHERE id = v_invoice_id;
+        WHERE id = v_invoice_id
+          AND status <> 'archived';
 
         RETURN NULL;
     END;

negare.code-workspace

@@ -0,0 +1,14 @@
+{
+	"folders": [
+		{
+			"path": "."
+		},
+		{
+			"path": "../negareh-console"
+		},
+		{
+			"path": "../negareh-admin"
+		}
+	],
+	"settings": {}
+}

src/app.module.ts

@@ -31,9 +31,9 @@ import { cacheConfig } from './config/cache.config';
     ConfigModule.forRoot({ isGlobal: true, cache: true }),
     CacheModule.registerAsync(cacheConfig()),
     MikroOrmModule.forRootAsync(dataBaseConfig),
+    AuthModule,
     UserModule,
     UtilsModule,
-    AuthModule,
     UploaderModule,
     AdminModule,
     ThrottlerModule.forRoot([

src/common/decorators/admin-perms.decorator.ts

@@ -0,0 +1,18 @@
+import { createParamDecorator, type ExecutionContext } from '@nestjs/common';
+import type { Request } from 'express';
+
+/**
+ * Decorator to extract userId from the authenticated request.
+ * Must be used after AdminAuthGuard or AuthGuard that sets request.userId.
+ *
+ * @example
+ * @Get('/profile')
+ * @UseGuards(AdminAuthGuard)
+ * getProfile(@UserId() userId: string) {
+ *   return this.userService.findById(userId);
+ * }
+ */
+export const AdminPerms = createParamDecorator((data: unknown, ctx: ExecutionContext): string[] => {
+  const request = ctx.switchToHttp().getRequest<Request & { permissions?: string[] }>();
+  return request.permissions || [];
+});

src/common/enums/permission.enum.ts

@@ -1,5 +1,7 @@
 export enum PermissionEnum {
 
+  DASHBOARD = 'dashboard',
+
   MANAGE_PRODUCTS = 'manage_products',
   MANAGE_CATEGORIES = 'manage_categories',
 
@@ -60,6 +62,7 @@ export enum PermissionEnum {
 
 
 export const PermissionTitles: Record<PermissionEnum, string> = {
+  [PermissionEnum.DASHBOARD]: 'مشاهده داشبورد',
   [PermissionEnum.MANAGE_PRODUCTS]: 'مدیریت محصولات',
   [PermissionEnum.MANAGE_CATEGORIES]: 'مدیریت دسته‌بندی‌ها',
 

src/modules/admin/controllers/admin.controller.ts

@@ -9,6 +9,7 @@ import { AdminId } from 'src/common/decorators/admin-id.decorator';
 import { Admin } from '../entities/admin.entity';
 import { PermissionEnum } from 'src/common/enums/permission.enum';
 import { Permissions } from 'src/common/decorators/permissions.decorator';
+import { AdminPerms } from 'src/common/decorators/admin-perms.decorator';
 
 @Controller()
 @ApiTags('admin')
@@ -20,7 +21,7 @@ export class AdminController {
   @Post('admin/admin')
   @Permissions(PermissionEnum.MANAGE_ADMINS)
   @ApiOperation({ summary: 'Create a new admin' })
-  async create(@Body() dto: CreateAdminDto,) {
+  async create(@Body() dto: CreateAdminDto) {
     const admin = await this.adminService.create(dto);
     return admin;
   }
@@ -40,55 +41,55 @@ export class AdminController {
 
   @Get('admin/admins/me')
   @ApiOperation({ summary: 'Get current authenticated admin profile' })
-  async getMe(@AdminId() adminId: string,) {
+  async getMe(@AdminId() adminId: string) {
-    const admin = await this.adminService.findById(adminId,);
+    const admin = await this.adminService.findById(adminId);
     return admin;
   }
 
   @Patch('admin/admins/me')
   @ApiOperation({ summary: 'Update current authenticated admin profile' })
-  updateMe(@AdminId() adminId: string, @Body() dto: UpdateAdminMeDto,): Promise<Admin> {
+  updateMe(@AdminId() adminId: string, @Body() dto: UpdateAdminMeDto): Promise<Admin> {
     return this.adminService.updateMe(adminId, dto);
   }
 
-  @Get('admin/dashboard/counts')
+  @Get('admin/menu/counts')
-  @ApiOperation({ summary: 'Get dashboard entity counts for admin panel' })
+  @ApiOperation({ summary: 'Get metrics for admin panel' })
-  getDashboardCounts() {
+  getDashboardCounts(@AdminId() adminId: string, @AdminPerms() permissions: string[]) {
-    return this.adminService.getDashboardCounts();
+    return this.adminService.getDashboardCounts(adminId, permissions);
   }
 
   @Get('admin/home/stats')
+  @Permissions(PermissionEnum.DASHBOARD)
   @ApiOperation({ summary: 'Get home page stats for admin panel' })
   getHomeStats() {
     return this.adminService.getHomeStats();
   }
 
   @Get('admin/home/weekly-orders')
+  @Permissions(PermissionEnum.DASHBOARD)
   @ApiOperation({ summary: 'Get weekly order counts for admin home page chart' })
   getWeeklyOrders() {
     return this.adminService.getWeeklyOrders();
   }
 
-
   @Patch('admin/admins/:adminId')
   @Permissions(PermissionEnum.MANAGE_ADMINS)
   @ApiOperation({ summary: 'Update an admin' })
-  update(@Param('adminId') adminId: string, @Body() dto: UpdateAdminDto,): Promise<Admin> {
+  update(@Param('adminId') adminId: string, @Body() dto: UpdateAdminDto): Promise<Admin> {
     return this.adminService.update(adminId, dto);
   }
 
   @Get('admin/admins/:adminId')
   @Permissions(PermissionEnum.MANAGE_ADMINS)
   @ApiOperation({ summary: 'Get an admin by ID' })
-  getById(@Param('adminId') adminId: string,): Promise<Admin | null> {
+  getById(@Param('adminId') adminId: string): Promise<Admin | null> {
-    return this.adminService.findById(adminId,);
+    return this.adminService.findById(adminId);
   }
 
   @Delete('admin/admins/:adminId')
   @Permissions(PermissionEnum.MANAGE_ADMINS)
   @ApiOperation({ summary: 'Delete an admin by ID' })
-  deleteById(@Param('adminId') adminId: string,): Promise<void> {
+  deleteById(@Param('adminId') adminId: string): Promise<void> {
-    return this.adminService.softDelete(adminId,);
+    return this.adminService.softDelete(adminId);
   }
-
 }

src/modules/admin/providers/admin.service.ts

@@ -102,7 +102,7 @@ export class AdminService {
     }
 
     if (rest.phone !== undefined && rest.phone !== admin.phone) {
-      const exists = await this.adminRepository.findOne({ phone: rest.phone,id: { $ne: adminId } });
+      const exists = await this.adminRepository.findOne({ phone: rest.phone, id: { $ne: adminId } });
       if (exists) {
         throw new ConflictException('This Phone Number is already taken');
       }
@@ -148,28 +148,23 @@ export class AdminService {
     }
     return admins
   }
+ 
 
-  async ownedPermissions(adminId: string, permissionNames: PermissionEnum[]): Promise<PermissionEnum[]> {
+  async getDashboardCounts(adminId: string, permissions: string[]) {
-    if (permissionNames.length === 0) return []
+ 
+    const canViewAnyOrder = permissions.includes(PermissionEnum.VIEW_ORDERS);
+    const canViewAssignedOrder = permissions.includes(PermissionEnum.VIEW_ASSIGNED_ORDERS);
 
-    const admin = await this.adminRepository.findOne(
+    const ordersCountPromise = canViewAnyOrder
-      { id: adminId },
+      ? this.em.count(Order)
-      { populate: ['role', 'role.permissions'] },
+      : canViewAssignedOrder
-    )
+        ? this.em.count(Order, { designers: { designer: { id: adminId } } })
+        : Promise.resolve(0);
 
-    if (!admin?.role?.permissions) return []
-
-    const adminPermissionNames = new Set(
-      admin.role.permissions.getItems().map((p) => p.name),
-    )
-    return permissionNames.filter((name) => adminPermissionNames.has(name))
-  }
-
-  async getDashboardCounts() {
     const [requestsCount, invoicesCount, ordersCount, paymentsCount] = await Promise.all([
       this.em.count(Request),
-      this.em.count(Invoice),
+      this.em.count(Invoice, { status: { $nin: [InvoiceConfirmStatusEnum.ARCHIVED] } }),
-      this.em.count(Order),
+      ordersCountPromise,
       this.em.count(Payment),
     ]);
 
@@ -233,7 +228,7 @@ export class AdminService {
       customersCount,
     ] = await Promise.all([
       this.em.count(Request),
-      this.em.count(Invoice, { confirmStatus: InvoiceConfirmStatusEnum.PENDING }),
+      this.em.count(Invoice, { status: InvoiceConfirmStatusEnum.PENDING }),
       this.em.count(Order, {
         status: { $nin: [OrderStatusEnum.FINISHED, OrderStatusEnum.CANCELED] },
       }),

src/modules/auth/auth.module.ts

@@ -1,4 +1,4 @@
-import { Module, forwardRef } from '@nestjs/common';
+import { Global, Module, forwardRef } from '@nestjs/common';
 import { AuthService } from './services/auth.service';
 import { AuthController } from './controllers/auth.controller';
 import { UtilsModule } from '../util/utils.module';
@@ -13,6 +13,7 @@ import { RefreshToken } from './entities/refresh-token.entity';
 import { NotificationsModule } from '../notification/notifications.module';
 import { OtpService } from './services/otp.service';
 
+@Global()
 @Module({
   imports: [
     UtilsModule,
@@ -38,6 +39,6 @@ import { OtpService } from './services/otp.service';
   ],
   controllers: [AuthController],
   providers: [AuthService, TokensService, AdminAuthGuard, OtpService],
-  exports: [AdminAuthGuard],
+  exports: [AdminAuthGuard, AuthService],
 })
 export class AuthModule { }

src/modules/auth/guards/adminAuth.guard.ts

@@ -13,10 +13,11 @@ import { JwtService } from '@nestjs/jwt';
 import { ConfigService } from '@nestjs/config';
 import { IAdminTokenPayload } from '../interfaces/IToken-payload';
 import { PERMISSIONS_KEY } from '../../../common/decorators/permissions.decorator';
-import { PermissionService } from 'src/modules/roles/providers/permissions.service';
+import { AuthService } from '../services/auth.service';
 
 export interface AdminAuthRequest extends Request {
   adminId: string;
+  permissions: string[];
 }
 
 @Injectable()
@@ -28,7 +29,7 @@ export class AdminAuthGuard implements CanActivate {
     private readonly jwtService: JwtService,
     @Inject(ConfigService)
     private readonly configService: ConfigService,
-    private readonly permissionsService: PermissionService,
+    private readonly authService: AuthService,
     private readonly reflector: Reflector,
   ) { }
 
@@ -61,34 +62,25 @@ export class AdminAuthGuard implements CanActivate {
 
       request['adminId'] = payload.adminId;
 
+      const adminPermissions = await this.authService.getAdminPermissionsFromCache(payload.adminId);
+      request['permissions'] = adminPermissions;
 
       // check if the user has the required permissions
       const requiredPermissions =
         this.reflector.getAllAndOverride<string[]>(PERMISSIONS_KEY, [context.getHandler(), context.getClass()]) ?? [];
 
-      if (!requiredPermissions || requiredPermissions.length === 0) {
+      if (requiredPermissions.length > 0) {
-        return true;
+        const hasPermission = requiredPermissions.every(p => adminPermissions.includes(p));
+
+        if (!hasPermission) {
+          this.logger.warn('Insufficient permissions', {
+            adminId: payload.adminId,
+            required: requiredPermissions,
+            has: hasPermission,
+          });
+          throw new ForbiddenException('You are not authorized to access this resource');
+        }
       }
-      //TODO : admin permissions must get it from cache
-      // const adminPermission = (await this.permissionsService.getAdminPermissions(payload.adminId))
-
-      // if (!adminPermission || !Array.isArray(adminPermission)) {
-      //   this.logger.error('No permissions found', { adminId: payload.adminId });
-      //   throw new ForbiddenException('No permissions found');
-      // }
-
-      // const adminPermissionNames = adminPermission.map(p => p.name)
-
-      // const hasPermission = requiredPermissions.every(p => adminPermissionNames.includes(p));
-
-      // if (!hasPermission) {
-      //   this.logger.warn('Insufficient permissions', {
-      //     adminId: payload.adminId,
-      //     required: requiredPermissions,
-      //     has: adminPermission,
-      //   });
-      //   throw new ForbiddenException('You are not authorized to access this resource');
-      // }
 
       return true;
     } catch (err) {

src/modules/auth/services/auth.service.ts

@@ -10,10 +10,12 @@ import { AdminLoginTransformer } from '../transformers/admin-login.transformer';
 import { UserLoginTransformer } from '../transformers/user-login.transformer';
 import { OtpService } from './otp.service';
 import { normalizePhoneToLocal } from 'src/modules/util/phone.util';
+import { CacheService } from 'src/modules/util/cache.service';
+import { PermissionService } from 'src/modules/roles/providers/permissions.service';
 
 @Injectable()
 export class AuthService {
-  readonly ADMIN_PERMISSIONS_KEY = 'admin-perms';
+  readonly ADMIN_PERMISSIONS_EXPIRATION_TIME = 1800;
 
   constructor(
     private readonly smsService: SmsService,
@@ -21,8 +23,10 @@ export class AuthService {
     private readonly tokensService: TokensService,
     private readonly adminRepository: AdminRepository,
     private readonly otpService: OtpService,
+    private readonly cacheService: CacheService,
+    private readonly permissionService: PermissionService,
   ) {
-   
+
   }
 
   async requestOtp(dto: RequestOtpDto, isAdmin: boolean) {
@@ -33,9 +37,9 @@ export class AuthService {
     }
 
     const code = this.generateOtpCode();
-    
+
     await this.otpService.set(phone, code)
-    
+
     // await this.smsService.sendotp(phone, code);
 
     return { code };
@@ -82,6 +86,10 @@ export class AuthService {
 
     const tokens = await this.tokensService.generateAccessAndRefreshToken(admin.id, true);
 
+    const permissionNames = admin.role.permissions.map(p => p.name);
+
+
+
     const adminResponse = await AdminLoginTransformer.transform(admin);
 
     return { tokens, admin: adminResponse };
@@ -103,4 +111,30 @@ export class AuthService {
     }
   }
 
-}
+  async setAdminPermissionsInCache(adminId: string, permissionNames: string[]) {
+    await this.cacheService.set(
+      this.getAdminPermissionsCacheKey(adminId),
+      JSON.stringify(permissionNames),
+      this.ADMIN_PERMISSIONS_EXPIRATION_TIME,
+    );
+    return { success: true };
+  }
+
+  async getAdminPermissionsFromCache(adminId: string): Promise<string[]> {
+    const cacheKey = this.getAdminPermissionsCacheKey(adminId);
+    const cached = await this.cacheService.get<string>(cacheKey);
+
+    if (cached !== undefined) {
+      return JSON.parse(cached) as string[];
+    }
+
+    const permissions = await this.permissionService.getAdminPermissionsName(adminId);
+    await this.setAdminPermissionsInCache(adminId, permissions);
+
+    return permissions;
+  }
+
+  private getAdminPermissionsCacheKey(adminId: string): string {
+    return `admin:${adminId}:permissions`;
+  }
+}

src/modules/invoice/dto/find-invoices.dto.ts

@@ -8,6 +8,7 @@ import {
   IsDateString,
   IsBoolean,
   IsEnum,
+  IsArray,
 } from 'class-validator';
 import { InvoiceConfirmStatusEnum } from '../enum/invoice-confirm-status.enum';
 import { Type, Transform } from 'class-transformer';
@@ -68,12 +69,21 @@ export class FindInvoicesDto {
   enableTax?: boolean;
 
   @ApiPropertyOptional({
+    description: 'Filter by invoice statuses',
     enum: InvoiceConfirmStatusEnum,
-    description: 'Filter by invoice confirmation status',
+    isArray: true,
   })
   @IsOptional()
-  @IsEnum(InvoiceConfirmStatusEnum)
+  @Transform(({ value }: { value: unknown }) =>
-  confirmStatus?: InvoiceConfirmStatusEnum;
+    Array.isArray(value)
+      ? value
+      : typeof value === 'string'
+        ? value.split(',')
+        : value,
+  )
+  @IsArray()
+  @IsEnum(InvoiceConfirmStatusEnum, { each: true })
+  statuses?: InvoiceConfirmStatusEnum[];
 
   @ApiPropertyOptional({ default: 'createdAt' })
   @IsOptional()

src/modules/invoice/entities/invoice.entity.ts

@@ -23,7 +23,7 @@ import { IAttachment } from 'src/modules/order/interface/order.interface';
 @Entity({ tableName: 'invoices' })
 @Index({ properties: ['user'] })
 export class Invoice extends BaseEntity {
-  [OptionalProps]?: 'createdAt' | 'deletedAt' | 'invoiceNumber' | 'confirmStatus'
+  [OptionalProps]?: 'createdAt' | 'deletedAt' | 'invoiceNumber' | 'status'
 
   @PrimaryKey({ type: 'string', columnType: 'char(26)' })
   id: string = ulid()
@@ -80,7 +80,7 @@ export class Invoice extends BaseEntity {
 
 
   @Enum(() => InvoiceConfirmStatusEnum)
-  confirmStatus: InvoiceConfirmStatusEnum = InvoiceConfirmStatusEnum.PENDING;
+  status: InvoiceConfirmStatusEnum = InvoiceConfirmStatusEnum.PENDING;
 
   @Property({ type: 'boolean', default: false })
   enableTax?: boolean = false

src/modules/invoice/enum/invoice-confirm-status.enum.ts

@@ -2,4 +2,5 @@ export enum InvoiceConfirmStatusEnum {
   PENDING = 'pending',
   PARTIALLY_CONFIRMED = 'partially_confirmed',
   CONFIRMED = 'confirmed',
+  ARCHIVED = 'archived',
 }

src/modules/invoice/enum/invoice-status.enum.ts

@@ -1,5 +0,0 @@
-export enum InvoiceStatusEnum {
-  PENDING = 'pending',
-  PAID = 'paid',
-}
-

src/modules/invoice/invoice.controller.ts

@@ -23,6 +23,13 @@ export class InvoiceController {
     return this.invoiceService.findAll(userId, dto);
   }
 
+  @Get('public/invoice/tab-counts')
+  @UseGuards(AuthGuard)
+  @ApiOperation({ summary: 'Get invoice tab counts for the current user' })
+  getTabCounts(@Query() dto: FindInvoicesDto, @UserId() userId: string) {
+    return this.invoiceService.getTabCounts(dto, userId);
+  }
+
   @Get('public/invoice/:id')
   @UseGuards(AuthGuard)
   @ApiOperation({ summary: 'Get one invoice by id' })
@@ -55,6 +62,14 @@ export class InvoiceController {
     return this.invoiceService.findAllAsAdmin(dto);
   }
 
+  @Get('admin/invoice/tab-counts')
+  @UseGuards(AdminAuthGuard)
+  @Permissions(PermissionEnum.VIEW_INVOICES)
+  @ApiOperation({ summary: 'Get invoice tab counts for admin invoice list' })
+  getTabCountsAsAdmin(@Query() dto: FindInvoicesDto) {
+    return this.invoiceService.getTabCounts(dto);
+  }
+
   @Get('admin/invoice/item/:id')
   @UseGuards(AdminAuthGuard)
   @Permissions(PermissionEnum.VIEW_INVOICES)
@@ -80,6 +95,14 @@ export class InvoiceController {
     return this.invoiceService.update(id, updateInvoiceDto);
   }
 
+  @Patch('admin/invoice/:id/archive')
+  @UseGuards(AdminAuthGuard)
+  @Permissions(PermissionEnum.UPDATE_INVOICE)
+  @ApiOperation({ summary: 'Archive an invoice (admin)' })
+  archive(@Param('id') id: string) {
+    return this.invoiceService.archive(id);
+  }
+
   @Delete('admin/invoice/:id')
   @UseGuards(AdminAuthGuard)
   @Permissions(PermissionEnum.DELETE_INVOICE)

src/modules/invoice/invoice.service.ts

@@ -12,6 +12,7 @@ import { ProductService } from '../product/providers/product.service';
 import { RequestService } from '../request/request.service';
 import { InvoiceRepository } from './repositories/invoice.repository';
 import { InvoiceCreatedEvent } from './events/invoice.events';
+import { InvoiceConfirmStatusEnum } from './enum/invoice-confirm-status.enum';
 const TAX_RATE = 0.1;
 
 type ResolvedItemDiscount = {
@@ -19,6 +20,12 @@ type ResolvedItemDiscount = {
   discountPercent?: number;
 };
 
+export type InvoiceTabCounts = {
+  pending: number;
+  confirmed: number;
+  archived: number;
+};
+
 @Injectable()
 export class InvoiceService {
   constructor(
@@ -175,6 +182,39 @@ export class InvoiceService {
     return this.invoiceRepository.findAllPaginated(dto);
   }
 
+  getTabCounts(dto: FindInvoicesDto, userId?: string): Promise<InvoiceTabCounts> {
+    const baseFilter: FindInvoicesDto & { userId?: string } = {
+      ...dto,
+      userId,
+    };
+
+    return this.countTabs(baseFilter);
+  }
+
+  private async countTabs(
+    baseFilter: FindInvoicesDto & { userId?: string },
+  ): Promise<InvoiceTabCounts> {
+    const [pending, confirmed, archived] = await Promise.all([
+      this.invoiceRepository.countByFilters({
+        ...baseFilter,
+        statuses: [InvoiceConfirmStatusEnum.PENDING],
+      }),
+      this.invoiceRepository.countByFilters({
+        ...baseFilter,
+        statuses: [
+          InvoiceConfirmStatusEnum.PARTIALLY_CONFIRMED,
+          InvoiceConfirmStatusEnum.CONFIRMED,
+        ],
+      }),
+      this.invoiceRepository.countByFilters({
+        ...baseFilter,
+        statuses: [InvoiceConfirmStatusEnum.ARCHIVED],
+      }),
+    ]);
+
+    return { pending, confirmed, archived };
+  }
+
   async findOne(id: string, userId: string) {
     const invoice = await this.em.findOne(
       Invoice,
@@ -336,6 +376,16 @@ export class InvoiceService {
     return invoice;
   }
 
+  async archive(id: string) {
+    const invoice = await this.findOneOrFail(id);
+    if (invoice.status === InvoiceConfirmStatusEnum.ARCHIVED) {
+      throw new BadRequestException('Invoice is already archived');
+    }
+    invoice.status = InvoiceConfirmStatusEnum.ARCHIVED;
+    await this.em.flush();
+    return invoice;
+  }
+
   async remove(id: string) {
     const invoice = await this.findOneOrFail(id);
     this.em.remove(invoice);

src/modules/invoice/repositories/invoice.repository.ts

@@ -4,6 +4,7 @@ import { FilterQuery } from '@mikro-orm/core';
 import { Invoice } from '../entities/invoice.entity';
 import { PaginatedResult } from 'src/common/interfaces/pagination.interface';
 import { FindInvoicesDto } from '../dto/find-invoices.dto';
+import { InvoiceConfirmStatusEnum } from '../enum/invoice-confirm-status.enum';
 
 interface FindInvoicesOpts extends FindInvoicesDto {
   userId?: string;
@@ -15,23 +16,17 @@ export class InvoiceRepository extends EntityRepository<Invoice> {
     super(em, Invoice);
   }
 
-  async findAllPaginated(opts: FindInvoicesOpts): Promise<PaginatedResult<Invoice>> {
+  private buildWhere(opts: FindInvoicesOpts): FilterQuery<Invoice> {
     const {
-      page = 1,
-      limit = 10,
       search,
-      orderBy = 'createdAt',
-      order = 'desc',
       userId,
       from,
       to,
       enableTax,
       requestId,
-      confirmStatus,
+      statuses,
     } = opts;
 
-    const offset = (page - 1) * limit;
-
     const where: FilterQuery<Invoice> = {};
 
     if (userId) {
@@ -46,8 +41,17 @@ export class InvoiceRepository extends EntityRepository<Invoice> {
       where.enableTax = enableTax;
     }
 
-    if (confirmStatus) {
+    if (statuses) {
-      where.confirmStatus = confirmStatus;
+      const normalizedStatuses = Array.isArray(statuses) ? statuses : [statuses];
+      const validStatuses = normalizedStatuses.filter(
+        (s): s is InvoiceConfirmStatusEnum => !!s,
+      );
+
+      if (validStatuses.length === 1) {
+        where.status = validStatuses[0];
+      } else if (validStatuses.length > 1) {
+        where.status = { $in: validStatuses };
+      }
     }
 
     if (from || to) {
@@ -76,6 +80,20 @@ export class InvoiceRepository extends EntityRepository<Invoice> {
       where.$or = searchConditions;
     }
 
+    return where;
+  }
+
+  async findAllPaginated(opts: FindInvoicesOpts): Promise<PaginatedResult<Invoice>> {
+    const {
+      page = 1,
+      limit = 10,
+      orderBy = 'createdAt',
+      order = 'desc',
+    } = opts;
+
+    const offset = (page - 1) * limit;
+    const where = this.buildWhere(opts);
+
     const [data, total] = await this.findAndCount(where, {
       limit,
       offset,
@@ -95,4 +113,8 @@ export class InvoiceRepository extends EntityRepository<Invoice> {
       },
     };
   }
+
+  async countByFilters(opts: FindInvoicesOpts): Promise<number> {
+    return this.count(this.buildWhere(opts));
+  }
 }

src/modules/order/controllers/order.controller.ts

@@ -7,6 +7,7 @@ import { FindOrdersDto } from '../dto/find-orders.dto';
 import { CreateOrderAsAdminDto } from '../dto/create-order.dto';
 import { UpdateOrderAsAdminDto } from '../dto/update-order.dto';
 import { AdminId } from 'src/common/decorators/admin-id.decorator';
+import { AdminPerms } from 'src/common/decorators/admin-perms.decorator';
 import { AdminAuthGuard } from 'src/modules/auth/guards/adminAuth.guard';
 import { Permissions } from 'src/common/decorators/permissions.decorator';
 import { PermissionEnum } from 'src/common/enums/permission.enum';
@@ -39,7 +40,7 @@ export class OrderController {
   @Get('public/orders/stats')
   @UseGuards(AuthGuard)
   @ApiOperation({ summary: 'Get User Orders stats' })
-  getStats( @UserId() userId: string) {
+  getStats(@UserId() userId: string) {
     return this.orderService.getStats(userId);
   }
   /*==========================  Admin Routes =====================*/
@@ -55,17 +56,24 @@ export class OrderController {
   // Permission handled inside service
   @Get('admin/orders')
   @UseGuards(AdminAuthGuard)
-  // @Permissions(PermissionEnum.VIEW_ORDERS)
   @ApiOperation({ summary: 'Get all orders with pagination and filters' })
-  findAllAsAdmin(@Query() dto: FindOrdersDto, @AdminId() adminId: string) {
+  findAllAsAdmin(
-    return this.orderService.findOrdersAsAdmin(adminId, dto);
+    @Query() dto: FindOrdersDto,
+    @AdminId() adminId: string,
+    @AdminPerms() permissions: string[],
+  ) {
+    return this.orderService.findOrdersAsAdmin(adminId, permissions, dto);
   }
 
   @Get('admin/orders/tab-counts')
   @UseGuards(AdminAuthGuard)
   @ApiOperation({ summary: 'Get order tab counts for admin order list' })
-  getAdminOrderTabCounts(@Query() dto: FindOrdersDto, @AdminId() adminId: string) {
+  getAdminOrderTabCounts(
-    return this.orderService.getAdminOrderTabCounts(adminId, dto);
+    @Query() dto: FindOrdersDto,
+    @AdminId() adminId: string,
+    @AdminPerms() permissions: string[],
+  ) {
+    return this.orderService.getAdminOrderTabCounts(adminId, permissions, dto);
   }
 
   @Get('admin/orders/:id')
@@ -106,8 +114,13 @@ export class OrderController {
   @Post('admin/orders/:orderId/status')
   @UseGuards(AdminAuthGuard)
   @ApiOperation({ summary: 'Assign Order Designer ' })
-  updateStatus(@Param('orderId') orderId: string,@AdminId()adminId:string, @Body() dto: UpdateStatusDto) {
+  updateStatus(
-    return this.orderService.updateStatus(orderId,adminId, dto);
+    @Param('orderId') orderId: string,
+    @AdminId() adminId: string,
+    @AdminPerms() permissions: string[],
+    @Body() dto: UpdateStatusDto,
+  ) {
+    return this.orderService.updateStatus(orderId, adminId, permissions, dto);
   }
 
 

src/modules/order/providers/order.service.ts

@@ -158,10 +158,11 @@ export class OrderService {
     })
   }
 
-  async findOrdersAsAdmin(adminId: string, dto: FindOrdersDto): Promise<PaginatedResult<Order>> {
+  async findOrdersAsAdmin(
-    const permissions = await this.adminService.ownedPermissions(adminId,
+    adminId: string,
-      [PermissionEnum.VIEW_ORDERS, PermissionEnum.VIEW_ASSIGNED_ORDERS])
+    permissions: string[],
-
+    dto: FindOrdersDto,
+  ): Promise<PaginatedResult<Order>> {
     if (permissions.includes(PermissionEnum.VIEW_ORDERS)) {
 
       return this.orderRepository.findAllPaginated(dto)
@@ -179,12 +180,11 @@ export class OrderService {
     }
   }
 
-  async getAdminOrderTabCounts(adminId: string, dto: FindOrdersDto): Promise<AdminOrderTabCounts> {
+  async getAdminOrderTabCounts(
-    const permissions = await this.adminService.ownedPermissions(adminId, [
+    adminId: string,
-      PermissionEnum.VIEW_ORDERS,
+    permissions: string[],
-      PermissionEnum.VIEW_ASSIGNED_ORDERS,
+    dto: FindOrdersDto,
-    ]);
+  ): Promise<AdminOrderTabCounts> {
-
     const canViewAnyOrder = permissions.includes(PermissionEnum.VIEW_ORDERS);
     const canViewAssignedOrder = permissions.includes(PermissionEnum.VIEW_ASSIGNED_ORDERS);
 
@@ -300,18 +300,12 @@ export class OrderService {
 
 
 
-  async updateStatus(orderId: string, adminId: string, dto: UpdateStatusDto): Promise<Order> {
+  async updateStatus(
-    const statusPermissions = [
+    orderId: string,
-      PermissionEnum.CHANGE_ORDER_STATUS_FROM_ANY_TO_ANY,
+    adminId: string,
-      PermissionEnum.CHANGE_ORDER_STATUS_TO_CANCELLED,
+    permissions: string[],
-      PermissionEnum.CHANGE_ORDER_STATUS_IN_PROGRESS,
+    dto: UpdateStatusDto,
-      PermissionEnum.CHANGE_ORDER_STATUS_FROM_IN_PROGRESS_TO_FINISHED,
+  ): Promise<Order> {
-      PermissionEnum.CHANGE_ORDER_STATUS_FROM_FINISHED_TO_INVOICED,
-    ];
-
-    const permissions = await this.adminService.ownedPermissions(adminId,
-      [PermissionEnum.VIEW_ORDERS, PermissionEnum.VIEW_ASSIGNED_ORDERS, ...statusPermissions]);
-
     const canViewAnyOrder = permissions.includes(PermissionEnum.VIEW_ORDERS);
     const canViewAssignedOrder = permissions.includes(PermissionEnum.VIEW_ASSIGNED_ORDERS);
 

src/modules/product/controllers/product.controller.ts

@@ -50,6 +50,7 @@ export class ProductController {
   @ApiQuery({ name: 'orderBy', required: false, type: String })
   @ApiQuery({ name: 'order', required: false, enum: ['asc', 'desc'] })
   @ApiQuery({ name: 'isActive', required: false, type: Boolean })
+  @ApiQuery({ name: 'parentId', required: false, type: String, description: 'Parent category id, or "null" for roots' })
   async findAllCategories(@Query() dto: FindCategoriesDto) {
     const result = await this.categoryService.findAll(dto);
     return result;

src/modules/product/dto/find-categories.dto.ts

@@ -36,4 +36,12 @@ export class FindCategoriesDto {
   @Type(() => Boolean)
   @ApiPropertyOptional({ example: true })
   isActive?: boolean;
+
+  @IsOptional()
+  @IsString()
+  @ApiPropertyOptional({
+    description: 'Filter by parent category id. Use "null" for root categories only.',
+    example: 'null',
+  })
+  parentId?: string;
 }

src/modules/product/repositories/category.repository.ts

@@ -11,6 +11,7 @@ type FindCategoriesOpts = {
   orderBy?: string;
   order?: 'asc' | 'desc';
   isActive?: boolean;
+  parentId?: string;
 };
 
 export type CategoryTreeNode = {
@@ -73,7 +74,7 @@ export class CategoryRepository extends EntityRepository<Category> {
   }
 
   async findAllPaginated(opts: FindCategoriesOpts = {}): Promise<PaginatedResult<Category>> {
-    const { page = 1, limit = 10, search, orderBy = 'createdAt', order = 'desc', isActive } = opts;
+    const { page = 1, limit = 10, search, orderBy = 'order', order = 'asc', isActive, parentId } = opts;
 
     const offset = (page - 1) * limit;
 
@@ -83,6 +84,12 @@ export class CategoryRepository extends EntityRepository<Category> {
       where.isActive = isActive;
     }
 
+    if (parentId === 'null') {
+      where.parent = null;
+    } else if (parentId) {
+      where.parent = parentId;
+    }
+
     if (search) {
       where.$or = [
         { title: { $ilike: `%${search}%` } },
@@ -91,7 +98,7 @@ export class CategoryRepository extends EntityRepository<Category> {
 
     const allCategories = await this.find(where, {
       orderBy: { [orderBy]: order.toLowerCase() as 'asc' | 'desc' },
-      populate: ['parent'],
+      populate: ['parent', 'children'],
     });
 
     const total = allCategories.length;

src/modules/product/repositories/product.repository.ts

@@ -21,7 +21,7 @@ export class ProductRepository extends EntityRepository<Product> {
   }
 
   async findAllPaginated(opts: FindproductsOpts = {}): Promise<PaginatedResult<Product>> {
-    const { page = 1, limit = 10, search, orderBy = 'createdAt', order = 'desc', categoryId, isActive } = opts;
+    const { page = 1, limit = 10, search, orderBy = 'order', order = 'asc', categoryId, isActive } = opts;
 
     const offset = (page - 1) * limit;
 

src/modules/user/controllers/users.controller.ts

@@ -39,9 +39,9 @@ export class UsersController {
     return user;
   }
 
-  @Get('public/dashboard/counts')
+  @Get('public/menu/counts')
   @UseGuards(AuthGuard)
-  @ApiOperation({ summary: 'Get dashboard entity counts for user panel' })
+  @ApiOperation({ summary: 'Get metrics for user panel' })
   getDashboardCounts(@UserId() userId: string) {
     return this.userService.getDashboardCounts(userId);
   }

src/modules/user/providers/user.service.ts

@@ -13,6 +13,7 @@ import { Request } from 'src/modules/request/entities/request.entity';
 import { Invoice } from 'src/modules/invoice/entities/invoice.entity';
 import { Order } from 'src/modules/order/entities/order.entity';
 import { Payment } from 'src/modules/payment/entities/payment.entity';
+import { InvoiceConfirmStatusEnum } from 'src/modules/invoice/enum/invoice-confirm-status.enum';
 
 @Injectable()
 export class UserService {
@@ -125,7 +126,7 @@ export class UserService {
   async getDashboardCounts(userId: string) {
     const [requestsCount, invoicesCount, ordersCount, paymentsCount] = await Promise.all([
       this.em.count(Request, { user: { id: userId } }),
-      this.em.count(Invoice, { user: { id: userId } }),
+      this.em.count(Invoice, { user: { id: userId }, status: { $nin: [InvoiceConfirmStatusEnum.ARCHIVED] } }),
       this.em.count(Order, { user: { id: userId } }),
       this.em.count(Payment, { invoice: { user: { id: userId } } }),
     ]);

src/seeders/data/admins.data.ts

@@ -13,13 +13,13 @@ export const adminsData: AdminData[] = [
     roleName: 'admin',
 
   },
-  {
+  // {
-    phone: '09121724095',
+  //   phone: '09121724095',
-    firstName: 'آقای',
+  //   firstName: 'آقای',
-    lastName: 'نواعتقاد',
+  //   lastName: 'نواعتقاد',
-    roleName:  'admin',
+  //   roleName:  'admin',
 
-  },
+  // },
   // {
   //   phone: '09185290775',
   //   firstName: 'حمید',