2043 lines
65 KiB
TypeScript
2043 lines
65 KiB
TypeScript
import {
|
|
Injectable,
|
|
HttpException,
|
|
NotFoundException,
|
|
BadRequestException,
|
|
Optional,
|
|
} from "@nestjs/common";
|
|
import { Prisma } from "@prisma/client";
|
|
import { PrismaService } from "../prisma/prisma.service";
|
|
import { RedisService } from "../redis/redis.service";
|
|
import { SmsService } from "../common/services/sms.service";
|
|
import * as bcrypt from "bcryptjs";
|
|
import { CreateUserDto, UpdateUserDto } from "./dto/user.dto";
|
|
import { ProductDto } from "./dto/product.dto";
|
|
import {
|
|
UpdatePricingSettingsDto,
|
|
ApplyGlobalMarginsDto,
|
|
BulkPriceAdjustmentDto,
|
|
} from "./dto/pricing.dto";
|
|
import {
|
|
DEFAULT_PRICING_SETTINGS,
|
|
PricingSettings,
|
|
applyRounding,
|
|
calculateSellingPrice,
|
|
RoundingMode,
|
|
} from "../common/utils/pricing.utils";
|
|
import { normalizeMobile } from "../common/utils/phone.utils";
|
|
import { CANONICAL_ALIASES } from "../settings/settings.service";
|
|
import { RevalidationService } from "../common/revalidation/revalidation.service";
|
|
|
|
export class PaginationQuery {
|
|
page?: number | string;
|
|
limit?: number | string;
|
|
search?: string;
|
|
role?: string;
|
|
categoryId?: string;
|
|
status?: string;
|
|
sortBy?: string;
|
|
sortOrder?: "asc" | "desc";
|
|
suitableFor?: string;
|
|
minPrice?: number | string;
|
|
maxPrice?: number | string;
|
|
}
|
|
|
|
export class CouponTargetInput {
|
|
targetType!: string;
|
|
targetId!: string;
|
|
modifierType?: string;
|
|
modifierValue?: number;
|
|
}
|
|
|
|
export class CouponInput {
|
|
code!: string;
|
|
type?: string;
|
|
value!: number;
|
|
minCartValue?: number;
|
|
maxCartValue?: number;
|
|
maxUses?: number;
|
|
expiresAt?: string | Date;
|
|
isActive?: boolean;
|
|
targets?: CouponTargetInput[];
|
|
}
|
|
|
|
import { ALLOWED_USER_ROLES, assertUserMutationAllowed } from "./user-role-policy";
|
|
import type { UserAdminActor } from "./user-role-policy";
|
|
|
|
@Injectable()
|
|
export class AdminService {
|
|
constructor(
|
|
private prisma: PrismaService,
|
|
private redisService: RedisService,
|
|
private revalidationService: RevalidationService,
|
|
@Optional() private smsService?: SmsService,
|
|
) {}
|
|
|
|
async getDashboardStats() {
|
|
const orders = await this.prisma.order.findMany({
|
|
where: { status: { not: "failed" } },
|
|
select: { totalAmount: true },
|
|
});
|
|
|
|
const revenue = orders.reduce((sum, o) => sum + Number(o.totalAmount), 0);
|
|
|
|
const newOrders = await this.prisma.order.count({
|
|
where: { status: "processing" },
|
|
});
|
|
|
|
const users = await this.prisma.user.count();
|
|
|
|
const todayKey = `visits:${new Date().toISOString().split("T")[0]}`;
|
|
let todayVisits = 0;
|
|
try {
|
|
const count = await this.redisService.get(todayKey);
|
|
todayVisits = count ? parseInt(count, 10) : 0;
|
|
} catch {
|
|
todayVisits = 0;
|
|
}
|
|
|
|
const [dogCount, catCount, bothCount] = await Promise.all([
|
|
this.prisma.product.count({ where: { suitableFor: "سگ" } }),
|
|
this.prisma.product.count({ where: { suitableFor: "گربه" } }),
|
|
this.prisma.product.count({
|
|
where: { suitableFor: { contains: "هر دو" } },
|
|
}),
|
|
]);
|
|
|
|
return {
|
|
revenue,
|
|
newOrders,
|
|
users,
|
|
todayVisits,
|
|
categoriesDistribution: [
|
|
{ name: "مکمل سگ", value: dogCount || 8 },
|
|
{ name: "مکمل گربه", value: catCount || 6 },
|
|
{ name: "هر دو (سگ و گربه)", value: bothCount || 12 },
|
|
],
|
|
};
|
|
}
|
|
|
|
async getUsers(query: PaginationQuery = {}) {
|
|
const page = Number(query.page) || 1;
|
|
const limit = Number(query.limit) || 10;
|
|
const skip = (page - 1) * limit;
|
|
|
|
const where: Prisma.UserWhereInput = {};
|
|
if (query.search) {
|
|
where.OR = [
|
|
{ firstName: { contains: query.search, mode: "insensitive" } },
|
|
{ lastName: { contains: query.search, mode: "insensitive" } },
|
|
{ email: { contains: query.search, mode: "insensitive" } },
|
|
{ mobile: { contains: query.search } },
|
|
];
|
|
}
|
|
if (query.role) {
|
|
if (query.role === "B2B") {
|
|
where.role = { contains: "B2B" };
|
|
} else {
|
|
where.role = query.role;
|
|
}
|
|
}
|
|
|
|
const sortField =
|
|
query.sortBy &&
|
|
typeof query.sortBy === "string" &&
|
|
[
|
|
"createdAt",
|
|
"firstName",
|
|
"lastName",
|
|
"mobile",
|
|
"email",
|
|
"role",
|
|
"walletBalance",
|
|
].includes(query.sortBy)
|
|
? query.sortBy
|
|
: "createdAt";
|
|
const sortDirection = query.sortOrder === "asc" ? "asc" : "desc";
|
|
|
|
const [data, total] = await Promise.all([
|
|
this.prisma.user.findMany({
|
|
where,
|
|
skip,
|
|
take: limit,
|
|
orderBy: { [sortField]: sortDirection },
|
|
select: {
|
|
id: true,
|
|
firstName: true,
|
|
lastName: true,
|
|
mobile: true,
|
|
email: true,
|
|
role: true,
|
|
walletBalance: true,
|
|
charityDonationTotal: true,
|
|
createdAt: true,
|
|
addresses: true,
|
|
orders: {
|
|
where: { status: { not: "CANCELLED" } },
|
|
select: { totalAmount: true },
|
|
},
|
|
_count: {
|
|
select: {
|
|
orders: true,
|
|
reviews: true,
|
|
blogComments: true,
|
|
pets: true,
|
|
},
|
|
},
|
|
},
|
|
}),
|
|
this.prisma.user.count({ where }),
|
|
]);
|
|
|
|
const enrichedUsers = data.map((u) => {
|
|
const totalSpent =
|
|
u.orders?.reduce(
|
|
(acc, curr) => acc + (Number(curr.totalAmount) || 0),
|
|
0,
|
|
) || 0;
|
|
// Explicit response allowlist: never expose authentication fields or
|
|
// new model columns implicitly through this administrative list.
|
|
return {
|
|
id: u.id,
|
|
firstName: u.firstName,
|
|
lastName: u.lastName,
|
|
mobile: u.mobile,
|
|
email: u.email,
|
|
role: u.role,
|
|
walletBalance: u.walletBalance,
|
|
charityDonationTotal: u.charityDonationTotal,
|
|
createdAt: u.createdAt,
|
|
addresses: u.addresses,
|
|
totalSpent,
|
|
ordersCount: u._count?.orders || 0,
|
|
reviewsCount: (u._count?.reviews || 0) + (u._count?.blogComments || 0),
|
|
petsCount: u._count?.pets || 0,
|
|
};
|
|
});
|
|
|
|
return {
|
|
data: enrichedUsers,
|
|
meta: { total, page, limit, lastPage: Math.ceil(total / limit) || 1 },
|
|
};
|
|
}
|
|
|
|
async getUserDetails(id: string) {
|
|
const user = await this.prisma.user.findUnique({
|
|
where: { id },
|
|
include: {
|
|
addresses: true,
|
|
pets: true,
|
|
orders: { orderBy: { createdAt: "desc" }, take: 10 },
|
|
walletTransactions: { orderBy: { createdAt: "desc" }, take: 20 },
|
|
},
|
|
});
|
|
if (!user) throw new NotFoundException(`کاربری با شناسه ${id} یافت نشد.`);
|
|
return user;
|
|
}
|
|
|
|
async createUser(dto: CreateUserDto, actor?: UserAdminActor) {
|
|
assertUserMutationAllowed(actor, undefined, dto.role);
|
|
const mobile = normalizeMobile(dto.mobile);
|
|
const existingMobile = await this.prisma.user.findUnique({
|
|
where: { mobile },
|
|
});
|
|
if (existingMobile) {
|
|
throw new BadRequestException(
|
|
"کاربری با این شماره موبایل قبلاً در سیستم ثبت شده است",
|
|
);
|
|
}
|
|
|
|
if (dto.email) {
|
|
const existingEmail = await this.prisma.user.findUnique({
|
|
where: { email: dto.email.trim().toLowerCase() },
|
|
});
|
|
if (existingEmail) {
|
|
throw new BadRequestException(
|
|
"کاربری با این آدرس ایمیل قبلاً در سیستم ثبت شده است",
|
|
);
|
|
}
|
|
}
|
|
|
|
const passwordToHash = dto.password?.trim();
|
|
const hashedPassword = passwordToHash
|
|
? await bcrypt.hash(passwordToHash, 10)
|
|
: "";
|
|
|
|
if (dto.role && !ALLOWED_USER_ROLES.includes(dto.role)) {
|
|
throw new BadRequestException("نقش کاربری مشخص شده نامعتبر است");
|
|
}
|
|
|
|
return this.prisma.user.create({
|
|
data: {
|
|
firstName: dto.firstName.trim(),
|
|
lastName: dto.lastName.trim(),
|
|
mobile,
|
|
email: dto.email ? dto.email.trim().toLowerCase() : null,
|
|
password: hashedPassword,
|
|
role: dto.role || "User_PetOwner",
|
|
walletBalance:
|
|
dto.walletBalance !== undefined
|
|
? new Prisma.Decimal(dto.walletBalance)
|
|
: new Prisma.Decimal(0),
|
|
},
|
|
});
|
|
}
|
|
|
|
async updateUser(id: string, dto: UpdateUserDto, actor?: UserAdminActor) {
|
|
if (id === "12345678-1234-1234-1234-123456789012") {
|
|
throw new BadRequestException(
|
|
"امکان ویرایش حساب ادمین پیشفرض وجود ندارد",
|
|
);
|
|
}
|
|
|
|
const user = await this.prisma.user.findUnique({ where: { id } });
|
|
if (!user) {
|
|
throw new NotFoundException(`کاربری با شناسه ${id} یافت نشد`);
|
|
}
|
|
|
|
assertUserMutationAllowed(actor, user.role, dto.role);
|
|
|
|
const normalizedMobile = dto.mobile
|
|
? normalizeMobile(dto.mobile)
|
|
: undefined;
|
|
if (normalizedMobile && normalizedMobile !== user.mobile) {
|
|
const existingMobile = await this.prisma.user.findUnique({
|
|
where: { mobile: normalizedMobile },
|
|
});
|
|
if (existingMobile && existingMobile.id !== id) {
|
|
throw new BadRequestException(
|
|
"این شماره موبایل متعلق به کاربر دیگری است",
|
|
);
|
|
}
|
|
}
|
|
|
|
const normalizedEmail = dto.email
|
|
? dto.email.trim().toLowerCase()
|
|
: undefined;
|
|
if (normalizedEmail && normalizedEmail !== user.email) {
|
|
const existingEmail = await this.prisma.user.findUnique({
|
|
where: { email: normalizedEmail },
|
|
});
|
|
if (existingEmail && existingEmail.id !== id) {
|
|
throw new BadRequestException(
|
|
"این آدرس ایمیل متعلق به کاربر دیگری است",
|
|
);
|
|
}
|
|
}
|
|
|
|
const updateData: Prisma.UserUpdateInput = {};
|
|
if (dto.firstName !== undefined)
|
|
updateData.firstName = dto.firstName.trim();
|
|
if (dto.lastName !== undefined) updateData.lastName = dto.lastName.trim();
|
|
if (normalizedMobile !== undefined) updateData.mobile = normalizedMobile;
|
|
if (normalizedEmail !== undefined)
|
|
updateData.email = normalizedEmail || null;
|
|
if (dto.role !== undefined) {
|
|
if (!ALLOWED_USER_ROLES.includes(dto.role)) {
|
|
throw new BadRequestException("نقش کاربری مشخص شده نامعتبر است");
|
|
}
|
|
updateData.role = dto.role;
|
|
}
|
|
if (dto.walletBalance !== undefined) {
|
|
updateData.walletBalance = new Prisma.Decimal(dto.walletBalance);
|
|
}
|
|
if (dto.password && dto.password.trim().length >= 6) {
|
|
updateData.password = await bcrypt.hash(dto.password.trim(), 10);
|
|
}
|
|
|
|
return this.prisma.user.update({
|
|
where: { id },
|
|
data: updateData,
|
|
});
|
|
}
|
|
|
|
async updateUserRole(id: string, role: string, actor?: UserAdminActor) {
|
|
return this.updateUser(id, { role }, actor);
|
|
}
|
|
|
|
async deleteUser(id: string, actor?: UserAdminActor) {
|
|
if (id === "12345678-1234-1234-1234-123456789012") {
|
|
throw new BadRequestException("امکان حذف حساب ادمین پیشفرض وجود ندارد");
|
|
}
|
|
|
|
const user = await this.prisma.user.findUnique({ where: { id } });
|
|
if (!user) {
|
|
throw new NotFoundException(`کاربری با شناسه ${id} یافت نشد`);
|
|
}
|
|
|
|
assertUserMutationAllowed(actor, user.role);
|
|
|
|
return this.prisma.$transaction(async (tx) => {
|
|
await tx.userAddress.deleteMany({ where: { userId: id } });
|
|
await tx.walletTransaction.deleteMany({ where: { userId: id } });
|
|
await tx.pet.deleteMany({ where: { userId: id } });
|
|
await tx.prescription.deleteMany({ where: { userId: id } });
|
|
await tx.paymentTransaction.deleteMany({ where: { userId: id } });
|
|
await tx.partnerAccount.deleteMany({ where: { userId: id } });
|
|
await tx.blog.deleteMany({ where: { authorId: id } });
|
|
await tx.order.deleteMany({ where: { userId: id } });
|
|
return tx.user.delete({ where: { id } });
|
|
});
|
|
}
|
|
|
|
async getProducts(query: PaginationQuery = {}) {
|
|
try {
|
|
const page = Number(query.page) || 1;
|
|
const limit = Number(query.limit) || 10;
|
|
const skip = (page - 1) * limit;
|
|
|
|
const where: Prisma.ProductWhereInput = {};
|
|
const andConditions: Prisma.ProductWhereInput[] = [];
|
|
|
|
if (query.search) {
|
|
const trimmed = query.search.trim();
|
|
andConditions.push({
|
|
OR: [
|
|
{ nameFa: { contains: trimmed, mode: "insensitive" } },
|
|
{ nameEn: { contains: trimmed, mode: "insensitive" } },
|
|
{ artNo: { contains: trimmed, mode: "insensitive" } },
|
|
{ barcode: { contains: trimmed, mode: "insensitive" } },
|
|
{ slug: { contains: trimmed, mode: "insensitive" } },
|
|
{ description: { contains: trimmed, mode: "insensitive" } },
|
|
{ shortDescription: { contains: trimmed, mode: "insensitive" } },
|
|
{ scientificTagline: { contains: trimmed, mode: "insensitive" } },
|
|
{
|
|
symptoms: {
|
|
some: {
|
|
symptom: { contains: trimmed, mode: "insensitive" },
|
|
},
|
|
},
|
|
},
|
|
{
|
|
category: {
|
|
name: { contains: trimmed, mode: "insensitive" },
|
|
},
|
|
},
|
|
],
|
|
});
|
|
}
|
|
|
|
if (query.categoryId) {
|
|
andConditions.push({ categoryId: query.categoryId });
|
|
}
|
|
|
|
if (query.suitableFor && query.suitableFor !== "all") {
|
|
andConditions.push({
|
|
suitableFor: { in: [query.suitableFor, "سگ و گربه", "هر دو"] },
|
|
});
|
|
}
|
|
|
|
if (andConditions.length > 0) {
|
|
where.AND = andConditions;
|
|
}
|
|
|
|
const sortField =
|
|
query.sortBy &&
|
|
typeof query.sortBy === "string" &&
|
|
[
|
|
"nameFa",
|
|
"artNo",
|
|
"priceValue",
|
|
"packageSize",
|
|
"createdAt",
|
|
"updatedAt",
|
|
].includes(query.sortBy)
|
|
? query.sortBy
|
|
: "createdAt";
|
|
const sortDirection = query.sortOrder === "asc" ? "asc" : "desc";
|
|
|
|
const [data, total] = await Promise.all([
|
|
this.prisma.product.findMany({
|
|
where,
|
|
skip,
|
|
take: limit,
|
|
orderBy: { [sortField]: sortDirection },
|
|
include: { category: true, symptoms: true, ingredientList: true },
|
|
}),
|
|
this.prisma.product.count({ where }),
|
|
]);
|
|
|
|
return {
|
|
data,
|
|
meta: { total, page, limit, lastPage: Math.ceil(total / limit) },
|
|
};
|
|
} catch (error) {
|
|
const err = error as { message?: string };
|
|
console.error("[AdminService] getProducts error:", err);
|
|
throw new HttpException(err.message || "Error fetching products", 500);
|
|
}
|
|
}
|
|
|
|
async createProduct(data: ProductDto) {
|
|
const marginRetail =
|
|
data.marginRetailPercent ?? data.priceValueMarginPercent;
|
|
const marginWholesale =
|
|
data.marginWholesalePercent ?? data.wholesaleMarginPercent;
|
|
|
|
const dosageConfigData: Record<string, any> = {
|
|
...(data.dosageConfig || {}),
|
|
...(data.feedingAdvice !== undefined
|
|
? { feedingAdvice: data.feedingAdvice }
|
|
: {}),
|
|
...(data.showFaqs !== undefined ? { showFaqs: data.showFaqs } : {}),
|
|
...(data.faqs !== undefined ? { faqs: data.faqs } : {}),
|
|
...(data.paoMonths !== undefined ? { paoMonths: data.paoMonths } : {}),
|
|
...(data.storageInfo !== undefined
|
|
? { storageInfo: data.storageInfo }
|
|
: {}),
|
|
...(data.precautions !== undefined
|
|
? { precautions: data.precautions }
|
|
: {}),
|
|
...(data.lifeStage !== undefined ? { lifeStage: data.lifeStage } : {}),
|
|
...(data.keyHighlights !== undefined
|
|
? { keyHighlights: data.keyHighlights }
|
|
: {}),
|
|
...(data.keyBenefits !== undefined
|
|
? { keyBenefits: data.keyBenefits }
|
|
: {}),
|
|
...(data.analysis !== undefined ? { analysis: data.analysis } : {}),
|
|
...(data.onSetOfAction !== undefined
|
|
? { onSetOfAction: data.onSetOfAction }
|
|
: {}),
|
|
...(data.specialBadge !== undefined
|
|
? { specialBadge: data.specialBadge }
|
|
: {}),
|
|
...(data.contraindications !== undefined
|
|
? { contraindications: data.contraindications }
|
|
: {}),
|
|
...(data.expectedResults !== undefined
|
|
? { expectedResults: data.expectedResults }
|
|
: {}),
|
|
...(data.specialist !== undefined ? { specialist: data.specialist } : {}),
|
|
...(data.isPreorder !== undefined ? { isPreorder: data.isPreorder } : {}),
|
|
...(data.preorderDeposit !== undefined
|
|
? { preorderDeposit: data.preorderDeposit }
|
|
: {}),
|
|
};
|
|
|
|
let resolvedCategorySlug = data.categorySlug;
|
|
if (
|
|
data.categoryId &&
|
|
(!resolvedCategorySlug || resolvedCategorySlug === "general")
|
|
) {
|
|
const cat = await this.prisma.category.findUnique({
|
|
where: { id: data.categoryId },
|
|
});
|
|
if (cat) {
|
|
resolvedCategorySlug = cat.slug;
|
|
}
|
|
}
|
|
|
|
const product = await this.prisma.product.create({
|
|
data: {
|
|
artNo: data.artNo || `ART-${Date.now()}`,
|
|
nameFa: data.nameFa || "",
|
|
nameEn: data.nameEn || "",
|
|
scientificTagline: data.scientificTagline || "",
|
|
description: data.description || "",
|
|
shortDescription: data.shortDescription || "",
|
|
ingredients: data.ingredients || null,
|
|
categoryId: data.categoryId || "",
|
|
categorySlug: resolvedCategorySlug || "general",
|
|
buyPrice: data.buyPrice !== undefined ? data.buyPrice : 0,
|
|
marginRetailPercent:
|
|
marginRetail !== undefined ? marginRetail : undefined,
|
|
marginWholesalePercent:
|
|
marginWholesale !== undefined ? marginWholesale : undefined,
|
|
roundingStep:
|
|
data.roundingStep !== undefined
|
|
? data.roundingStep
|
|
? Number(data.roundingStep)
|
|
: null
|
|
: undefined,
|
|
roundingMode:
|
|
data.roundingMode !== undefined
|
|
? data.roundingMode || null
|
|
: undefined,
|
|
priceValue: data.priceValue || 0,
|
|
wholesalePrice:
|
|
data.wholesalePrice !== undefined ? data.wholesalePrice : null,
|
|
priceDisplay: data.priceDisplay || "",
|
|
unit: data.unit || "عدد",
|
|
packageSize: data.packageSize !== undefined ? data.packageSize : 100,
|
|
dosageLogic: data.dosageLogic || "",
|
|
dosageConfig:
|
|
Object.keys(dosageConfigData).length > 0
|
|
? dosageConfigData
|
|
: undefined,
|
|
suitableFor: data.suitableFor || "سگ",
|
|
imageUrl: data.imageUrl || "",
|
|
images: Array.isArray(data.images)
|
|
? data.images
|
|
: data.images
|
|
? [data.images]
|
|
: [],
|
|
podcastUrl: data.podcastUrl || null,
|
|
podcastTitle: data.podcastTitle || null,
|
|
podcastDescription: data.podcastDescription || null,
|
|
podcastCover: data.podcastCover || null,
|
|
videoUrl: data.videoUrl || null,
|
|
videoTitle: data.videoTitle || null,
|
|
videoDescription: data.videoDescription || null,
|
|
videoCover: data.videoCover || null,
|
|
pdfUrl: data.pdfUrl || null,
|
|
pdfTitle: data.pdfTitle || null,
|
|
pdfDescription: data.pdfDescription || null,
|
|
pdfCover: data.pdfCover || null,
|
|
metaTitle: data.metaTitle || "",
|
|
metaDescription: data.metaDescription || "",
|
|
keywords: data.keywords || "",
|
|
canonicalUrl: data.canonicalUrl || "",
|
|
stock:
|
|
data.stock !== undefined
|
|
? Number(data.stock)
|
|
: data.stockStatus === "OUT_OF_STOCK"
|
|
? 0
|
|
: 100,
|
|
stockStatus:
|
|
data.stockStatus ||
|
|
(data.stock !== undefined && Number(data.stock) <= 0
|
|
? "OUT_OF_STOCK"
|
|
: "IN_STOCK"),
|
|
noIndex: data.noIndex ?? false,
|
|
noFollow: data.noFollow ?? false,
|
|
ogImage: data.ogImage || null,
|
|
featuredImageAlt: data.featuredImageAlt || null,
|
|
slug: data.slug || data.artNo || `slug-${Date.now()}`,
|
|
},
|
|
});
|
|
|
|
if (data.symptoms && Array.isArray(data.symptoms)) {
|
|
await this.prisma.productSymptom.createMany({
|
|
data: data.symptoms
|
|
.map((s: string) => ({
|
|
productId: product.id,
|
|
symptom: s.trim(),
|
|
}))
|
|
.filter((s: { symptom: string }) => s.symptom.length > 0),
|
|
});
|
|
}
|
|
|
|
if (data.ingredientList && Array.isArray(data.ingredientList)) {
|
|
const uniqueIngs = Array.from(
|
|
new Set(
|
|
data.ingredientList.map((i: string) => i.trim()).filter(Boolean),
|
|
),
|
|
);
|
|
if (uniqueIngs.length > 0) {
|
|
const resolvedIngs = await this.resolveIngredientCards(uniqueIngs);
|
|
await this.prisma.productIngredient.createMany({
|
|
data: resolvedIngs.map((item) => ({
|
|
productId: product.id,
|
|
ingredient: item.ingredient,
|
|
ingredientCardId: item.ingredientCardId,
|
|
ingredientCardSlug: item.ingredientCardSlug,
|
|
})),
|
|
});
|
|
}
|
|
}
|
|
|
|
await this.revalidationService.revalidateProduct(
|
|
product.slug,
|
|
product.artNo,
|
|
);
|
|
return product;
|
|
}
|
|
|
|
async updateProduct(id: string, data: ProductDto) {
|
|
const existing = await this.prisma.product.findUnique({ where: { id } });
|
|
if (!existing) {
|
|
throw new NotFoundException(`محصولی با شناسه ${id} یافت نشد.`);
|
|
}
|
|
|
|
const marginRetail =
|
|
data.marginRetailPercent ?? data.priceValueMarginPercent;
|
|
const marginWholesale =
|
|
data.marginWholesalePercent ?? data.wholesaleMarginPercent;
|
|
|
|
const existingDosageConfig =
|
|
(existing.dosageConfig as Record<string, any>) || {};
|
|
const updatedDosageConfig: Record<string, any> = {
|
|
...existingDosageConfig,
|
|
...(data.dosageConfig || {}),
|
|
...(data.feedingAdvice !== undefined
|
|
? { feedingAdvice: data.feedingAdvice }
|
|
: {}),
|
|
...(data.showFaqs !== undefined ? { showFaqs: data.showFaqs } : {}),
|
|
...(data.faqs !== undefined ? { faqs: data.faqs } : {}),
|
|
...(data.paoMonths !== undefined ? { paoMonths: data.paoMonths } : {}),
|
|
...(data.storageInfo !== undefined
|
|
? { storageInfo: data.storageInfo }
|
|
: {}),
|
|
...(data.precautions !== undefined
|
|
? { precautions: data.precautions }
|
|
: {}),
|
|
...(data.lifeStage !== undefined ? { lifeStage: data.lifeStage } : {}),
|
|
...(data.keyHighlights !== undefined
|
|
? { keyHighlights: data.keyHighlights }
|
|
: {}),
|
|
...(data.keyBenefits !== undefined
|
|
? { keyBenefits: data.keyBenefits }
|
|
: {}),
|
|
...(data.analysis !== undefined ? { analysis: data.analysis } : {}),
|
|
...(data.onSetOfAction !== undefined
|
|
? { onSetOfAction: data.onSetOfAction }
|
|
: {}),
|
|
...(data.specialBadge !== undefined
|
|
? { specialBadge: data.specialBadge }
|
|
: {}),
|
|
...(data.contraindications !== undefined
|
|
? { contraindications: data.contraindications }
|
|
: {}),
|
|
...(data.expectedResults !== undefined
|
|
? { expectedResults: data.expectedResults }
|
|
: {}),
|
|
...(data.specialist !== undefined ? { specialist: data.specialist } : {}),
|
|
...(data.isPreorder !== undefined ? { isPreorder: data.isPreorder } : {}),
|
|
...(data.preorderDeposit !== undefined
|
|
? { preorderDeposit: data.preorderDeposit }
|
|
: {}),
|
|
};
|
|
|
|
let resolvedCategorySlug = data.categorySlug;
|
|
if (data.categoryId && !resolvedCategorySlug) {
|
|
const cat = await this.prisma.category.findUnique({
|
|
where: { id: data.categoryId },
|
|
});
|
|
if (cat) {
|
|
resolvedCategorySlug = cat.slug;
|
|
}
|
|
}
|
|
|
|
const product = await this.prisma.product.update({
|
|
where: { id },
|
|
data: {
|
|
artNo: data.artNo,
|
|
nameFa: data.nameFa,
|
|
nameEn: data.nameEn,
|
|
scientificTagline: data.scientificTagline,
|
|
description: data.description,
|
|
shortDescription: data.shortDescription,
|
|
ingredients:
|
|
data.ingredients !== undefined ? data.ingredients : undefined,
|
|
categoryId: data.categoryId,
|
|
categorySlug:
|
|
resolvedCategorySlug !== undefined ? resolvedCategorySlug : undefined,
|
|
buyPrice: data.buyPrice !== undefined ? data.buyPrice : undefined,
|
|
marginRetailPercent:
|
|
marginRetail !== undefined ? marginRetail : undefined,
|
|
marginWholesalePercent:
|
|
marginWholesale !== undefined ? marginWholesale : undefined,
|
|
roundingStep:
|
|
data.roundingStep !== undefined
|
|
? data.roundingStep
|
|
? Number(data.roundingStep)
|
|
: null
|
|
: undefined,
|
|
roundingMode:
|
|
data.roundingMode !== undefined
|
|
? data.roundingMode || null
|
|
: undefined,
|
|
priceValue: data.priceValue,
|
|
wholesalePrice:
|
|
data.wholesalePrice !== undefined ? data.wholesalePrice : undefined,
|
|
priceDisplay: data.priceDisplay,
|
|
unit: data.unit,
|
|
packageSize: data.packageSize,
|
|
dosageLogic: data.dosageLogic,
|
|
dosageConfig: updatedDosageConfig,
|
|
suitableFor: data.suitableFor,
|
|
imageUrl: data.imageUrl,
|
|
images: Array.isArray(data.images)
|
|
? data.images
|
|
: data.images
|
|
? [data.images]
|
|
: undefined,
|
|
podcastUrl: data.podcastUrl !== undefined ? data.podcastUrl : undefined,
|
|
podcastTitle:
|
|
data.podcastTitle !== undefined ? data.podcastTitle : undefined,
|
|
podcastDescription:
|
|
data.podcastDescription !== undefined
|
|
? data.podcastDescription
|
|
: undefined,
|
|
podcastCover:
|
|
data.podcastCover !== undefined ? data.podcastCover : undefined,
|
|
videoUrl: data.videoUrl !== undefined ? data.videoUrl : undefined,
|
|
videoTitle: data.videoTitle !== undefined ? data.videoTitle : undefined,
|
|
videoDescription:
|
|
data.videoDescription !== undefined
|
|
? data.videoDescription
|
|
: undefined,
|
|
videoCover: data.videoCover !== undefined ? data.videoCover : undefined,
|
|
pdfUrl: data.pdfUrl !== undefined ? data.pdfUrl : undefined,
|
|
pdfTitle: data.pdfTitle !== undefined ? data.pdfTitle : undefined,
|
|
pdfDescription:
|
|
data.pdfDescription !== undefined ? data.pdfDescription : undefined,
|
|
pdfCover: data.pdfCover !== undefined ? data.pdfCover : undefined,
|
|
metaTitle: data.metaTitle,
|
|
metaDescription: data.metaDescription,
|
|
keywords: data.keywords,
|
|
canonicalUrl: data.canonicalUrl,
|
|
stock: data.stock !== undefined ? Number(data.stock) : undefined,
|
|
stockStatus:
|
|
data.stockStatus !== undefined
|
|
? data.stockStatus
|
|
: data.stock !== undefined
|
|
? Number(data.stock) <= 0
|
|
? "OUT_OF_STOCK"
|
|
: "IN_STOCK"
|
|
: undefined,
|
|
noIndex: data.noIndex !== undefined ? data.noIndex : undefined,
|
|
noFollow: data.noFollow !== undefined ? data.noFollow : undefined,
|
|
ogImage: data.ogImage !== undefined ? data.ogImage : undefined,
|
|
featuredImageAlt:
|
|
data.featuredImageAlt !== undefined
|
|
? data.featuredImageAlt
|
|
: undefined,
|
|
slug: data.slug || data.artNo,
|
|
},
|
|
});
|
|
|
|
if (data.symptoms !== undefined && Array.isArray(data.symptoms)) {
|
|
await this.prisma.productSymptom.deleteMany({ where: { productId: id } });
|
|
if (data.symptoms.length > 0) {
|
|
await this.prisma.productSymptom.createMany({
|
|
data: data.symptoms
|
|
.map((s: string) => ({
|
|
productId: id,
|
|
symptom: s.trim(),
|
|
}))
|
|
.filter((s: { symptom: string }) => s.symptom.length > 0),
|
|
});
|
|
}
|
|
}
|
|
|
|
if (
|
|
data.ingredientList !== undefined &&
|
|
Array.isArray(data.ingredientList)
|
|
) {
|
|
await this.prisma.productIngredient.deleteMany({
|
|
where: { productId: id },
|
|
});
|
|
if (data.ingredientList.length > 0) {
|
|
const uniqueIngs = Array.from(
|
|
new Set(
|
|
data.ingredientList.map((i: string) => i.trim()).filter(Boolean),
|
|
),
|
|
);
|
|
const resolvedIngs = await this.resolveIngredientCards(uniqueIngs);
|
|
await this.prisma.productIngredient.createMany({
|
|
data: resolvedIngs.map((item) => ({
|
|
productId: id,
|
|
ingredient: item.ingredient,
|
|
ingredientCardId: item.ingredientCardId,
|
|
ingredientCardSlug: item.ingredientCardSlug,
|
|
})),
|
|
});
|
|
}
|
|
}
|
|
|
|
await this.revalidationService.revalidateProduct(
|
|
product.slug,
|
|
product.artNo,
|
|
);
|
|
return this.prisma.product.findUnique({
|
|
where: { id },
|
|
include: { category: true, symptoms: true, ingredientList: true },
|
|
});
|
|
}
|
|
|
|
async deleteProduct(id: string) {
|
|
const existing = await this.prisma.product.findUnique({ where: { id } });
|
|
const res = await this.prisma.product.delete({
|
|
where: { id },
|
|
});
|
|
if (existing) {
|
|
await this.revalidationService.revalidateProduct(
|
|
existing.slug,
|
|
existing.artNo,
|
|
);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
async getOrders(query: PaginationQuery = {}) {
|
|
const page = Number(query.page) || 1;
|
|
const limit = Number(query.limit) || 10;
|
|
const skip = (page - 1) * limit;
|
|
|
|
const where: Prisma.OrderWhereInput = {};
|
|
if (query.search) {
|
|
where.OR = [
|
|
{ trackingNumber: { contains: query.search, mode: "insensitive" } },
|
|
{
|
|
user: { firstName: { contains: query.search, mode: "insensitive" } },
|
|
},
|
|
{ user: { lastName: { contains: query.search, mode: "insensitive" } } },
|
|
{ user: { mobile: { contains: query.search } } },
|
|
];
|
|
}
|
|
if (query.status) {
|
|
where.status = query.status;
|
|
}
|
|
|
|
const sortField =
|
|
query.sortBy &&
|
|
typeof query.sortBy === "string" &&
|
|
["createdAt", "totalAmount", "status", "finalAmount"].includes(
|
|
query.sortBy,
|
|
)
|
|
? query.sortBy
|
|
: "createdAt";
|
|
const sortDirection = query.sortOrder === "asc" ? "asc" : "desc";
|
|
|
|
const [data, total] = await Promise.all([
|
|
this.prisma.order.findMany({
|
|
where,
|
|
skip,
|
|
take: limit,
|
|
orderBy: { [sortField]: sortDirection },
|
|
include: {
|
|
user: true,
|
|
orderItems: {
|
|
include: {
|
|
product: true,
|
|
},
|
|
},
|
|
coupon: true,
|
|
paymentTransactions: {
|
|
orderBy: { createdAt: "desc" },
|
|
},
|
|
},
|
|
}),
|
|
this.prisma.order.count({ where }),
|
|
]);
|
|
|
|
return {
|
|
data,
|
|
meta: { total, page, limit, lastPage: Math.ceil(total / limit) },
|
|
};
|
|
}
|
|
|
|
async getOrderById(id: string) {
|
|
const order = await this.prisma.order.findUnique({
|
|
where: { id },
|
|
include: {
|
|
user: true,
|
|
orderItems: {
|
|
include: {
|
|
product: true,
|
|
},
|
|
},
|
|
coupon: true,
|
|
paymentTransactions: {
|
|
orderBy: { createdAt: "desc" },
|
|
},
|
|
},
|
|
});
|
|
if (!order) {
|
|
throw new NotFoundException(`سفارش با شناسه ${id} یافت نشد`);
|
|
}
|
|
return order;
|
|
}
|
|
|
|
async updateOrderStatus(id: string, status: string, trackingNumber?: string) {
|
|
const dataToUpdate: Prisma.OrderUpdateInput = { status };
|
|
|
|
if (trackingNumber !== undefined) {
|
|
dataToUpdate.trackingNumber = trackingNumber;
|
|
}
|
|
const updatedOrder = await this.prisma.order.update({
|
|
where: { id },
|
|
data: dataToUpdate,
|
|
include: {
|
|
user: true,
|
|
orderItems: {
|
|
include: {
|
|
product: true,
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
// Send Shipping SMS with Tracking Code or Courier fallback
|
|
if (status === "shipped" && this.smsService && updatedOrder.user?.mobile) {
|
|
try {
|
|
const rawShipping = updatedOrder.shippingAddress;
|
|
let shipping: Record<string, any> = {};
|
|
|
|
if (typeof rawShipping === "object" && rawShipping !== null) {
|
|
shipping = rawShipping;
|
|
} else if (typeof rawShipping === "string") {
|
|
const trimmed = rawShipping.trim();
|
|
if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
|
|
try {
|
|
shipping = JSON.parse(trimmed);
|
|
} catch {
|
|
shipping = {};
|
|
}
|
|
}
|
|
if (!shipping.province || !shipping.address) {
|
|
let text = trimmed;
|
|
const recipientMatch = text.match(
|
|
/\(گیرنده:\s*([^-)]+)(?:-\s*([^)]+))?\)/,
|
|
);
|
|
if (recipientMatch) {
|
|
if (!shipping.fullName)
|
|
shipping.fullName = recipientMatch[1]?.trim();
|
|
if (!shipping.phone && recipientMatch[2])
|
|
shipping.phone = recipientMatch[2]?.trim();
|
|
text = text.replace(recipientMatch[0], "").trim();
|
|
}
|
|
const postalMatch = text.match(/\(کد پستی:\s*([^)]+)\)/);
|
|
if (postalMatch) {
|
|
if (!shipping.postalCode)
|
|
shipping.postalCode = postalMatch[1]?.trim();
|
|
text = text.replace(postalMatch[0], "").trim();
|
|
}
|
|
const parts = text
|
|
.split(/[،,]/)
|
|
.map((p) => p.trim())
|
|
.filter(Boolean);
|
|
if (parts.length >= 3) {
|
|
if (!shipping.province) shipping.province = parts[0];
|
|
if (!shipping.city) shipping.city = parts[1];
|
|
if (!shipping.address)
|
|
shipping.address = parts.slice(2).join("، ");
|
|
} else if (parts.length === 2) {
|
|
if (!shipping.province) shipping.province = parts[0];
|
|
if (!shipping.address) shipping.address = parts[1];
|
|
} else if (parts.length === 1 && !shipping.address) {
|
|
shipping.address = parts[0];
|
|
}
|
|
}
|
|
}
|
|
|
|
const user = updatedOrder.user;
|
|
const customerFullName = (
|
|
user?.firstName
|
|
? `${user.firstName} ${user.lastName || ""}`
|
|
: shipping.fullName || "مشتری"
|
|
).trim();
|
|
|
|
const recipientFullName = (
|
|
shipping.fullName ||
|
|
shipping.receptorName ||
|
|
customerFullName
|
|
).trim();
|
|
|
|
const finalTracking =
|
|
trackingNumber || updatedOrder.trackingNumber || "";
|
|
|
|
const orderData = {
|
|
orderNumber:
|
|
updatedOrder.trackingNumber || updatedOrder.id.slice(0, 8),
|
|
amount: Number(updatedOrder.totalAmount || 0).toLocaleString("fa-IR"),
|
|
customerName: customerFullName,
|
|
customerPhone: user?.mobile || shipping.phone || "",
|
|
recipientName: recipientFullName,
|
|
recipientPhone: shipping.phone || user?.mobile || "",
|
|
provinceCity: (shipping.province && shipping.city
|
|
? `${shipping.province} - ${shipping.city}`
|
|
: shipping.province || shipping.city || "ثبت نشده"
|
|
).trim(),
|
|
postalCode: shipping.postalCode || shipping.zipCode || "",
|
|
address: (
|
|
shipping.address ||
|
|
(typeof rawShipping === "string" ? rawShipping : "")
|
|
).trim(),
|
|
trackingCode: finalTracking || "ارسال با پیک شهری",
|
|
shippingTrackingCode: finalTracking || "ارسال با پیک شهری",
|
|
shippingMethod: finalTracking ? "پست پیشتاز / تیپاکس" : "پیک شهری",
|
|
orderDate: new Date().toLocaleDateString("fa-IR"),
|
|
};
|
|
|
|
this.smsService
|
|
.triggerEvent("ORDER_SHIPPED", orderData)
|
|
.catch(() => {});
|
|
} catch (smsErr) {
|
|
// Silently catch SMS errors to avoid breaking status update
|
|
}
|
|
}
|
|
|
|
return updatedOrder;
|
|
}
|
|
|
|
async refundOrderToWallet(
|
|
orderId: string,
|
|
customAmount?: number,
|
|
reason?: string,
|
|
) {
|
|
const order = await this.prisma.order.findUnique({
|
|
where: { id: orderId },
|
|
include: { user: true },
|
|
});
|
|
|
|
if (!order) {
|
|
throw new NotFoundException("سفارش مورد نظر یافت نشد");
|
|
}
|
|
|
|
if (!order.userId || !order.user) {
|
|
throw new BadRequestException(
|
|
"این سفارش به کاربر ثبتنامشدهای متصل نیست",
|
|
);
|
|
}
|
|
|
|
if (order.refundStatus === "wallet" || order.refundStatus === "gateway") {
|
|
throw new BadRequestException(
|
|
"برای این سفارش قبلاً استرداد وجه انجام شده است",
|
|
);
|
|
}
|
|
|
|
const refundAmount =
|
|
customAmount !== undefined && customAmount > 0
|
|
? customAmount
|
|
: Number(order.totalAmount || 0);
|
|
|
|
if (refundAmount <= 0) {
|
|
throw new BadRequestException("مبلغ استرداد باید بیشتر از صفر باشد");
|
|
}
|
|
|
|
await this.prisma.$transaction(async (tx) => {
|
|
// 1. Increment user wallet balance
|
|
await tx.user.update({
|
|
where: { id: order.userId },
|
|
data: {
|
|
walletBalance: { increment: refundAmount },
|
|
},
|
|
});
|
|
|
|
// 2. Create wallet transaction entry
|
|
await tx.walletTransaction.create({
|
|
data: {
|
|
userId: order.userId,
|
|
amount: refundAmount,
|
|
type: "deposit",
|
|
status: "completed",
|
|
description:
|
|
reason ||
|
|
`استرداد وجه سفارش لغو شده #${order.trackingNumber || order.id.slice(0, 8)} به کیف پول`,
|
|
},
|
|
});
|
|
|
|
// 3. Mark order as cancelled and note refund
|
|
await tx.order.update({
|
|
where: { id: order.id },
|
|
data: {
|
|
status: "cancelled",
|
|
refundStatus: "wallet",
|
|
refundedAmount: refundAmount,
|
|
refundMethod: "wallet",
|
|
},
|
|
});
|
|
});
|
|
|
|
// Send SMS notification for wallet refund
|
|
if (this.smsService && order.user?.mobile) {
|
|
try {
|
|
const user = await this.prisma.user.findUnique({
|
|
where: { id: order.userId },
|
|
});
|
|
const customerFullName = (
|
|
order.user.firstName
|
|
? `${order.user.firstName} ${order.user.lastName || ""}`
|
|
: "کاربر گرامی"
|
|
).trim();
|
|
const refundData = {
|
|
customerName: customerFullName,
|
|
customerPhone: order.user.mobile,
|
|
amount: Number(refundAmount || 0).toLocaleString("fa-IR"),
|
|
balance: Number(user?.walletBalance || 0).toLocaleString("fa-IR"),
|
|
reason:
|
|
reason ||
|
|
`استرداد وجه سفارش #${order.trackingNumber || order.id.slice(0, 8)}`,
|
|
date: new Date().toLocaleDateString("fa-IR"),
|
|
};
|
|
|
|
this.smsService
|
|
.triggerEvent("WALLET_CHARGED", refundData)
|
|
.catch(() => {});
|
|
} catch (err) {
|
|
// Silently catch SMS errors
|
|
}
|
|
}
|
|
|
|
return {
|
|
success: true,
|
|
message: `مبلغ ${refundAmount.toLocaleString("fa-IR")} تومان با موفقیت به کیف پول کاربر بازگردانده شد.`,
|
|
refundAmount,
|
|
userId: order.userId,
|
|
};
|
|
}
|
|
|
|
async getCoupons(query: PaginationQuery = {}) {
|
|
const page = Number(query.page) || 1;
|
|
const limit = Number(query.limit) || 10;
|
|
const skip = (page - 1) * limit;
|
|
|
|
const where: Prisma.CouponWhereInput = query.search
|
|
? { code: { contains: query.search, mode: "insensitive" } }
|
|
: {};
|
|
|
|
const [data, total] = await Promise.all([
|
|
this.prisma.coupon.findMany({
|
|
where,
|
|
skip,
|
|
take: limit,
|
|
orderBy: { createdAt: "desc" },
|
|
include: { targets: true },
|
|
}),
|
|
this.prisma.coupon.count({ where }),
|
|
]);
|
|
|
|
return {
|
|
data,
|
|
meta: {
|
|
total,
|
|
page,
|
|
limit,
|
|
lastPage: Math.ceil(total / limit),
|
|
},
|
|
};
|
|
}
|
|
|
|
async createCoupon(data: CouponInput) {
|
|
return this.prisma.coupon.create({
|
|
data: {
|
|
code: data.code,
|
|
type: data.type || "percent",
|
|
value: data.value,
|
|
minCartValue: data.minCartValue || null,
|
|
maxCartValue: data.maxCartValue || null,
|
|
maxUses: data.maxUses || null,
|
|
expiresAt: data.expiresAt ? new Date(data.expiresAt) : null,
|
|
isActive: data.isActive !== undefined ? data.isActive : true,
|
|
targets:
|
|
data.targets && data.targets.length > 0
|
|
? {
|
|
create: data.targets.map((t) => ({
|
|
targetType: t.targetType,
|
|
targetId: t.targetId,
|
|
modifierType: t.modifierType || "override",
|
|
modifierValue: t.modifierValue || null,
|
|
})),
|
|
}
|
|
: undefined,
|
|
},
|
|
include: { targets: true },
|
|
});
|
|
}
|
|
|
|
async updateCoupon(id: string, data: CouponInput) {
|
|
await this.prisma.couponTarget.deleteMany({ where: { couponId: id } });
|
|
|
|
return this.prisma.coupon.update({
|
|
where: { id },
|
|
data: {
|
|
code: data.code,
|
|
type: data.type,
|
|
value: data.value,
|
|
minCartValue: data.minCartValue,
|
|
maxCartValue: data.maxCartValue,
|
|
maxUses: data.maxUses,
|
|
expiresAt: data.expiresAt ? new Date(data.expiresAt) : null,
|
|
isActive: data.isActive,
|
|
targets:
|
|
data.targets && data.targets.length > 0
|
|
? {
|
|
create: data.targets.map((t) => ({
|
|
targetType: t.targetType,
|
|
targetId: t.targetId,
|
|
modifierType: t.modifierType || "override",
|
|
modifierValue: t.modifierValue || null,
|
|
})),
|
|
}
|
|
: undefined,
|
|
},
|
|
include: { targets: true },
|
|
});
|
|
}
|
|
|
|
async toggleCoupon(id: string, isActive: boolean) {
|
|
return this.prisma.coupon.update({
|
|
where: { id },
|
|
data: { isActive },
|
|
});
|
|
}
|
|
|
|
async deleteCoupon(id: string) {
|
|
return this.prisma.coupon.delete({
|
|
where: { id },
|
|
});
|
|
}
|
|
|
|
async getSettings() {
|
|
const settings = await this.prisma.uiText.findMany();
|
|
return settings.reduce(
|
|
(acc, curr) => ({ ...acc, [curr.key]: curr.value }),
|
|
{} as Record<string, string>,
|
|
);
|
|
}
|
|
|
|
async updateSettings(data: Record<string, string>) {
|
|
if (!data || typeof data !== "object") return this.getSettings();
|
|
|
|
const mergedData: Record<string, string> = { ...data };
|
|
Object.entries(data).forEach(([key, value]) => {
|
|
const aliases = CANONICAL_ALIASES[key] || [];
|
|
aliases.forEach((alias) => {
|
|
mergedData[alias] = String(value);
|
|
});
|
|
});
|
|
|
|
const operations = Object.entries(mergedData).map(([key, value]) => {
|
|
return this.prisma.uiText.upsert({
|
|
where: { key },
|
|
update: { value: String(value) },
|
|
create: { key, value: String(value) },
|
|
});
|
|
});
|
|
|
|
await this.prisma.$transaction(operations);
|
|
|
|
// Also sync setting table
|
|
for (const [key, value] of Object.entries(mergedData)) {
|
|
try {
|
|
await this.prisma.setting.upsert({
|
|
where: { key },
|
|
update: { value: String(value) },
|
|
create: { key, value: String(value), category: "general" },
|
|
});
|
|
} catch {
|
|
// ignore
|
|
}
|
|
}
|
|
|
|
return this.getSettings();
|
|
}
|
|
|
|
async getPets(query: PaginationQuery = {}) {
|
|
const page = Number(query.page) || 1;
|
|
const limit = Number(query.limit) || 10;
|
|
const skip = (page - 1) * limit;
|
|
|
|
const where: Prisma.PetWhereInput = {};
|
|
if (query.search) {
|
|
where.OR = [
|
|
{ name: { contains: query.search, mode: "insensitive" } },
|
|
{ breed: { contains: query.search, mode: "insensitive" } },
|
|
{
|
|
user: { firstName: { contains: query.search, mode: "insensitive" } },
|
|
},
|
|
{ user: { lastName: { contains: query.search, mode: "insensitive" } } },
|
|
];
|
|
}
|
|
|
|
const [data, total] = await Promise.all([
|
|
this.prisma.pet.findMany({
|
|
where,
|
|
skip,
|
|
take: limit,
|
|
orderBy: { createdAt: "desc" },
|
|
include: {
|
|
user: {
|
|
select: {
|
|
id: true,
|
|
firstName: true,
|
|
lastName: true,
|
|
mobile: true,
|
|
email: true,
|
|
},
|
|
},
|
|
medicalConditions: true,
|
|
reminders: true,
|
|
healthLogs: {
|
|
orderBy: { loggedDate: "desc" },
|
|
take: 10,
|
|
},
|
|
},
|
|
}),
|
|
this.prisma.pet.count({ where }),
|
|
]);
|
|
|
|
return {
|
|
data,
|
|
meta: { total, page, limit, lastPage: Math.ceil(total / limit) },
|
|
};
|
|
}
|
|
|
|
async getDoctors() {
|
|
return this.prisma.doctor.findMany({
|
|
orderBy: { createdAt: "desc" },
|
|
});
|
|
}
|
|
|
|
async createDoctor(data: {
|
|
name: string;
|
|
title: string;
|
|
avatarUrl?: string;
|
|
bio?: string;
|
|
clinic?: string;
|
|
}) {
|
|
return this.prisma.doctor.create({ data });
|
|
}
|
|
|
|
async updateDoctor(
|
|
id: string,
|
|
data: {
|
|
name?: string;
|
|
title?: string;
|
|
avatarUrl?: string;
|
|
bio?: string;
|
|
clinic?: string;
|
|
},
|
|
) {
|
|
return this.prisma.doctor.update({ where: { id }, data });
|
|
}
|
|
|
|
async deleteDoctor(id: string) {
|
|
return this.prisma.doctor.delete({ where: { id } });
|
|
}
|
|
|
|
async adjustUserWallet(
|
|
userId: string,
|
|
amount: number,
|
|
type: "deposit" | "withdrawal" | "refund",
|
|
description?: string,
|
|
actor?: UserAdminActor,
|
|
) {
|
|
const user = await this.prisma.user.findUnique({ where: { id: userId } });
|
|
if (!user) {
|
|
throw new NotFoundException(`کاربری با شناسه ${userId} یافت نشد.`);
|
|
}
|
|
|
|
assertUserMutationAllowed(actor, user.role);
|
|
|
|
const transaction = await this.prisma.walletTransaction.create({
|
|
data: {
|
|
userId,
|
|
amount,
|
|
type,
|
|
status: "completed",
|
|
description: description || "تغییر دستی توسط مدیر سیستم",
|
|
},
|
|
});
|
|
|
|
const isIncrement = type === "deposit" || type === "refund";
|
|
const updatedUser = await this.prisma.user.update({
|
|
where: { id: userId },
|
|
data: {
|
|
walletBalance: isIncrement
|
|
? { increment: amount }
|
|
: { decrement: amount },
|
|
},
|
|
});
|
|
|
|
// Send SMS notification if wallet is topped up or refunded
|
|
if (isIncrement && this.smsService && updatedUser.mobile) {
|
|
try {
|
|
const customerFullName = (
|
|
updatedUser.firstName
|
|
? `${updatedUser.firstName} ${updatedUser.lastName || ""}`
|
|
: "کاربر گرامی"
|
|
).trim();
|
|
const topupData = {
|
|
customerName: customerFullName,
|
|
customerPhone: updatedUser.mobile,
|
|
amount: Number(amount || 0).toLocaleString("fa-IR"),
|
|
balance: Number(updatedUser.walletBalance || 0).toLocaleString(
|
|
"fa-IR",
|
|
),
|
|
reason:
|
|
description ||
|
|
(type === "refund"
|
|
? "استرداد وجه به کیف پول"
|
|
: "شارژ کیف پول توسط مدیریت"),
|
|
date: new Date().toLocaleDateString("fa-IR"),
|
|
};
|
|
|
|
this.smsService
|
|
.triggerEvent("WALLET_CHARGED", topupData)
|
|
.catch(() => {});
|
|
} catch (err) {
|
|
// Silently catch SMS errors
|
|
}
|
|
}
|
|
|
|
return transaction;
|
|
}
|
|
|
|
async getPricingSettings(): Promise<PricingSettings> {
|
|
const setting = await this.prisma.setting.findUnique({
|
|
where: { key: "pricing_config" },
|
|
});
|
|
if (!setting || !setting.value || typeof setting.value !== "object") {
|
|
return DEFAULT_PRICING_SETTINGS;
|
|
}
|
|
const val = setting.value as Record<string, any>;
|
|
return {
|
|
roundingStep: Number(
|
|
val.roundingStep ?? DEFAULT_PRICING_SETTINGS.roundingStep,
|
|
),
|
|
roundingMode: (val.roundingMode ||
|
|
DEFAULT_PRICING_SETTINGS.roundingMode) as RoundingMode,
|
|
defaultRetailMarginPercent: Number(
|
|
val.defaultRetailMarginPercent ??
|
|
DEFAULT_PRICING_SETTINGS.defaultRetailMarginPercent,
|
|
),
|
|
defaultWholesaleMarginPercent: Number(
|
|
val.defaultWholesaleMarginPercent ??
|
|
DEFAULT_PRICING_SETTINGS.defaultWholesaleMarginPercent,
|
|
),
|
|
};
|
|
}
|
|
|
|
async updatePricingSettings(dto: UpdatePricingSettingsDto) {
|
|
const value = {
|
|
roundingStep: Number(dto.roundingStep ?? 5000),
|
|
roundingMode: dto.roundingMode || "UP",
|
|
defaultRetailMarginPercent: Number(dto.defaultRetailMarginPercent ?? 30),
|
|
defaultWholesaleMarginPercent: Number(
|
|
dto.defaultWholesaleMarginPercent ?? 15,
|
|
),
|
|
};
|
|
|
|
await this.prisma.setting.upsert({
|
|
where: { key: "pricing_config" },
|
|
update: { category: "pricing", value },
|
|
create: { key: "pricing_config", category: "pricing", value },
|
|
});
|
|
|
|
let updatedCount = 0;
|
|
if (dto.applyToAllProducts !== false) {
|
|
const products = await this.prisma.product.findMany({
|
|
where: { buyPrice: { gt: 0 } },
|
|
select: {
|
|
id: true,
|
|
slug: true,
|
|
artNo: true,
|
|
buyPrice: true,
|
|
roundingStep: true,
|
|
roundingMode: true,
|
|
},
|
|
});
|
|
|
|
const revalidateSlugs: string[] = [];
|
|
for (const prod of products) {
|
|
const buyPrice = Number(prod.buyPrice || 0);
|
|
if (buyPrice > 0) {
|
|
const prodStep = prod.roundingStep
|
|
? Number(prod.roundingStep)
|
|
: value.roundingStep;
|
|
const prodMode = (prod.roundingMode ||
|
|
value.roundingMode) as RoundingMode;
|
|
const newRetailPrice = calculateSellingPrice(
|
|
buyPrice,
|
|
value.defaultRetailMarginPercent,
|
|
prodStep,
|
|
prodMode,
|
|
);
|
|
const newWholesalePrice = calculateSellingPrice(
|
|
buyPrice,
|
|
value.defaultWholesaleMarginPercent,
|
|
prodStep,
|
|
prodMode,
|
|
);
|
|
|
|
await this.prisma.product.update({
|
|
where: { id: prod.id },
|
|
data: {
|
|
priceValue: newRetailPrice,
|
|
wholesalePrice: newWholesalePrice,
|
|
marginRetailPercent: value.defaultRetailMarginPercent,
|
|
marginWholesalePercent: value.defaultWholesaleMarginPercent,
|
|
priceDisplay: `${newRetailPrice.toLocaleString("fa-IR")} تومان`,
|
|
},
|
|
});
|
|
updatedCount++;
|
|
if (prod.slug) revalidateSlugs.push(prod.slug);
|
|
}
|
|
}
|
|
|
|
if (revalidateSlugs.length > 0) {
|
|
for (const slug of revalidateSlugs.slice(0, 30)) {
|
|
this.revalidationService.revalidateProduct(slug).catch(() => {});
|
|
}
|
|
}
|
|
}
|
|
|
|
return {
|
|
success: true,
|
|
message:
|
|
updatedCount > 0
|
|
? `تنظیمات ذخیره و قیمت ${updatedCount} محصول با فرمول جدید بهروزرسانی و گرد شدند.`
|
|
: "تنظیمات قیمتگذاری و گرد کردن با موفقیت ذخیره شد.",
|
|
data: value,
|
|
updatedCount,
|
|
};
|
|
}
|
|
|
|
async applyGlobalMargins(dto: ApplyGlobalMarginsDto) {
|
|
const pricingSettings = await this.getPricingSettings();
|
|
const globalRoundingStep =
|
|
dto.roundingStep !== undefined
|
|
? Number(dto.roundingStep)
|
|
: pricingSettings.roundingStep;
|
|
const globalRoundingMode = dto.roundingMode || pricingSettings.roundingMode;
|
|
const retailMargin = Number(dto.retailMarginPercent);
|
|
const wholesaleMargin = Number(dto.wholesaleMarginPercent);
|
|
|
|
const whereCondition: Prisma.ProductWhereInput = {};
|
|
if (
|
|
dto.scope === "CATEGORY" &&
|
|
dto.categoryIds &&
|
|
dto.categoryIds.length > 0
|
|
) {
|
|
whereCondition.categoryId = { in: dto.categoryIds };
|
|
} else if (
|
|
dto.scope === "SPECIFIC" &&
|
|
dto.productIds &&
|
|
dto.productIds.length > 0
|
|
) {
|
|
whereCondition.id = { in: dto.productIds };
|
|
}
|
|
|
|
const products = await this.prisma.product.findMany({
|
|
where: whereCondition,
|
|
select: {
|
|
id: true,
|
|
slug: true,
|
|
artNo: true,
|
|
buyPrice: true,
|
|
roundingStep: true,
|
|
roundingMode: true,
|
|
priceValue: true,
|
|
wholesalePrice: true,
|
|
},
|
|
});
|
|
|
|
let updatedCount = 0;
|
|
const revalidateSlugs: string[] = [];
|
|
|
|
for (const prod of products) {
|
|
const buyPrice = Number(prod.buyPrice || 0);
|
|
if (buyPrice > 0) {
|
|
const prodStep = prod.roundingStep
|
|
? Number(prod.roundingStep)
|
|
: globalRoundingStep;
|
|
const prodMode = (prod.roundingMode ||
|
|
globalRoundingMode) as RoundingMode;
|
|
const newRetailPrice = calculateSellingPrice(
|
|
buyPrice,
|
|
retailMargin,
|
|
prodStep,
|
|
prodMode,
|
|
);
|
|
const newWholesalePrice = calculateSellingPrice(
|
|
buyPrice,
|
|
wholesaleMargin,
|
|
prodStep,
|
|
prodMode,
|
|
);
|
|
|
|
await this.prisma.product.update({
|
|
where: { id: prod.id },
|
|
data: {
|
|
priceValue: newRetailPrice,
|
|
wholesalePrice: newWholesalePrice,
|
|
marginRetailPercent: retailMargin,
|
|
marginWholesalePercent: wholesaleMargin,
|
|
priceDisplay: `${newRetailPrice.toLocaleString("fa-IR")} تومان`,
|
|
},
|
|
});
|
|
updatedCount++;
|
|
if (prod.slug) revalidateSlugs.push(prod.slug);
|
|
}
|
|
}
|
|
|
|
if (revalidateSlugs.length > 0) {
|
|
for (const slug of revalidateSlugs.slice(0, 20)) {
|
|
this.revalidationService.revalidateProduct(slug).catch(() => {});
|
|
}
|
|
}
|
|
|
|
let updatedPricing = pricingSettings;
|
|
if (dto.scope === "ALL" || !dto.scope) {
|
|
updatedPricing = {
|
|
roundingStep: globalRoundingStep,
|
|
roundingMode: globalRoundingMode,
|
|
defaultRetailMarginPercent: retailMargin,
|
|
defaultWholesaleMarginPercent: wholesaleMargin,
|
|
};
|
|
const jsonVal = {
|
|
roundingStep: updatedPricing.roundingStep,
|
|
roundingMode: updatedPricing.roundingMode,
|
|
defaultRetailMarginPercent: updatedPricing.defaultRetailMarginPercent,
|
|
defaultWholesaleMarginPercent:
|
|
updatedPricing.defaultWholesaleMarginPercent,
|
|
};
|
|
await this.prisma.setting.upsert({
|
|
where: { key: "pricing_config" },
|
|
update: { category: "pricing", value: jsonVal },
|
|
create: {
|
|
key: "pricing_config",
|
|
category: "pricing",
|
|
value: jsonVal,
|
|
},
|
|
});
|
|
}
|
|
|
|
return {
|
|
success: true,
|
|
message: `درصد سود با موفقیت بر روی ${updatedCount} محصول اعمال و قیمتها گرد شدند.`,
|
|
updatedCount,
|
|
totalMatched: products.length,
|
|
data: updatedPricing,
|
|
};
|
|
}
|
|
|
|
async bulkPriceAdjustment(dto: BulkPriceAdjustmentDto) {
|
|
const pricingSettings = await this.getPricingSettings();
|
|
const roundingStep =
|
|
dto.roundingStep !== undefined
|
|
? Number(dto.roundingStep)
|
|
: pricingSettings.roundingStep;
|
|
const roundingMode = dto.roundingMode || pricingSettings.roundingMode;
|
|
const applyRound = dto.applyRounding !== false;
|
|
const adjValue = Number(dto.value || 0);
|
|
|
|
const whereCondition: Prisma.ProductWhereInput = {};
|
|
if (
|
|
dto.scope === "CATEGORY" &&
|
|
dto.categoryIds &&
|
|
dto.categoryIds.length > 0
|
|
) {
|
|
whereCondition.categoryId = { in: dto.categoryIds };
|
|
} else if (
|
|
dto.scope === "SPECIFIC" &&
|
|
dto.productIds &&
|
|
dto.productIds.length > 0
|
|
) {
|
|
whereCondition.id = { in: dto.productIds };
|
|
}
|
|
|
|
const products = await this.prisma.product.findMany({
|
|
where: whereCondition,
|
|
select: {
|
|
id: true,
|
|
slug: true,
|
|
artNo: true,
|
|
buyPrice: true,
|
|
priceValue: true,
|
|
wholesalePrice: true,
|
|
},
|
|
});
|
|
|
|
let updatedCount = 0;
|
|
const revalidateSlugs: string[] = [];
|
|
|
|
const computeNewPrice = (currentPrice: number): number => {
|
|
let result = currentPrice;
|
|
if (dto.adjustmentType === "PERCENT") {
|
|
const factor =
|
|
dto.adjustmentDirection === "INCREASE"
|
|
? 1 + adjValue / 100
|
|
: 1 - adjValue / 100;
|
|
result = currentPrice * Math.max(0, factor);
|
|
} else {
|
|
const delta =
|
|
dto.adjustmentDirection === "INCREASE" ? adjValue : -adjValue;
|
|
result = Math.max(0, currentPrice + delta);
|
|
}
|
|
return applyRound
|
|
? applyRounding(result, roundingStep, roundingMode)
|
|
: Math.round(result);
|
|
};
|
|
|
|
for (const prod of products) {
|
|
const updateData: Prisma.ProductUpdateInput = {};
|
|
let changed = false;
|
|
|
|
const currentBuyPrice = Number(prod.buyPrice || 0);
|
|
const currentRetailPrice = Number(prod.priceValue || 0);
|
|
const currentWholesalePrice = Number(prod.wholesalePrice || 0);
|
|
|
|
let newBuyPrice = currentBuyPrice;
|
|
let newRetailPrice = currentRetailPrice;
|
|
let newWholesalePrice = currentWholesalePrice;
|
|
|
|
if (dto.targetField === "BUY" || dto.targetField === "ALL") {
|
|
if (currentBuyPrice > 0) {
|
|
newBuyPrice = computeNewPrice(currentBuyPrice);
|
|
updateData.buyPrice = newBuyPrice;
|
|
changed = true;
|
|
}
|
|
}
|
|
|
|
if (
|
|
dto.targetField === "RETAIL" ||
|
|
dto.targetField === "BOTH_SELLING" ||
|
|
dto.targetField === "ALL"
|
|
) {
|
|
if (currentRetailPrice > 0) {
|
|
newRetailPrice = computeNewPrice(currentRetailPrice);
|
|
updateData.priceValue = newRetailPrice;
|
|
changed = true;
|
|
}
|
|
}
|
|
|
|
if (
|
|
dto.targetField === "WHOLESALE" ||
|
|
dto.targetField === "BOTH_SELLING" ||
|
|
dto.targetField === "ALL"
|
|
) {
|
|
if (currentWholesalePrice > 0) {
|
|
newWholesalePrice = computeNewPrice(currentWholesalePrice);
|
|
updateData.wholesalePrice = newWholesalePrice;
|
|
changed = true;
|
|
}
|
|
}
|
|
|
|
if (changed) {
|
|
if (newBuyPrice > 0) {
|
|
if (newRetailPrice > 0) {
|
|
updateData.marginRetailPercent =
|
|
Math.round(
|
|
((newRetailPrice - newBuyPrice) / newBuyPrice) * 10000,
|
|
) / 100;
|
|
}
|
|
if (newWholesalePrice > 0) {
|
|
updateData.marginWholesalePercent =
|
|
Math.round(
|
|
((newWholesalePrice - newBuyPrice) / newBuyPrice) * 10000,
|
|
) / 100;
|
|
}
|
|
}
|
|
|
|
await this.prisma.product.update({
|
|
where: { id: prod.id },
|
|
data: updateData,
|
|
});
|
|
updatedCount++;
|
|
if (prod.slug) revalidateSlugs.push(prod.slug);
|
|
}
|
|
}
|
|
|
|
if (revalidateSlugs.length > 0) {
|
|
for (const slug of revalidateSlugs.slice(0, 20)) {
|
|
this.revalidationService.revalidateProduct(slug).catch(() => {});
|
|
}
|
|
}
|
|
|
|
return {
|
|
success: true,
|
|
message: `تغییرات قیمت با موفقیت بر روی ${updatedCount} محصول اعمال شد.`,
|
|
updatedCount,
|
|
totalMatched: products.length,
|
|
};
|
|
}
|
|
|
|
async resolveIngredientCards(ingredients: string[]): Promise<
|
|
Array<{
|
|
ingredient: string;
|
|
ingredientCardId: string | null;
|
|
ingredientCardSlug: string | null;
|
|
}>
|
|
> {
|
|
if (!ingredients || ingredients.length === 0) return [];
|
|
const allCards = await this.prisma.ingredient.findMany({
|
|
select: { id: true, slug: true, nameFa: true, nameEn: true },
|
|
});
|
|
|
|
const normalize = (str: string) =>
|
|
str.toLowerCase().replace(/[()]/g, "").replace(/\s+/g, " ").trim();
|
|
|
|
return ingredients.map((rawIng) => {
|
|
const clean = rawIng.trim();
|
|
const norm = normalize(clean);
|
|
|
|
const matchedCard = allCards.find((card) => {
|
|
const cardFaNorm = normalize(card.nameFa);
|
|
const cardEnNorm = normalize(card.nameEn);
|
|
const cardSlugNorm = normalize(card.slug.replace(/-/g, " "));
|
|
|
|
return (
|
|
norm === cardFaNorm ||
|
|
norm === cardEnNorm ||
|
|
norm === cardSlugNorm ||
|
|
norm.includes(cardFaNorm) ||
|
|
cardFaNorm.includes(norm) ||
|
|
norm.includes(cardEnNorm) ||
|
|
cardEnNorm.includes(norm)
|
|
);
|
|
});
|
|
|
|
return {
|
|
ingredient: clean,
|
|
ingredientCardId: matchedCard ? matchedCard.id : null,
|
|
ingredientCardSlug: matchedCard ? matchedCard.slug : null,
|
|
};
|
|
});
|
|
}
|
|
|
|
|
|
async getSymptoms(params?: { page?: number; limit?: number; search?: string }) {
|
|
const page = Math.max(1, Number(params?.page) || 1);
|
|
const limit = Math.max(1, Number(params?.limit) || 20);
|
|
const offset = (page - 1) * limit;
|
|
const search = params?.search?.trim() || '';
|
|
|
|
let items: any[] = [];
|
|
let total = 0;
|
|
|
|
if (search) {
|
|
const searchPattern = `%${search}%`;
|
|
const [listResult, countResult] = await Promise.all([
|
|
this.prisma.$queryRaw<any[]>`
|
|
SELECT
|
|
s.id,
|
|
s.name,
|
|
s.slug,
|
|
s.description,
|
|
s.meta_title as "metaTitle",
|
|
s.meta_description as "metaDescription",
|
|
s.keywords,
|
|
s.icon,
|
|
s.created_at as "createdAt",
|
|
COALESCE(COUNT(ps.product_id), 0)::int as "productsCount"
|
|
FROM symptoms s
|
|
LEFT JOIN product_symptoms ps ON ps.symptom = s.name
|
|
WHERE s.name ILIKE ${searchPattern} OR s.slug ILIKE ${searchPattern}
|
|
GROUP BY s.id, s.name, s.slug, s.description, s.meta_title, s.meta_description, s.keywords, s.icon, s.created_at
|
|
ORDER BY s.name ASC
|
|
LIMIT ${limit} OFFSET ${offset};
|
|
`,
|
|
this.prisma.$queryRaw<any[]>`
|
|
SELECT COUNT(*)::int as total
|
|
FROM symptoms s
|
|
WHERE s.name ILIKE ${searchPattern} OR s.slug ILIKE ${searchPattern};
|
|
`,
|
|
]);
|
|
items = listResult;
|
|
total = countResult[0]?.total || 0;
|
|
} else {
|
|
const [listResult, countResult] = await Promise.all([
|
|
this.prisma.$queryRaw<any[]>`
|
|
SELECT
|
|
s.id,
|
|
s.name,
|
|
s.slug,
|
|
s.description,
|
|
s.meta_title as "metaTitle",
|
|
s.meta_description as "metaDescription",
|
|
s.keywords,
|
|
s.icon,
|
|
s.created_at as "createdAt",
|
|
COALESCE(COUNT(ps.product_id), 0)::int as "productsCount"
|
|
FROM symptoms s
|
|
LEFT JOIN product_symptoms ps ON ps.symptom = s.name
|
|
GROUP BY s.id, s.name, s.slug, s.description, s.meta_title, s.meta_description, s.keywords, s.icon, s.created_at
|
|
ORDER BY s.name ASC
|
|
LIMIT ${limit} OFFSET ${offset};
|
|
`,
|
|
this.prisma.$queryRaw<any[]>`
|
|
SELECT COUNT(*)::int as total
|
|
FROM symptoms s;
|
|
`,
|
|
]);
|
|
items = listResult;
|
|
total = countResult[0]?.total || 0;
|
|
}
|
|
|
|
const lastPage = Math.ceil(total / limit) || 1;
|
|
|
|
return {
|
|
data: items,
|
|
meta: {
|
|
page,
|
|
limit,
|
|
total,
|
|
lastPage,
|
|
},
|
|
};
|
|
}
|
|
|
|
async createSymptom(dto: { name: string; slug?: string; description?: string; metaTitle?: string; metaDescription?: string; keywords?: string }) {
|
|
if (!dto.name?.trim()) throw new BadRequestException('نام علامت الزامی است');
|
|
const name = dto.name.trim();
|
|
const slug = dto.slug?.trim() || name.replace(/\s+/g, '-').toLowerCase();
|
|
|
|
return await this.prisma.$queryRawUnsafe(`
|
|
INSERT INTO symptoms (name, slug, description, meta_title, meta_description, keywords)
|
|
VALUES ($1, $2, $3, $4, $5, $6)
|
|
RETURNING id, name, slug, description, meta_title as "metaTitle", meta_description as "metaDescription", keywords;
|
|
`, name, slug, dto.description || '', dto.metaTitle || '', dto.metaDescription || '', dto.keywords || '');
|
|
}
|
|
|
|
async updateSymptom(id: string, dto: { name?: string; slug?: string; description?: string; metaTitle?: string; metaDescription?: string; keywords?: string }) {
|
|
// 1. Get existing symptom
|
|
const existing = await this.prisma.$queryRawUnsafe<any[]>(`SELECT * FROM symptoms WHERE id = $1::uuid LIMIT 1`, id);
|
|
if (!existing || existing.length === 0) throw new NotFoundException('علامت یافت نشد');
|
|
const oldName = existing[0].name;
|
|
const newName = dto.name?.trim() || oldName;
|
|
const newSlug = dto.slug?.trim() || existing[0].slug;
|
|
|
|
return await this.prisma.$transaction(async (tx) => {
|
|
// Update symptoms table
|
|
const updated = await tx.$queryRawUnsafe(`
|
|
UPDATE symptoms
|
|
SET
|
|
name = $2,
|
|
slug = $3,
|
|
description = $4,
|
|
meta_title = $5,
|
|
meta_description = $6,
|
|
keywords = $7,
|
|
updated_at = CURRENT_TIMESTAMP
|
|
WHERE id = $1::uuid
|
|
RETURNING id, name, slug, description, meta_title as "metaTitle", meta_description as "metaDescription", keywords;
|
|
`, id, newName, newSlug, dto.description ?? existing[0].description, dto.metaTitle ?? existing[0].meta_title, dto.metaDescription ?? existing[0].meta_description, dto.keywords ?? existing[0].keywords);
|
|
|
|
// If name changed, cascade update across product_symptoms & products JSON
|
|
if (oldName !== newName) {
|
|
await tx.$executeRaw`UPDATE product_symptoms SET symptom = ${newName} WHERE symptom = ${oldName};`;
|
|
await tx.$executeRaw`
|
|
UPDATE products
|
|
SET dosage_config = jsonb_set(
|
|
dosage_config,
|
|
'{symptoms}',
|
|
(
|
|
SELECT jsonb_agg(
|
|
CASE
|
|
WHEN elem::text = to_jsonb(${oldName}::text)::text THEN to_jsonb(${newName}::text)
|
|
ELSE elem
|
|
END
|
|
)
|
|
FROM jsonb_array_elements(dosage_config->'symptoms') AS elem
|
|
)
|
|
)
|
|
WHERE dosage_config ? 'symptoms'
|
|
AND dosage_config->'symptoms' @> to_jsonb(${oldName}::text);
|
|
`;
|
|
}
|
|
|
|
return updated;
|
|
});
|
|
}
|
|
|
|
async deleteSymptom(id: string) {
|
|
const existing = await this.prisma.$queryRawUnsafe<any[]>(`SELECT * FROM symptoms WHERE id = $1::uuid LIMIT 1`, id);
|
|
if (!existing || existing.length === 0) throw new NotFoundException('علامت یافت نشد');
|
|
const name = existing[0].name;
|
|
|
|
return await this.prisma.$transaction(async (tx) => {
|
|
// Delete join links
|
|
await tx.$executeRaw`DELETE FROM product_symptoms WHERE symptom = ${name};`;
|
|
// Delete symptom row
|
|
await tx.$queryRawUnsafe(`DELETE FROM symptoms WHERE id = $1::uuid;`, id);
|
|
return { success: true, message: `علامت «${name}» با موفقیت حذف شد` };
|
|
});
|
|
}
|
|
|
|
}
|