Editing of the project's Kariz page

apps/api/src/common/excel.ts

@@ -144,6 +144,16 @@ export function formatClock(d: Date | string | null | undefined) {
   return `${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}`;
 }
 
+export function parseAmount(raw?: string): number | null {
+  const text = toAsciiDigits(raw ?? '')
+    .replace(/[,،]/g, '')
+    .replace(/\s+/g, '')
+    .trim();
+  if (!text) return null;
+  const n = Number(text.replace(/[^\d.-]/g, ''));
+  return Number.isFinite(n) ? n : null;
+}
+
 export function parseJalaliDateTime(dateRaw?: string, timeRaw?: string): Date | null {
   const dateText = toAsciiDigits(dateRaw ?? '').trim();
   if (!dateText) return null;

apps/api/src/pipelines/deals-excel.service.ts

@@ -0,0 +1,319 @@
+import { Injectable } from '@nestjs/common';
+import type { DealStatus, ImportContactsResult } from '@mento/shared';
+import { Prisma } from '@prisma/client';
+import { PrismaService } from '../prisma/prisma.service';
+import type { Actor } from '../common/record-scope';
+import { ownerWhere, resolveOwnerId } from '../common/record-scope';
+import { toJsonCustomFields } from '../common/custom-fields';
+import { normalizePhone } from '../contacts/normalize';
+import {
+  formatJalaliDate,
+  parseAmount,
+  parseJalaliDateTime,
+  readMappedRows,
+  writeXlsx,
+} from '../common/excel';
+import { PipelinesService } from './pipelines.service';
+
+const DEAL_COLUMNS = [
+  { header: '_type', key: '_type', width: 12 },
+  { header: 'کد دیدار معامله', key: 'didarId', width: 16 },
+  { header: 'عنوان معامله', key: 'title', width: 28 },
+  { header: 'مبلغ معامله', key: 'amount', width: 16 },
+  { header: 'ارز معامله', key: 'currency', width: 12 },
+  { header: 'وضعیت معامله', key: 'status', width: 14 },
+  { header: 'مسئول معامله', key: 'ownerName', width: 18 },
+  { header: 'مجوز مشاهده معامله', key: 'visibility', width: 18 },
+  { header: 'تاریخ ثبت معامله', key: 'createdAt', width: 16 },
+  { header: 'نام خانوادگی شخص معامله', key: 'personName', width: 22 },
+  { header: 'کد دیدار شخص', key: 'personCode', width: 14 },
+  { header: 'موبایل شخص معامله', key: 'personMobile', width: 16 },
+  { header: 'نام شرکت معامله', key: 'companyName', width: 22 },
+  { header: 'کاریز معامله', key: 'pipelineName', width: 20 },
+  { header: 'مرحله کاریز معامله', key: 'stageName', width: 18 },
+  { header: 'تاریخ انجام معامله', key: 'expectedCloseAt', width: 16 },
+  { header: 'منبع معامله', key: 'source', width: 16 },
+  { header: 'توضیحات معامله', key: 'notes', width: 32 },
+  { header: 'برچسب', key: 'tags', width: 16 },
+];
+
+const DEAL_ALIASES: Record<string, string> = {
+  _type: '_type',
+  type: '_type',
+  کددیدارمعامله: 'didarId',
+  عنوانمعامله: 'title',
+  عنوان: 'title',
+  مبلغمعامله: 'amount',
+  مبلغ: 'amount',
+  ارزمعامله: 'currency',
+  ارز: 'currency',
+  وضعیتمعامله: 'status',
+  مسئولمعامله: 'ownerName',
+  مجوزمشاهدهمعامله: 'visibility',
+  تاریخثبتمعامله: 'createdAt',
+  نامخانوادگیشخصمعامله: 'personName',
+  کددیدارشخص: 'personCode',
+  موبایلشخصمعامله: 'personMobile',
+  نامشرکتمعامله: 'companyName',
+  شرکت: 'companyName',
+  کاریزمعامله: 'pipelineName',
+  کاریز: 'pipelineName',
+  مرحلهکاریزمعامله: 'stageName',
+  مرحله: 'stageName',
+  تاریخانجاممعامله: 'expectedCloseAt',
+  منبعمعامله: 'source',
+  منبع: 'source',
+  توضیحاتمعامله: 'notes',
+  توضیحات: 'notes',
+  برچسب: 'tags',
+};
+
+function statusLabel(status: DealStatus) {
+  if (status === 'won') return 'برنده';
+  if (status === 'lost') return 'از دست‌رفته';
+  return 'باز';
+}
+
+function parseStatus(raw?: string): DealStatus {
+  const v = (raw ?? '').trim();
+  if (/برنده|won|موفق/i.test(v)) return 'won';
+  if (/از\s*دست|باخت|lost|ناموفق/i.test(v)) return 'lost';
+  return 'open';
+}
+
+function parseTags(raw?: string) {
+  return (raw ?? '')
+    .split(/[،,|#]+/)
+    .map((t) => t.trim())
+    .filter(Boolean)
+    .slice(0, 20);
+}
+
+@Injectable()
+export class DealsExcelService {
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly pipelines: PipelinesService,
+  ) {}
+
+  async export(actor: Actor): Promise<Buffer> {
+    const rows = await this.prisma.deal.findMany({
+      where: { organizationId: actor.organizationId, ...ownerWhere(actor) },
+      include: {
+        person: {
+          select: { id: true, firstName: true, lastName: true, mobile: true },
+        },
+        company: { select: { name: true } },
+        owner: { select: { fullName: true } },
+        pipeline: { select: { name: true } },
+        stage: { select: { name: true } },
+      },
+      orderBy: [{ updatedAt: 'desc' }],
+      take: 10000,
+    });
+
+    return writeXlsx(
+      'Deal',
+      DEAL_COLUMNS,
+      rows.map((row) => {
+        const extra = (row.customFields ?? {}) as Record<string, string>;
+        return {
+          _type: 'Deal',
+          didarId: extra.didarId ?? row.id,
+          title: row.title,
+          amount: row.amount == null ? '' : Number(row.amount),
+          currency: row.currency,
+          status: statusLabel(row.status),
+          ownerName: row.owner?.fullName ?? '',
+          visibility: 'همه افراد شرکت',
+          createdAt: formatJalaliDate(row.createdAt),
+          personName: row.person
+            ? `${row.person.firstName} ${row.person.lastName}`.trim()
+            : '',
+          personCode: row.person?.id ?? '',
+          personMobile: row.person?.mobile ?? '',
+          companyName: row.company?.name ?? '',
+          pipelineName: row.pipeline.name,
+          stageName: row.stage.name,
+          expectedCloseAt: formatJalaliDate(row.expectedCloseAt),
+          source: row.source ?? '',
+          notes: row.notes ?? '',
+          tags: (row.tags ?? []).join('، '),
+        };
+      }),
+    );
+  }
+
+  async import(actor: Actor, file: Express.Multer.File): Promise<ImportContactsResult> {
+    const rows = await readMappedRows(file, DEAL_ALIASES);
+    const result: ImportContactsResult = { created: 0, skipped: 0, errors: [] };
+    const affected = new Map<string, string>();
+
+    for (let i = 0; i < rows.length; i++) {
+      const row = rows[i]!;
+      const rowNum = i + 2;
+      if ((row._type || '').trim() && row._type.trim().toLowerCase() !== 'deal') {
+        continue;
+      }
+      const title = (row.title || '').trim();
+      if (title.length < 2) {
+        result.errors.push({ row: rowNum, message: 'عنوان معامله الزامی است' });
+        continue;
+      }
+
+      try {
+        const status = parseStatus(row.status);
+        const { pipelineId, stageId, pipelineName } = await this.resolvePipelineAndStage(
+          actor.organizationId,
+          row.pipelineName,
+          row.stageName,
+          status,
+        );
+        affected.set(pipelineId, pipelineName);
+
+        const duplicate = await this.prisma.deal.findFirst({
+          where: { organizationId: actor.organizationId, pipelineId, title },
+          select: { id: true },
+        });
+        if (duplicate) {
+          result.skipped += 1;
+          continue;
+        }
+
+        const personId = await this.findPersonId(actor.organizationId, row);
+        const companyId = await this.findCompanyId(actor.organizationId, row.companyName);
+        const ownerId =
+          (await this.findUserId(actor.organizationId, row.ownerName)) ??
+          resolveOwnerId(actor, null);
+        const amount = parseAmount(row.amount);
+        const expectedCloseAt = parseJalaliDateTime(row.expectedCloseAt);
+        const customFields: Record<string, string> = {};
+        if (row.didarId?.trim()) customFields.didarId = row.didarId.trim();
+
+        await this.prisma.deal.create({
+          data: {
+            organizationId: actor.organizationId,
+            pipelineId,
+            stageId,
+            title,
+            amount: amount == null ? null : new Prisma.Decimal(amount),
+            currency: (row.currency || 'IRR').trim() || 'IRR',
+            status,
+            source: row.source?.trim() || null,
+            notes: row.notes?.trim() || null,
+            tags: parseTags(row.tags),
+            customFields: toJsonCustomFields(customFields),
+            expectedCloseAt,
+            personId,
+            companyId,
+            ownerId,
+          },
+        });
+        result.created += 1;
+      } catch (e) {
+        result.errors.push({
+          row: rowNum,
+          message: e instanceof Error ? e.message : 'خطای ناشناخته',
+        });
+      }
+    }
+
+    const entries = [...affected.entries()];
+    if (entries[0]) {
+      result.boardId = entries[0][0];
+      result.boards = entries.map(([, n]) => n);
+    }
+    return result;
+  }
+
+  private async resolvePipelineAndStage(
+    organizationId: string,
+    pipelineName?: string,
+    stageName?: string,
+    status: DealStatus = 'open',
+  ) {
+    const name = pipelineName?.trim() || 'کاریز فروش';
+    const wanted = stageName?.trim();
+    let pipeline = await this.prisma.pipeline.findFirst({
+      where: { organizationId, name: { equals: name, mode: 'insensitive' } },
+      include: { stages: { orderBy: { position: 'asc' } } },
+    });
+    if (!pipeline) {
+      const created = await this.pipelines.create(organizationId, name);
+      pipeline = await this.prisma.pipeline.findFirstOrThrow({
+        where: { id: created.id },
+        include: { stages: { orderBy: { position: 'asc' } } },
+      });
+    }
+
+    if (wanted) {
+      const existing = pipeline.stages.find(
+        (s) => s.name.trim().toLowerCase() === wanted.toLowerCase(),
+      );
+      if (existing) {
+        return { pipelineId: pipeline.id, stageId: existing.id, pipelineName: pipeline.name };
+      }
+      const added = await this.pipelines.createStage(organizationId, pipeline.id, wanted);
+      const stage = added.stages.find((s) => s.name === wanted) ?? added.stages.at(-1);
+      if (!stage) throw new Error('کاریز مرحله‌ای ندارد');
+      return { pipelineId: pipeline.id, stageId: stage.id, pipelineName: pipeline.name };
+    }
+
+    const byStatus =
+      status === 'won'
+        ? pipeline.stages.find((s) => s.isWon)
+        : status === 'lost'
+          ? pipeline.stages.find((s) => s.isLost)
+          : pipeline.stages.find((s) => !s.isWon && !s.isLost);
+    const stage = byStatus ?? pipeline.stages[0];
+    if (!stage) throw new Error('کاریز مرحله‌ای ندارد');
+    return { pipelineId: pipeline.id, stageId: stage.id, pipelineName: pipeline.name };
+  }
+
+  private async findPersonId(organizationId: string, row: Record<string, string>) {
+    const mobile = normalizePhone(row.personMobile);
+    if (mobile) {
+      const needle = mobile.replace(/^\+98|^98|^0/, '');
+      const byMobile = await this.prisma.person.findFirst({
+        where: { organizationId, mobile: { contains: needle } },
+        select: { id: true },
+      });
+      if (byMobile) return byMobile.id;
+    }
+    const name = (row.personName ?? '').trim();
+    if (name) {
+      const byName = await this.prisma.person.findFirst({
+        where: {
+          organizationId,
+          OR: [
+            { lastName: { contains: name, mode: 'insensitive' } },
+            { firstName: { contains: name.split(/\s+/)[0]!, mode: 'insensitive' } },
+          ],
+        },
+        select: { id: true },
+      });
+      if (byName) return byName.id;
+    }
+    return null;
+  }
+
+  private async findCompanyId(organizationId: string, name?: string) {
+    const n = name?.trim();
+    if (!n) return null;
+    const row = await this.prisma.company.findFirst({
+      where: { organizationId, name: { equals: n, mode: 'insensitive' } },
+      select: { id: true },
+    });
+    return row?.id ?? null;
+  }
+
+  private async findUserId(organizationId: string, name?: string) {
+    const n = name?.trim();
+    if (!n) return null;
+    const row = await this.prisma.user.findFirst({
+      where: { organizationId, fullName: { contains: n, mode: 'insensitive' } },
+      select: { id: true },
+    });
+    return row?.id ?? null;
+  }
+}

apps/api/src/pipelines/deals.controller.ts

@@ -6,33 +6,72 @@ import {
   Param,
   Patch,
   Post,
+  Res,
+  StreamableFile,
+  UploadedFile,
   UseGuards,
+  UseInterceptors,
 } from '@nestjs/common';
+import { FileInterceptor } from '@nestjs/platform-express';
+import { memoryStorage } from 'multer';
+import type { Response } from 'express';
 import { JwtAuthGuard } from '../auth/jwt-auth.guard';
 import { CurrentUser } from '../auth/current-user.decorator';
+import type { Actor } from '../common/record-scope';
 import { CreateDealDto, MoveDealDto, UpdateDealDto } from './dto';
 import { DealsService } from './deals.service';
-
-type AuthUser = { organizationId: string; userId: string; role: string };
+import { DealsExcelService } from './deals-excel.service';
+import { brand } from '@mento/shared';
 
 @Controller('deals')
 @UseGuards(JwtAuthGuard)
 export class DealsController {
-  constructor(private readonly dealsService: DealsService) {}
+  constructor(
+    private readonly dealsService: DealsService,
+    private readonly excelService: DealsExcelService,
+  ) {}
+
+  @Get('export')
+  async export(
+    @CurrentUser() user: Actor,
+    @Res({ passthrough: true }) res: Response,
+  ) {
+    const buffer = await this.excelService.export(user);
+    res.set({
+      'Content-Type':
+        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+      'Content-Disposition': `attachment; filename="${brand.filePrefix}-deals.xlsx"`,
+    });
+    return new StreamableFile(buffer);
+  }
+
+  @Post('import')
+  @UseInterceptors(
+    FileInterceptor('file', {
+      storage: memoryStorage(),
+      limits: { fileSize: 15_000_000 },
+    }),
+  )
+  import(
+    @CurrentUser() user: Actor,
+    @UploadedFile() file: Express.Multer.File,
+  ) {
+    return this.excelService.import(user, file);
+  }
 
   @Get(':id')
-  get(@CurrentUser() user: AuthUser, @Param('id') id: string) {
+  get(@CurrentUser() user: Actor, @Param('id') id: string) {
     return this.dealsService.get(user.organizationId, id, user);
   }
 
   @Post()
-  create(@CurrentUser() user: AuthUser, @Body() dto: CreateDealDto) {
+  create(@CurrentUser() user: Actor, @Body() dto: CreateDealDto) {
     return this.dealsService.create(user.organizationId, user, dto);
   }
 
   @Patch(':id')
   update(
-    @CurrentUser() user: AuthUser,
+    @CurrentUser() user: Actor,
     @Param('id') id: string,
     @Body() dto: UpdateDealDto,
   ) {
@@ -41,7 +80,7 @@ export class DealsController {
 
   @Patch(':id/move')
   move(
-    @CurrentUser() user: AuthUser,
+    @CurrentUser() user: Actor,
     @Param('id') id: string,
     @Body() dto: MoveDealDto,
   ) {
@@ -49,7 +88,7 @@ export class DealsController {
   }
 
   @Delete(':id')
-  async remove(@CurrentUser() user: AuthUser, @Param('id') id: string) {
+  async remove(@CurrentUser() user: Actor, @Param('id') id: string) {
     await this.dealsService.remove(user.organizationId, id, user);
     return { ok: true };
   }

apps/api/src/pipelines/pipelines.module.ts

@@ -1,6 +1,7 @@
 import { Module, forwardRef } from '@nestjs/common';
 import { DealsController } from './deals.controller';
 import { DealsService } from './deals.service';
+import { DealsExcelService } from './deals-excel.service';
 import { PipelinesController } from './pipelines.controller';
 import { PipelinesService } from './pipelines.service';
 import { NotificationsModule } from '../notifications/notifications.module';
@@ -16,7 +17,7 @@ import { MessageAutomationsModule } from '../message-automations/message-automat
     MessageAutomationsModule,
   ],
   controllers: [PipelinesController, DealsController],
-  providers: [PipelinesService, DealsService],
+  providers: [PipelinesService, DealsService, DealsExcelService],
   exports: [PipelinesService, DealsService],
 })
 export class PipelinesModule {}

apps/api/src/products/products-excel.service.ts

@@ -0,0 +1,172 @@
+import { Injectable } from '@nestjs/common';
+import type { ImportContactsResult } from '@mento/shared';
+import { PrismaService } from '../prisma/prisma.service';
+import {
+  parseAmount,
+  readMappedRows,
+  writeXlsx,
+} from '../common/excel';
+import { ProductsService } from './products.service';
+
+const PRODUCT_COLUMNS = [
+  { header: '_type', key: '_type', width: 12 },
+  { header: 'نوع', key: 'kind', width: 12 },
+  { header: 'نام محصول', key: 'name', width: 28 },
+  { header: 'کد کالا', key: 'sku', width: 16 },
+  { header: 'دسته‌بندی', key: 'category', width: 16 },
+  { header: 'واحد', key: 'unit', width: 10 },
+  { header: 'موجودی', key: 'stockQty', width: 12 },
+  { header: 'برند', key: 'brand', width: 14 },
+  { header: 'مدل', key: 'model', width: 14 },
+  { header: 'کشور', key: 'country', width: 12 },
+  { header: 'قیمت واحد', key: 'unitPrice', width: 14 },
+  { header: 'ارز', key: 'currency', width: 10 },
+  { header: 'وضعیت', key: 'active', width: 12 },
+  { header: 'برچسب', key: 'tags', width: 16 },
+  { header: 'توضیحات', key: 'description', width: 32 },
+];
+
+const PRODUCT_ALIASES: Record<string, string> = {
+  _type: '_type',
+  type: '_type',
+  نوع: 'kind',
+  ناممحصول: 'name',
+  نام: 'name',
+  نامکالا: 'name',
+  کدکالا: 'sku',
+  sku: 'sku',
+  کد: 'sku',
+  دستهبندی: 'category',
+  دسته: 'category',
+  واحد: 'unit',
+  موجودی: 'stockQty',
+  برند: 'brand',
+  مدل: 'model',
+  کشور: 'country',
+  قیمتواحد: 'unitPrice',
+  قیمت: 'unitPrice',
+  ارز: 'currency',
+  وضعیت: 'active',
+  فعال: 'active',
+  برچسب: 'tags',
+  توضیحات: 'description',
+};
+
+function kindLabel(kind: string) {
+  return kind === 'service' ? 'خدمت' : 'کالا';
+}
+
+function parseKind(raw?: string): 'product' | 'service' {
+  return /خدمت|service/i.test(raw ?? '') ? 'service' : 'product';
+}
+
+function parseActive(raw?: string) {
+  const v = (raw ?? '').trim();
+  if (!v) return true;
+  return !/غیرفعال|inactive|خیر|no|0/i.test(v);
+}
+
+function parseTags(raw?: string) {
+  return (raw ?? '')
+    .split(/[،,|#]+/)
+    .map((t) => t.trim())
+    .filter(Boolean)
+    .slice(0, 20);
+}
+
+@Injectable()
+export class ProductsExcelService {
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly products: ProductsService,
+  ) {}
+
+  async export(organizationId: string, q?: string): Promise<Buffer> {
+    const items = await this.products.list(organizationId, { q });
+    return writeXlsx(
+      'Product',
+      PRODUCT_COLUMNS,
+      items.map((p) => ({
+        _type: 'Product',
+        kind: kindLabel(p.kind),
+        name: p.name,
+        sku: p.sku ?? '',
+        category: p.category ?? '',
+        unit: p.unit ?? '',
+        stockQty: p.stockQty ?? '',
+        brand: p.brand ?? '',
+        model: p.model ?? '',
+        country: p.country ?? '',
+        unitPrice: p.unitPrice ?? '',
+        currency: p.currency,
+        active: p.isActive ? 'فعال' : 'غیرفعال',
+        tags: (p.tags ?? []).join('، '),
+        description: p.description ?? '',
+      })),
+    );
+  }
+
+  async import(
+    organizationId: string,
+    file: Express.Multer.File,
+  ): Promise<ImportContactsResult> {
+    const rows = await readMappedRows(file, PRODUCT_ALIASES);
+    const result: ImportContactsResult = { created: 0, skipped: 0, errors: [] };
+
+    for (let i = 0; i < rows.length; i++) {
+      const row = rows[i]!;
+      const rowNum = i + 2;
+      if ((row._type || '').trim() && row._type.trim().toLowerCase() !== 'product') {
+        continue;
+      }
+      const name = (row.name || '').trim();
+      if (name.length < 1) {
+        result.errors.push({ row: rowNum, message: 'نام محصول الزامی است' });
+        continue;
+      }
+
+      const sku = row.sku?.trim() || undefined;
+      const duplicate = await this.prisma.product.findFirst({
+        where: {
+          organizationId,
+          OR: [
+            ...(sku ? [{ sku: { equals: sku, mode: 'insensitive' as const } }] : []),
+            { name: { equals: name, mode: 'insensitive' } },
+          ],
+        },
+        select: { id: true },
+      });
+      if (duplicate) {
+        result.skipped += 1;
+        continue;
+      }
+
+      try {
+        await this.products.create(organizationId, {
+          name,
+          kind: parseKind(row.kind),
+          sku,
+          category: row.category || undefined,
+          unit: row.unit || undefined,
+          stockQty: parseAmount(row.stockQty),
+          brand: row.brand || undefined,
+          model: row.model || undefined,
+          country: row.country || undefined,
+          tags: parseTags(row.tags),
+          unitPrice: parseAmount(row.unitPrice),
+          currency: row.currency || undefined,
+          isActive: parseActive(row.active),
+          description: row.description || undefined,
+        });
+        result.created += 1;
+      } catch (e) {
+        result.errors.push({
+          row: rowNum,
+          message: e instanceof Error ? e.message : 'خطای ناشناخته',
+        });
+      }
+    }
+
+    return result;
+  }
+}

apps/api/src/products/products.controller.ts

@@ -7,19 +7,32 @@ import {
   Patch,
   Post,
   Query,
+  Res,
+  StreamableFile,
+  UploadedFile,
   UseGuards,
+  UseInterceptors,
 } from '@nestjs/common';
+import { FileInterceptor } from '@nestjs/platform-express';
+import { memoryStorage } from 'multer';
+import type { Response } from 'express';
 import { JwtAuthGuard } from '../auth/jwt-auth.guard';
 import { CurrentUser } from '../auth/current-user.decorator';
 import { Roles } from '../auth/roles.decorator';
 import { RolesGuard } from '../auth/roles.guard';
+import type { Actor } from '../common/record-scope';
 import { CreateProductDto, ListProductsQueryDto, UpdateProductDto } from './dto';
 import { ProductsService } from './products.service';
+import { ProductsExcelService } from './products-excel.service';
+import { brand } from '@mento/shared';
 
 @Controller('products')
 @UseGuards(JwtAuthGuard, RolesGuard)
 export class ProductsController {
-  constructor(private readonly productsService: ProductsService) {}
+  constructor(
+    private readonly productsService: ProductsService,
+    private readonly excelService: ProductsExcelService,
+  ) {}
 
   @Get()
   list(
@@ -34,6 +47,36 @@ export class ProductsController {
     });
   }
 
+  @Get('export')
+  async export(
+    @CurrentUser() user: Actor,
+    @Query('q') q: string | undefined,
+    @Res({ passthrough: true }) res: Response,
+  ) {
+    const buffer = await this.excelService.export(user.organizationId, q);
+    res.set({
+      'Content-Type':
+        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+      'Content-Disposition': `attachment; filename="${brand.filePrefix}-products.xlsx"`,
+    });
+    return new StreamableFile(buffer);
+  }
+
+  @Post('import')
+  @Roles('owner', 'admin')
+  @UseInterceptors(
+    FileInterceptor('file', {
+      storage: memoryStorage(),
+      limits: { fileSize: 15_000_000 },
+    }),
+  )
+  import(
+    @CurrentUser() user: Actor,
+    @UploadedFile() file: Express.Multer.File,
+  ) {
+    return this.excelService.import(user.organizationId, file);
+  }
+
   @Get(':id')
   getOne(
     @CurrentUser() user: { organizationId: string },

apps/api/src/products/products.module.ts

@@ -3,11 +3,12 @@ import { AuthModule } from '../auth/auth.module';
 import { InventoryModule } from '../inventory/inventory.module';
 import { ProductsController } from './products.controller';
 import { ProductsService } from './products.service';
+import { ProductsExcelService } from './products-excel.service';
 
 @Module({
   imports: [AuthModule, InventoryModule],
   controllers: [ProductsController],
-  providers: [ProductsService],
+  providers: [ProductsService, ProductsExcelService],
   exports: [ProductsService],
 })
 export class ProductsModule {}

apps/api/src/project-boards/dto.ts

@@ -1,5 +1,6 @@
 import { Type } from 'class-transformer';
 import {
+  IsArray,
   IsNumber,
   IsOptional,
   IsString,
@@ -16,6 +17,27 @@ export class CreateProjectBoardDto {
   name!: string;
 }
 
+export class CreateProjectBoardStageDto {
+  @IsString()
+  @MinLength(1)
+  @MaxLength(80)
+  name!: string;
+}
+
+export class UpdateProjectBoardStageDto {
+  @IsOptional()
+  @IsString()
+  @MinLength(1)
+  @MaxLength(80)
+  name?: string;
+}
+
+export class ReorderProjectBoardStagesDto {
+  @IsArray()
+  @IsString({ each: true })
+  stageIds!: string[];
+}
+
 export class CreateProjectCardDto {
   @IsString()
   @MinLength(2)

apps/api/src/project-boards/project-boards.controller.ts

@@ -23,8 +23,11 @@ import { RolesGuard } from '../auth/roles.guard';
 import type { Actor } from '../common/record-scope';
 import {
   CreateProjectBoardDto,
+  CreateProjectBoardStageDto,
   CreateProjectCardDto,
   MoveProjectCardDto,
+  ReorderProjectBoardStagesDto,
+  UpdateProjectBoardStageDto,
   UpdateProjectCardDto,
 } from './dto';
 import { ProjectBoardsService } from './project-boards.service';
@@ -61,6 +64,56 @@ export class ProjectBoardsController {
     return this.boards.create(user.organizationId, dto.name);
   }
 
+  @Post('project-boards/:boardId/stages')
+  @Roles('owner', 'admin')
+  createStage(
+    @CurrentUser() user: Actor,
+    @Param('boardId') boardId: string,
+    @Body() dto: CreateProjectBoardStageDto,
+  ) {
+    return this.boards.createStage(user.organizationId, boardId, dto.name);
+  }
+
+  @Patch('project-boards/:boardId/stages/order')
+  @Roles('owner', 'admin')
+  reorderStages(
+    @CurrentUser() user: Actor,
+    @Param('boardId') boardId: string,
+    @Body() dto: ReorderProjectBoardStagesDto,
+  ) {
+    return this.boards.reorderStages(
+      user.organizationId,
+      boardId,
+      dto.stageIds,
+    );
+  }
+
+  @Patch('project-boards/:boardId/stages/:stageId')
+  @Roles('owner', 'admin')
+  updateStage(
+    @CurrentUser() user: Actor,
+    @Param('boardId') boardId: string,
+    @Param('stageId') stageId: string,
+    @Body() dto: UpdateProjectBoardStageDto,
+  ) {
+    return this.boards.updateStage(
+      user.organizationId,
+      boardId,
+      stageId,
+      dto.name,
+    );
+  }
+
+  @Delete('project-boards/:boardId/stages/:stageId')
+  @Roles('owner', 'admin')
+  deleteStage(
+    @CurrentUser() user: Actor,
+    @Param('boardId') boardId: string,
+    @Param('stageId') stageId: string,
+  ) {
+    return this.boards.deleteStage(user.organizationId, boardId, stageId);
+  }
+
   @Get('project-cards/export')
   async exportCards(
     @CurrentUser() user: Actor,

apps/api/src/project-boards/project-boards.service.ts

@@ -299,6 +299,114 @@ export class ProjectBoardsService {
     await this.prisma.projectCard.delete({ where: { id } });
   }
 
+  async createStage(
+    organizationId: string,
+    boardId: string,
+    name: string,
+  ): Promise<ProjectBoardDto> {
+    const board = await this.getOwnedBoard(organizationId, boardId);
+    const trimmed = name.trim();
+    if (!trimmed) throw new BadRequestException('نام ستون لازم است');
+    await this.prisma.projectBoardStage.create({
+      data: {
+        boardId: board.id,
+        name: trimmed,
+        position: board.stages.length,
+      },
+    });
+    return this.getOwnedBoardDto(organizationId, board.id);
+  }
+
+  async updateStage(
+    organizationId: string,
+    boardId: string,
+    stageId: string,
+    name?: string,
+  ): Promise<ProjectBoardDto> {
+    const board = await this.getOwnedBoard(organizationId, boardId);
+    const stage = board.stages.find((s) => s.id === stageId);
+    if (!stage) throw new NotFoundException('ستون پیدا نشد');
+    const trimmed = name?.trim() ?? '';
+    if (!trimmed) throw new BadRequestException('نام ستون لازم است');
+    await this.prisma.projectBoardStage.update({
+      where: { id: stage.id },
+      data: { name: trimmed },
+    });
+    return this.getOwnedBoardDto(organizationId, board.id);
+  }
+
+  async deleteStage(
+    organizationId: string,
+    boardId: string,
+    stageId: string,
+  ): Promise<ProjectBoardDto> {
+    const board = await this.getOwnedBoard(organizationId, boardId);
+    const stage = board.stages.find((s) => s.id === stageId);
+    if (!stage) throw new NotFoundException('ستون پیدا نشد');
+    if (board.stages.length <= 1) {
+      throw new BadRequestException('حداقل یک ستون باید باقی بماند');
+    }
+    const cardCount = await this.prisma.projectCard.count({
+      where: { organizationId, stageId: stage.id },
+    });
+    if (cardCount > 0) {
+      throw new BadRequestException(
+        'ابتدا کارت‌های این ستون را به ستون دیگری منتقل کنید',
+      );
+    }
+    const remaining = board.stages.filter((s) => s.id !== stage.id);
+    await this.prisma.$transaction([
+      this.prisma.projectBoardStage.delete({ where: { id: stage.id } }),
+      ...remaining.map((s, index) =>
+        this.prisma.projectBoardStage.update({
+          where: { id: s.id },
+          data: { position: index },
+        }),
+      ),
+    ]);
+    return this.getOwnedBoardDto(organizationId, board.id);
+  }
+
+  async reorderStages(
+    organizationId: string,
+    boardId: string,
+    stageIds: string[],
+  ): Promise<ProjectBoardDto> {
+    const board = await this.getOwnedBoard(organizationId, boardId);
+    const currentIds = board.stages.map((s) => s.id);
+    const unique = new Set(stageIds);
+    if (
+      stageIds.length !== currentIds.length ||
+      unique.size !== currentIds.length ||
+      currentIds.some((id) => !unique.has(id))
+    ) {
+      throw new BadRequestException('ترتیب ستون‌ها نامعتبر است');
+    }
+    await this.prisma.$transaction(
+      stageIds.map((id, index) =>
+        this.prisma.projectBoardStage.update({
+          where: { id },
+          data: { position: index },
+        }),
+      ),
+    );
+    return this.getOwnedBoardDto(organizationId, board.id);
+  }
+
+  private async getOwnedBoard(organizationId: string, boardId: string) {
+    const board = await this.prisma.projectBoard.findFirst({
+      where: { id: boardId, organizationId },
+      include: { stages: { orderBy: { position: 'asc' as const } } },
+    });
+    if (!board) throw new NotFoundException('برد پیدا نشد');
+    return board;
+  }
+
+  private async getOwnedBoardDto(organizationId: string, boardId: string) {
+    const board = await this.getOwnedBoard(organizationId, boardId);
+    return this.toBoardDto(board);
+  }
+
   toCardDto(row: {
     id: string;
     title: string;

apps/api/src/project-boards/project-cards-excel.service.ts

@@ -108,6 +108,7 @@ export class ProjectCardsExcelService {
   async import(actor: Actor, file: Express.Multer.File): Promise<ImportContactsResult> {
     const rows = await readMappedRows(file, CASE_ALIASES);
     const result: ImportContactsResult = { created: 0, skipped: 0, errors: [] };
+    const affected = new Map<string, string>();
 
     for (let i = 0; i < rows.length; i++) {
       const row = rows[i]!;
@@ -122,12 +123,13 @@ export class ProjectCardsExcelService {
       }
 
       try {
-        const { boardId, stageId } = await this.resolveBoardAndStage(
+        const { boardId, stageId, boardName } = await this.resolveBoardAndStage(
           actor.organizationId,
           row.boardName,
           row.stageName,
           isClosedStatus(row.status),
         );
+        affected.set(boardId, boardName);
         const duplicate = await this.prisma.projectCard.findFirst({
           where: { organizationId: actor.organizationId, boardId, title },
           select: { id: true },
@@ -165,6 +167,12 @@ export class ProjectCardsExcelService {
       }
     }
 
+    const entries = [...affected.entries()];
+    if (entries[0]) {
+      result.boardId = entries[0][0];
+      result.boards = entries.map(([, n]) => n);
+    }
+
     return result;
   }
 
@@ -204,19 +212,19 @@ export class ProjectCardsExcelService {
       const existing = board.stages.find(
         (s) => s.name.trim().toLowerCase() === wanted.toLowerCase(),
       );
-      if (existing) return { boardId: board.id, stageId: existing.id };
+      if (existing) return { boardId: board.id, stageId: existing.id, boardName: board.name };
       const maxPos = board.stages.reduce((m, s) => Math.max(m, s.position), -1);
       const stage = await this.prisma.projectBoardStage.create({
         data: { boardId: board.id, name: wanted, position: maxPos + 1 },
       });
-      return { boardId: board.id, stageId: stage.id };
+      return { boardId: board.id, stageId: stage.id, boardName: board.name };
     }
 
     const stage = closed
       ? board.stages[board.stages.length - 1]
       : board.stages[0];
     if (!stage) throw new Error('برد مرحله‌ای ندارد');
-    return { boardId: board.id, stageId: stage.id };
+    return { boardId: board.id, stageId: stage.id, boardName: board.name };
   }
 
   private async findPersonId(organizationId: string, row: Record<string, string>) {