mohmdsdgandCursor
9f0422c1db
Provide backend for admin and user apps with Postgres, migrations, seed data, and docker-compose for LiteSpeed reverse-proxy deployment. Co-authored-by: Cursor <cursoragent@cursor.com>
644 lines
20 KiB
TypeScript
644 lines
20 KiB
TypeScript
import {
|
|
BadRequestException,
|
|
ForbiddenException,
|
|
Injectable,
|
|
NotFoundException,
|
|
} from '@nestjs/common';
|
|
import {
|
|
CheckRegistrationMode,
|
|
OrderStatus,
|
|
Prisma,
|
|
SettlementType,
|
|
} from '@prisma/client';
|
|
import { PrismaService } from '../prisma/prisma.service';
|
|
import {
|
|
AdminCreateOrderDto,
|
|
SubmitOrderCheckDto,
|
|
SubmitOrderDto,
|
|
UpdateOrderChecksDto,
|
|
UpdateOrderPricingDto,
|
|
UpdateOrderStatusDto,
|
|
} from './dto/order.dto';
|
|
import { generateOrderNumber } from '../common/utils/order-number';
|
|
import { calculateCheckRass } from '../common/utils/check-rass';
|
|
import { computeCashInvoiceExpiry } from '../common/utils/cash-expiry';
|
|
import {
|
|
resolveAdminStatusFilter,
|
|
toAdminStatus,
|
|
} from '../common/utils/order-status';
|
|
import { joinFullName, splitFullName } from '../common/utils/name';
|
|
import {
|
|
isValidPhone,
|
|
normalizePhone,
|
|
toEnglishDigits,
|
|
} from '../common/utils/phone';
|
|
|
|
const orderInclude = {
|
|
items: true,
|
|
checks: { orderBy: { row: 'asc' as const } },
|
|
cashReceipt: true,
|
|
statusHistory: { orderBy: { changedAt: 'asc' as const } },
|
|
shipment: true,
|
|
user: true,
|
|
company: true,
|
|
} satisfies Prisma.OrderInclude;
|
|
|
|
type OrderFull = Prisma.OrderGetPayload<{ include: typeof orderInclude }>;
|
|
|
|
@Injectable()
|
|
export class OrdersService {
|
|
constructor(private readonly prisma: PrismaService) {}
|
|
|
|
async findMyOrders(userId: string) {
|
|
const orders = await this.prisma.order.findMany({
|
|
where: { userId },
|
|
orderBy: { createdAt: 'desc' },
|
|
include: orderInclude,
|
|
});
|
|
return orders.map((o) => this.mapOrder(o));
|
|
}
|
|
|
|
async findMyOrder(userId: string, id: string) {
|
|
const order = await this.getOrder(id);
|
|
if (order.userId !== userId) {
|
|
throw new ForbiddenException('دسترسی به این سفارش مجاز نیست');
|
|
}
|
|
return this.mapOrder(order);
|
|
}
|
|
|
|
async findAdminOrders(filters: { status?: string; q?: string }) {
|
|
const statuses = resolveAdminStatusFilter(filters.status);
|
|
const q = filters.q?.trim();
|
|
const orders = await this.prisma.order.findMany({
|
|
where: {
|
|
...(statuses ? { status: { in: statuses } } : {}),
|
|
...(q
|
|
? {
|
|
OR: [
|
|
{ orderNumber: { contains: q, mode: 'insensitive' } },
|
|
{ companyName: { contains: q, mode: 'insensitive' } },
|
|
{
|
|
user: {
|
|
OR: [
|
|
{ firstName: { contains: q, mode: 'insensitive' } },
|
|
{ lastName: { contains: q, mode: 'insensitive' } },
|
|
{ phone: { contains: toEnglishDigits(q) } },
|
|
],
|
|
},
|
|
},
|
|
],
|
|
}
|
|
: {}),
|
|
},
|
|
orderBy: { createdAt: 'desc' },
|
|
include: orderInclude,
|
|
});
|
|
return orders.map((o) => this.mapOrder(o, true));
|
|
}
|
|
|
|
async findAdminOrder(id: string) {
|
|
const order = await this.getOrder(id);
|
|
return this.mapOrder(order, true);
|
|
}
|
|
|
|
async submitOrder(userId: string, dto: SubmitOrderDto) {
|
|
const company = await this.prisma.company.findUnique({
|
|
where: { id: dto.companyId },
|
|
});
|
|
if (!company || !company.isActive) {
|
|
throw new NotFoundException('شرکت یافت نشد یا غیرفعال است');
|
|
}
|
|
|
|
const productIds = dto.items.map((i) => i.productId);
|
|
const products = await this.prisma.product.findMany({
|
|
where: { id: { in: productIds }, companyId: company.id, isActive: true },
|
|
include: { catalog: true },
|
|
});
|
|
if (products.length !== productIds.length) {
|
|
throw new BadRequestException('یک یا چند محصول نامعتبر است');
|
|
}
|
|
const productMap = new Map(products.map((p) => [p.id, p]));
|
|
|
|
let totalMeterage = 0;
|
|
const itemsData = dto.items.map((item) => {
|
|
const product = productMap.get(item.productId)!;
|
|
if (item.meterage < product.minMeterage) {
|
|
throw new BadRequestException(
|
|
`حداقل متراژ برای ${product.name} برابر ${product.minMeterage} است`,
|
|
);
|
|
}
|
|
const rem =
|
|
Math.round((item.meterage / product.orderMultiplier) * 1000) / 1000;
|
|
if (Math.abs(rem - Math.round(rem)) > 1e-6) {
|
|
throw new BadRequestException(
|
|
`متراژ ${product.name} باید مضرب ${product.orderMultiplier} باشد`,
|
|
);
|
|
}
|
|
totalMeterage += item.meterage;
|
|
return {
|
|
productId: product.id,
|
|
catalogCode: product.catalog.code,
|
|
productName: product.name,
|
|
productCode: product.code,
|
|
color: product.color,
|
|
requestedMeterage: item.meterage,
|
|
unitPrice: product.basePrice,
|
|
notes: item.notes?.trim() || null,
|
|
};
|
|
});
|
|
|
|
if (totalMeterage > company.maxMeteragePerInvoice) {
|
|
throw new BadRequestException(
|
|
`حداکثر متراژ مجاز هر فاکتور ${company.maxMeteragePerInvoice} متر است`,
|
|
);
|
|
}
|
|
|
|
const settlementType = dto.settlementType;
|
|
if (settlementType === SettlementType.check) {
|
|
if (!dto.checks?.length) {
|
|
throw new BadRequestException('برای تسویه چکی حداقل یک چک لازم است');
|
|
}
|
|
}
|
|
|
|
const checkMode =
|
|
settlementType === SettlementType.check
|
|
? (dto.checkMode ?? CheckRegistrationMode.full)
|
|
: null;
|
|
|
|
const rass =
|
|
settlementType === SettlementType.check && dto.checks?.length
|
|
? calculateCheckRass(
|
|
dto.checks.map((c) => ({
|
|
amount: c.amount,
|
|
dueDate: c.dueDate,
|
|
})),
|
|
)
|
|
: null;
|
|
|
|
const cashInvoiceExpiresAt =
|
|
settlementType === SettlementType.cash
|
|
? computeCashInvoiceExpiry(company)
|
|
: null;
|
|
|
|
const orderNumber = await this.nextOrderNumber();
|
|
|
|
const order = await this.prisma.$transaction(async (tx) => {
|
|
const created = await tx.order.create({
|
|
data: {
|
|
orderNumber,
|
|
userId,
|
|
companyId: company.id,
|
|
companyName: company.name,
|
|
settlementType,
|
|
checkMode,
|
|
status: OrderStatus.awaiting_review,
|
|
totalMeterage,
|
|
notes: dto.notes?.trim() || null,
|
|
checkRassDays: rass?.rassDays ?? null,
|
|
checkRassDate: rass?.rassDate ? new Date(rass.rassDate) : null,
|
|
cashInvoiceExpiresAt,
|
|
items: { create: itemsData },
|
|
checks:
|
|
settlementType === SettlementType.check && dto.checks
|
|
? {
|
|
create: dto.checks.map((c, index) =>
|
|
this.mapCheckCreate(c, index + 1, checkMode!),
|
|
),
|
|
}
|
|
: undefined,
|
|
statusHistory: {
|
|
create: [
|
|
{
|
|
fromStatus: null,
|
|
toStatus: OrderStatus.submitted,
|
|
changedBy: 'customer',
|
|
note: 'سفارش ثبت شد',
|
|
},
|
|
{
|
|
fromStatus: OrderStatus.submitted,
|
|
toStatus: OrderStatus.awaiting_review,
|
|
changedBy: 'customer',
|
|
note: 'ارسال برای بررسی مدیریت',
|
|
},
|
|
],
|
|
},
|
|
},
|
|
include: orderInclude,
|
|
});
|
|
|
|
// Clear cart items for this company after successful submit
|
|
const cart = await tx.cart.findFirst({ where: { userId } });
|
|
if (cart) {
|
|
await tx.cartItem.deleteMany({
|
|
where: { cartId: cart.id, companyId: company.id },
|
|
});
|
|
}
|
|
|
|
return created;
|
|
});
|
|
|
|
return this.mapOrder(order);
|
|
}
|
|
|
|
async adminCreate(adminId: string, dto: AdminCreateOrderDto) {
|
|
const settlementType = dto.settlementType ?? dto.settlementMethod;
|
|
if (!settlementType) {
|
|
throw new BadRequestException('نوع تسویه الزامی است');
|
|
}
|
|
|
|
const company = await this.prisma.company.findUnique({
|
|
where: { id: dto.companyId },
|
|
});
|
|
if (!company) throw new NotFoundException('شرکت یافت نشد');
|
|
|
|
let userId = dto.userId;
|
|
if (!userId && dto.customerPhone) {
|
|
const phone = normalizePhone(toEnglishDigits(dto.customerPhone));
|
|
if (!isValidPhone(phone)) {
|
|
throw new BadRequestException('شماره موبایل نامعتبر است');
|
|
}
|
|
let customer = await this.prisma.customer.findUnique({ where: { phone } });
|
|
if (!customer) {
|
|
const names = splitFullName(dto.customerName || 'مشتری جدید');
|
|
customer = await this.prisma.customer.create({
|
|
data: {
|
|
phone,
|
|
firstName: names.firstName,
|
|
lastName: names.lastName || 'جدید',
|
|
},
|
|
});
|
|
}
|
|
userId = customer.id;
|
|
}
|
|
if (!userId) {
|
|
throw new BadRequestException('شناسه یا شماره مشتری الزامی است');
|
|
}
|
|
|
|
const orderNumber = await this.nextOrderNumber();
|
|
const totalMeterage = dto.meterage ?? 0;
|
|
|
|
const order = await this.prisma.order.create({
|
|
data: {
|
|
orderNumber,
|
|
userId,
|
|
companyId: company.id,
|
|
companyName: company.name,
|
|
settlementType,
|
|
status: OrderStatus.awaiting_review,
|
|
totalMeterage,
|
|
notes: dto.notes?.trim() || null,
|
|
statusHistory: {
|
|
create: {
|
|
fromStatus: null,
|
|
toStatus: OrderStatus.awaiting_review,
|
|
changedBy: `admin:${adminId}`,
|
|
note: 'سفارش توسط ادمین ثبت شد',
|
|
},
|
|
},
|
|
},
|
|
include: orderInclude,
|
|
});
|
|
|
|
return this.mapOrder(order, true);
|
|
}
|
|
|
|
async updatePricing(
|
|
id: string,
|
|
adminId: string,
|
|
dto: UpdateOrderPricingDto,
|
|
) {
|
|
const order = await this.getOrder(id);
|
|
|
|
await this.prisma.$transaction(async (tx) => {
|
|
let totalAmount = 0;
|
|
let totalMeterage = 0;
|
|
|
|
for (const item of dto.items) {
|
|
const existing = order.items.find((i) => i.id === item.id);
|
|
if (!existing) {
|
|
throw new BadRequestException(`آیتم ${item.id} یافت نشد`);
|
|
}
|
|
const unitPrice =
|
|
item.unitPrice !== undefined
|
|
? item.unitPrice
|
|
: item.supplyPrice !== undefined
|
|
? item.supplyPrice
|
|
: (existing.unitPrice ?? 0);
|
|
const unitDiscount = item.unitDiscount ?? existing.unitDiscount ?? 0;
|
|
const confirmed =
|
|
item.confirmedMeterage ??
|
|
existing.confirmedMeterage ??
|
|
existing.requestedMeterage;
|
|
const lineTotal = Math.max(0, (unitPrice - unitDiscount) * confirmed);
|
|
totalAmount += lineTotal;
|
|
totalMeterage += confirmed;
|
|
|
|
await tx.orderItem.update({
|
|
where: { id: item.id },
|
|
data: {
|
|
confirmedMeterage: confirmed,
|
|
unitPrice,
|
|
unitDiscount,
|
|
lineTotal,
|
|
},
|
|
});
|
|
}
|
|
|
|
const shippingCost = dto.shippingCost ?? order.shippingCost ?? 0;
|
|
const totalDiscount = dto.totalDiscount ?? order.totalDiscount ?? 0;
|
|
const finalAmount = Math.max(0, totalAmount + shippingCost - totalDiscount);
|
|
|
|
const nextStatus =
|
|
order.status === OrderStatus.awaiting_review ||
|
|
order.status === OrderStatus.pricing
|
|
? OrderStatus.pricing
|
|
: order.status;
|
|
|
|
await tx.order.update({
|
|
where: { id },
|
|
data: {
|
|
totalAmount,
|
|
totalMeterage,
|
|
shippingCost,
|
|
totalDiscount,
|
|
finalAmount,
|
|
status: nextStatus,
|
|
},
|
|
});
|
|
|
|
if (nextStatus !== order.status) {
|
|
await tx.orderStatusHistory.create({
|
|
data: {
|
|
orderId: id,
|
|
fromStatus: order.status,
|
|
toStatus: nextStatus,
|
|
changedBy: `admin:${adminId}`,
|
|
note: dto.note || 'قیمتگذاری انجام شد',
|
|
},
|
|
});
|
|
}
|
|
});
|
|
|
|
return this.findAdminOrder(id);
|
|
}
|
|
|
|
async updateStatus(
|
|
id: string,
|
|
adminId: string,
|
|
dto: UpdateOrderStatusDto,
|
|
) {
|
|
const order = await this.getOrder(id);
|
|
if (order.status === dto.status) {
|
|
return this.mapOrder(order, true);
|
|
}
|
|
|
|
await this.prisma.$transaction(async (tx) => {
|
|
await tx.order.update({
|
|
where: { id },
|
|
data: { status: dto.status },
|
|
});
|
|
await tx.orderStatusHistory.create({
|
|
data: {
|
|
orderId: id,
|
|
fromStatus: order.status,
|
|
toStatus: dto.status,
|
|
changedBy: `admin:${adminId}`,
|
|
note: dto.note || null,
|
|
reason: dto.reason || null,
|
|
},
|
|
});
|
|
|
|
// Side effects for common transitions
|
|
if (
|
|
dto.status === OrderStatus.cash_invoice_issued ||
|
|
dto.status === OrderStatus.awaiting_cash_payment
|
|
) {
|
|
if (!order.cashInvoiceExpiresAt) {
|
|
await tx.order.update({
|
|
where: { id },
|
|
data: {
|
|
cashInvoiceExpiresAt: computeCashInvoiceExpiry(order.company),
|
|
},
|
|
});
|
|
}
|
|
}
|
|
});
|
|
|
|
return this.findAdminOrder(id);
|
|
}
|
|
|
|
async updateChecks(userId: string, id: string, dto: UpdateOrderChecksDto) {
|
|
const order = await this.getOrder(id);
|
|
if (order.userId !== userId) {
|
|
throw new ForbiddenException('دسترسی به این سفارش مجاز نیست');
|
|
}
|
|
if (order.settlementType !== SettlementType.check) {
|
|
throw new BadRequestException('این سفارش تسویه چکی نیست');
|
|
}
|
|
|
|
const checkMode = dto.checkMode ?? order.checkMode ?? CheckRegistrationMode.full;
|
|
const rass = calculateCheckRass(
|
|
dto.checks.map((c) => ({ amount: c.amount, dueDate: c.dueDate })),
|
|
order.createdAt,
|
|
);
|
|
|
|
await this.prisma.$transaction(async (tx) => {
|
|
await tx.check.deleteMany({ where: { orderId: id } });
|
|
await tx.check.createMany({
|
|
data: dto.checks.map((c, index) => ({
|
|
orderId: id,
|
|
...this.mapCheckCreate(c, index + 1, checkMode),
|
|
})),
|
|
});
|
|
await tx.order.update({
|
|
where: { id },
|
|
data: {
|
|
checkMode,
|
|
checkRassDays: rass.rassDays,
|
|
checkRassDate: rass.rassDate ? new Date(rass.rassDate) : null,
|
|
status:
|
|
order.status === OrderStatus.check_needs_fix
|
|
? OrderStatus.awaiting_check_review
|
|
: order.status,
|
|
},
|
|
});
|
|
if (order.status === OrderStatus.check_needs_fix) {
|
|
await tx.orderStatusHistory.create({
|
|
data: {
|
|
orderId: id,
|
|
fromStatus: order.status,
|
|
toStatus: OrderStatus.awaiting_check_review,
|
|
changedBy: 'customer',
|
|
note: 'چکها اصلاح و مجدداً ارسال شد',
|
|
},
|
|
});
|
|
}
|
|
});
|
|
|
|
return this.findMyOrder(userId, id);
|
|
}
|
|
|
|
private mapCheckCreate(
|
|
c: SubmitOrderCheckDto,
|
|
row: number,
|
|
defaultMode: CheckRegistrationMode,
|
|
) {
|
|
return {
|
|
row,
|
|
amount: c.amount,
|
|
dueDate: new Date(c.dueDate),
|
|
sayadId: c.sayadId?.trim() || null,
|
|
checkNumber: c.checkNumber?.trim() || null,
|
|
ownerNationalId: c.ownerNationalId?.trim() || null,
|
|
ownerFirstName: c.ownerFirstName?.trim() || null,
|
|
ownerLastName: c.ownerLastName?.trim() || null,
|
|
bankName: c.bankName?.trim() || null,
|
|
branchName: c.branchName?.trim() || null,
|
|
frontImage: c.frontImage || null,
|
|
backImage: c.backImage || null,
|
|
notes: c.notes?.trim() || null,
|
|
mode: c.mode ?? defaultMode,
|
|
};
|
|
}
|
|
|
|
private async nextOrderNumber(): Promise<string> {
|
|
for (let i = 0; i < 5; i++) {
|
|
const orderNumber = generateOrderNumber();
|
|
const exists = await this.prisma.order.findUnique({
|
|
where: { orderNumber },
|
|
});
|
|
if (!exists) return orderNumber;
|
|
}
|
|
return `${generateOrderNumber()}-${Date.now().toString().slice(-3)}`;
|
|
}
|
|
|
|
private async getOrder(id: string): Promise<OrderFull> {
|
|
const order = await this.prisma.order.findUnique({
|
|
where: { id },
|
|
include: orderInclude,
|
|
});
|
|
if (!order) throw new NotFoundException('سفارش یافت نشد');
|
|
return order;
|
|
}
|
|
|
|
mapOrder(order: OrderFull, adminView = false) {
|
|
const customerName = joinFullName(
|
|
order.user.firstName,
|
|
order.user.lastName,
|
|
);
|
|
const base = {
|
|
id: order.id,
|
|
orderNumber: order.orderNumber,
|
|
userId: order.userId,
|
|
companyId: order.companyId,
|
|
companyName: order.companyName,
|
|
settlementType: order.settlementType,
|
|
settlementMethod: order.settlementType,
|
|
checkMode: order.checkMode ?? undefined,
|
|
status: order.status,
|
|
adminStatus: toAdminStatus(order.status),
|
|
totalMeterage: order.totalMeterage,
|
|
meterage: order.totalMeterage,
|
|
totalAmount: order.totalAmount,
|
|
shippingCost: order.shippingCost,
|
|
totalDiscount: order.totalDiscount,
|
|
finalAmount: order.finalAmount,
|
|
notes: order.notes ?? undefined,
|
|
checkRassDays: order.checkRassDays ?? undefined,
|
|
checkRassDate: order.checkRassDate?.toISOString(),
|
|
cashInvoiceExpiresAt: order.cashInvoiceExpiresAt?.toISOString(),
|
|
createdAt: order.createdAt.toISOString(),
|
|
updatedAt: order.updatedAt.toISOString(),
|
|
customerName,
|
|
customerPhone: order.user.phone,
|
|
customerNationalId: order.user.nationalId ?? undefined,
|
|
customerType: order.user.customerType,
|
|
items: order.items.map((item) => ({
|
|
id: item.id,
|
|
productId: item.productId ?? undefined,
|
|
catalogCode: item.catalogCode,
|
|
productName: item.productName,
|
|
productCode: item.productCode ?? undefined,
|
|
color: item.color,
|
|
requestedMeterage: item.requestedMeterage,
|
|
confirmedMeterage: item.confirmedMeterage,
|
|
unitPrice: item.unitPrice,
|
|
supplyPrice: item.unitPrice,
|
|
unitDiscount: item.unitDiscount ?? 0,
|
|
discount: item.unitDiscount ?? 0,
|
|
lineTotal: item.lineTotal,
|
|
totalAmount: item.lineTotal,
|
|
notes: item.notes ?? undefined,
|
|
})),
|
|
checks: order.checks.map((c) => ({
|
|
id: c.id,
|
|
orderId: c.orderId,
|
|
row: c.row,
|
|
amount: c.amount,
|
|
dueDate: c.dueDate.toISOString(),
|
|
sayadId: c.sayadId ?? undefined,
|
|
checkNumber: c.checkNumber ?? undefined,
|
|
ownerNationalId: c.ownerNationalId ?? undefined,
|
|
ownerFirstName: c.ownerFirstName ?? undefined,
|
|
ownerLastName: c.ownerLastName ?? undefined,
|
|
bankName: c.bankName ?? '',
|
|
branchName: c.branchName ?? undefined,
|
|
frontImage: c.frontImage ?? undefined,
|
|
backImage: c.backImage ?? undefined,
|
|
notes: c.notes ?? undefined,
|
|
mode: c.mode,
|
|
status: c.status,
|
|
createdAt: c.createdAt.toISOString(),
|
|
updatedAt: c.updatedAt.toISOString(),
|
|
})),
|
|
cashReceipt: order.cashReceipt
|
|
? {
|
|
id: order.cashReceipt.id,
|
|
amount: order.cashReceipt.amount,
|
|
paidAmount: order.cashReceipt.paidAmount,
|
|
transferDate: order.cashReceipt.transferDate?.toISOString() ?? null,
|
|
transferTime: order.cashReceipt.transferTime ?? undefined,
|
|
trackingNumber: order.cashReceipt.trackingNumber ?? undefined,
|
|
trackingCode: order.cashReceipt.trackingNumber ?? undefined,
|
|
destinationAccountId:
|
|
order.cashReceipt.destinationAccountId ?? undefined,
|
|
receiptImage: order.cashReceipt.receiptImage ?? undefined,
|
|
notes: order.cashReceipt.notes ?? undefined,
|
|
expiresAt:
|
|
order.cashReceipt.expiresAt?.toISOString() ??
|
|
order.cashInvoiceExpiresAt?.toISOString(),
|
|
status: order.cashReceipt.status,
|
|
submittedAt: order.cashReceipt.submittedAt?.toISOString(),
|
|
createdAt: order.cashReceipt.createdAt.toISOString(),
|
|
}
|
|
: undefined,
|
|
shipment: order.shipment
|
|
? {
|
|
id: order.shipment.id,
|
|
orderId: order.shipment.orderId,
|
|
carrier: order.shipment.carrier,
|
|
trackingNumber: order.shipment.trackingNumber ?? '',
|
|
meterage: order.shipment.meterage,
|
|
status: order.shipment.status,
|
|
shippedAt: order.shipment.shippedAt?.toISOString() ?? null,
|
|
deliveredAt: order.shipment.deliveredAt?.toISOString() ?? null,
|
|
}
|
|
: undefined,
|
|
statusHistory: order.statusHistory.map((h) => ({
|
|
id: h.id,
|
|
fromStatus: h.fromStatus,
|
|
toStatus: h.toStatus,
|
|
changedBy: h.changedBy,
|
|
note: h.note ?? undefined,
|
|
reason: h.reason ?? undefined,
|
|
changedAt: h.changedAt.toISOString(),
|
|
})),
|
|
};
|
|
|
|
if (adminView) {
|
|
return base;
|
|
}
|
|
return base;
|
|
}
|
|
}
|