- Backend (NestJS): 82 suites, 641 tests passing; 0 ESLint errors; 0 tsc errors. Hardened SSL cert/key matching, SSRF IP pinning, and eBank validation. - Admin Panel (Vite/React): 48 suites, 300 tests passing; 0 ESLint errors; 0 tsc errors. Full coverage across all pages and settings. - Storefront (Next.js): 62 suites, 368 tests passing; 0 ESLint errors; 0 tsc errors. - Fixed unmount lifecycle guards, promise error handling, and component edge cases.
1390 lines
43 KiB
TypeScript
1390 lines
43 KiB
TypeScript
import { Injectable, Logger } from "@nestjs/common";
|
|
import * as https from "https";
|
|
import { PrismaService } from "../../prisma/prisma.service";
|
|
import { Prisma } from "@prisma/client";
|
|
import {
|
|
DEFAULT_SMS_RULES,
|
|
SMS_EVENT_DEFINITIONS,
|
|
SmsEventDefinition,
|
|
} from "./sms-events.constants";
|
|
|
|
export interface SendPatternSmsOptions {
|
|
to: string;
|
|
bodyId: number; // MeliPayamak Shared Pattern Body ID
|
|
args: string[]; // Dynamic variables inside pattern
|
|
type?: string; // OTP, ORDER_CONFIRMATION, SHIPPING_TRACKING, B2B_NOTIFICATION, PET_CARE_REMINDER, TEST, GENERIC
|
|
}
|
|
|
|
export interface SmsRule {
|
|
id: string;
|
|
title: string;
|
|
event: string; // ORDER_PAID, ORDER_CREATED, ORDER_SHIPPED, B2B_SUBMITTED, CONTACT_SUBMITTED, OTP
|
|
enabled: boolean;
|
|
recipientType: "customer" | "admin" | "custom";
|
|
customPhone?: string;
|
|
patternId: number;
|
|
variables: string[]; // Ordered parameter keys: e.g. ['orderNumber', 'recipientName', 'address']
|
|
description?: string;
|
|
}
|
|
|
|
export interface SmsConfig {
|
|
enabled: boolean;
|
|
username: string;
|
|
password: string;
|
|
fromNumber?: string;
|
|
adminPhone?: string;
|
|
otpBodyId: number;
|
|
orderBodyId: number;
|
|
shippingBodyId: number;
|
|
b2bBodyId: number;
|
|
petCareBodyId: number;
|
|
rules?: SmsRule[];
|
|
}
|
|
|
|
export interface MeliPayamakPattern {
|
|
id: number;
|
|
title: string;
|
|
body: string;
|
|
status: number; // 0 = Pending, 1 = Approved, 2 = Needs Edit
|
|
statusText?: string;
|
|
assignedTo?: string[];
|
|
}
|
|
|
|
export class SmsLogQuery {
|
|
page?: number;
|
|
limit?: number;
|
|
search?: string;
|
|
type?: string;
|
|
status?: string;
|
|
sortBy?: string;
|
|
sortOrder?: "asc" | "desc";
|
|
}
|
|
|
|
export interface MeliPayamakResponse {
|
|
Value?: number;
|
|
RetStatus?: number;
|
|
StrRetStatus?: string;
|
|
}
|
|
|
|
@Injectable()
|
|
export class SmsService {
|
|
private readonly logger = new Logger(SmsService.name);
|
|
|
|
constructor(private readonly prisma: PrismaService) {}
|
|
|
|
/**
|
|
* Get active SMS configuration from database (fallback to .env)
|
|
*/
|
|
async getSmsConfig(): Promise<SmsConfig> {
|
|
try {
|
|
const setting = await this.prisma.setting.findFirst({
|
|
where: { category: "sms" },
|
|
});
|
|
const dbConfig = (setting?.value as Record<string, unknown>) || {};
|
|
|
|
return {
|
|
enabled:
|
|
dbConfig.enabled !== undefined ? Boolean(dbConfig.enabled) : true,
|
|
username:
|
|
typeof dbConfig.username === "string" && dbConfig.username
|
|
? dbConfig.username
|
|
: process.env.MELIPAYAMAK_USERNAME || "9364100228",
|
|
password:
|
|
typeof dbConfig.password === "string" && dbConfig.password
|
|
? dbConfig.password
|
|
: process.env.MELIPAYAMAK_PASSWORD || "",
|
|
fromNumber:
|
|
typeof dbConfig.fromNumber === "string" && dbConfig.fromNumber
|
|
? dbConfig.fromNumber
|
|
: process.env.MELIPAYAMAK_FROM_NUMBER || "",
|
|
adminPhone:
|
|
typeof dbConfig.adminPhone === "string" && dbConfig.adminPhone
|
|
? dbConfig.adminPhone
|
|
: process.env.ADMIN_MOBILE || "09364100228",
|
|
otpBodyId: Number(
|
|
dbConfig.otpBodyId || process.env.MELIPAYAMAK_OTP_BODY_ID || "508079",
|
|
),
|
|
orderBodyId: Number(
|
|
dbConfig.orderBodyId ||
|
|
process.env.MELIPAYAMAK_ORDER_BODY_ID ||
|
|
"508081",
|
|
),
|
|
shippingBodyId: Number(
|
|
dbConfig.shippingBodyId ||
|
|
process.env.MELIPAYAMAK_SHIPPING_BODY_ID ||
|
|
"508082",
|
|
),
|
|
b2bBodyId: Number(
|
|
dbConfig.b2bBodyId || process.env.MELIPAYAMAK_B2B_BODY_ID || "508083",
|
|
),
|
|
petCareBodyId: Number(
|
|
dbConfig.petCareBodyId ||
|
|
process.env.MELIPAYAMAK_PET_CARE_BODY_ID ||
|
|
"0",
|
|
),
|
|
rules: Array.isArray(dbConfig.rules)
|
|
? (dbConfig.rules as SmsRule[])
|
|
: DEFAULT_SMS_RULES,
|
|
};
|
|
} catch {
|
|
return {
|
|
enabled: true,
|
|
username: process.env.MELIPAYAMAK_USERNAME || "9364100228",
|
|
password: process.env.MELIPAYAMAK_PASSWORD || "",
|
|
fromNumber: process.env.MELIPAYAMAK_FROM_NUMBER || "",
|
|
adminPhone: process.env.ADMIN_MOBILE || "09364100228",
|
|
otpBodyId: Number(process.env.MELIPAYAMAK_OTP_BODY_ID || "508079"),
|
|
orderBodyId: Number(process.env.MELIPAYAMAK_ORDER_BODY_ID || "508081"),
|
|
shippingBodyId: Number(
|
|
process.env.MELIPAYAMAK_SHIPPING_BODY_ID || "508082",
|
|
),
|
|
b2bBodyId: Number(process.env.MELIPAYAMAK_B2B_BODY_ID || "508083"),
|
|
petCareBodyId: Number(process.env.MELIPAYAMAK_PET_CARE_BODY_ID || "0"),
|
|
rules: DEFAULT_SMS_RULES,
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Dispatch dynamic SMS notification rules for an event
|
|
*/
|
|
async triggerEvent(
|
|
event: string,
|
|
data: Record<string, any>,
|
|
): Promise<boolean> {
|
|
try {
|
|
const config = await this.getSmsConfig();
|
|
if (!config.enabled) {
|
|
this.logger.log(
|
|
`[SMS Trigger] SMS gateway disabled. Skipping event ${event}`,
|
|
);
|
|
return false;
|
|
}
|
|
|
|
const activeRules = (config.rules || []).filter(
|
|
(rule) =>
|
|
rule.enabled && rule.event === event && Number(rule.patternId) > 0,
|
|
);
|
|
|
|
if (activeRules.length > 0) {
|
|
this.logger.log(
|
|
`[SMS Trigger] Found ${activeRules.length} active rule(s) for event ${event}`,
|
|
);
|
|
|
|
for (const rule of activeRules) {
|
|
const phones: string[] = [];
|
|
|
|
if (rule.recipientType === "customer") {
|
|
const customerPhone =
|
|
data.customerPhone ||
|
|
data.phone ||
|
|
data.mobile ||
|
|
data.recipientPhone;
|
|
if (customerPhone) phones.push(String(customerPhone).trim());
|
|
} else if (rule.recipientType === "admin") {
|
|
const rawAdminPhones =
|
|
config.adminPhone ||
|
|
process.env.ADMIN_MOBILE ||
|
|
process.env.ADMIN_MOBILE_ALERT ||
|
|
"";
|
|
const list = rawAdminPhones
|
|
.split(/[,;\s]+/)
|
|
.map((p) => p.trim())
|
|
.filter(Boolean);
|
|
if (list.length > 0) {
|
|
phones.push(...list);
|
|
}
|
|
} else if (rule.recipientType === "custom" && rule.customPhone) {
|
|
const list = rule.customPhone
|
|
.split(/[,;\s]+/)
|
|
.map((p) => p.trim())
|
|
.filter(Boolean);
|
|
if (list.length > 0) {
|
|
phones.push(...list);
|
|
}
|
|
}
|
|
|
|
if (phones.length === 0) {
|
|
this.logger.warn(
|
|
`[SMS Trigger] Rule "${rule.title}" has no recipient phone number.`,
|
|
);
|
|
continue;
|
|
}
|
|
|
|
const args: string[] = (rule.variables || []).map((varKey) => {
|
|
const val = data[varKey];
|
|
if (val === undefined || val === null) return "";
|
|
return String(val).trim();
|
|
});
|
|
|
|
for (const targetPhone of phones) {
|
|
this.sendPatternSms({
|
|
to: targetPhone,
|
|
bodyId: Number(rule.patternId),
|
|
args,
|
|
type: `${event}_${rule.recipientType.toUpperCase()}`,
|
|
}).catch((err) => {
|
|
this.logger.error(
|
|
`[SMS Trigger Error] Failed to execute rule "${rule.title}" to ${targetPhone}: ${err}`,
|
|
);
|
|
});
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Legacy fallback when no rules are configured for this event
|
|
this.logger.log(
|
|
`[SMS Trigger] No custom rules configured for ${event}. Using standard fallback.`,
|
|
);
|
|
if (event === "ORDER_PAID" || event === "ORDER_CREATED") {
|
|
const phone = data.customerPhone || data.phone || data.mobile;
|
|
if (phone && config.orderBodyId) {
|
|
await this.sendOrderConfirmation(
|
|
phone,
|
|
data.customerName || "مشتری",
|
|
data.orderNumber || "",
|
|
data.amount || "",
|
|
);
|
|
}
|
|
} else if (event === "ORDER_SHIPPED") {
|
|
const phone = data.customerPhone || data.phone || data.mobile;
|
|
if (phone && config.shippingBodyId) {
|
|
await this.sendShippingNotification(
|
|
phone,
|
|
data.orderNumber || "",
|
|
data.trackingCode || "",
|
|
);
|
|
}
|
|
} else if (event === "B2B_SUBMITTED") {
|
|
const phone = data.applicantPhone || data.phone;
|
|
if (phone && config.b2bBodyId) {
|
|
await this.sendB2bNotification(phone, data.applicantName || "");
|
|
}
|
|
}
|
|
return true;
|
|
} catch (err: any) {
|
|
this.logger.error(
|
|
`[SMS Trigger Exception] Error triggering event ${event}: ${err?.message || err}`,
|
|
);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get all supported SMS events and their dynamic variables
|
|
*/
|
|
getEventDefinitions(): SmsEventDefinition[] {
|
|
return SMS_EVENT_DEFINITIONS;
|
|
}
|
|
|
|
/**
|
|
* Test an SMS rule with sample/mock event data
|
|
*/
|
|
async testRule(
|
|
rule: SmsRule,
|
|
testPhone?: string,
|
|
): Promise<{
|
|
success: boolean;
|
|
message: string;
|
|
targetPhone?: string;
|
|
args?: string[];
|
|
rawResponse?: any;
|
|
}> {
|
|
const config = await this.getSmsConfig();
|
|
if (!config.username || !config.password) {
|
|
return {
|
|
success: false,
|
|
message:
|
|
"مشخصات نام کاربری و رمز عبور سامانه ملی پیامک تنظیم نشده است.",
|
|
};
|
|
}
|
|
|
|
if (!rule.patternId) {
|
|
return {
|
|
success: false,
|
|
message: "کد پترن (Body ID) برای این سناریو مشخص نشده است.",
|
|
};
|
|
}
|
|
|
|
// Determine target recipient phone
|
|
let phone = testPhone ? testPhone.trim() : "";
|
|
if (!phone) {
|
|
if (rule.recipientType === "customer") {
|
|
phone = config.adminPhone || "09123456789";
|
|
} else if (rule.recipientType === "admin") {
|
|
phone = config.adminPhone || process.env.ADMIN_MOBILE || "09123456789";
|
|
} else if (rule.recipientType === "custom") {
|
|
phone = (rule.customPhone || "").split(/[,;\s]+/)[0] || "";
|
|
}
|
|
}
|
|
|
|
if (!phone) {
|
|
return {
|
|
success: false,
|
|
message:
|
|
"شماره گیرنده جهت ارسال تست یافت نشد. لطفاً یک شماره موبایل وارد کنید.",
|
|
};
|
|
}
|
|
|
|
// Resolve sample values for variables
|
|
const eventDef = SMS_EVENT_DEFINITIONS.find((d) => d.event === rule.event);
|
|
const sampleData: Record<string, string> = {};
|
|
if (eventDef) {
|
|
for (const v of eventDef.variables) {
|
|
sampleData[v.key] = v.sample;
|
|
}
|
|
}
|
|
|
|
const args = (rule.variables || []).map((varKey) => {
|
|
return sampleData[varKey] || varKey;
|
|
});
|
|
|
|
const result = await this.testSms(phone, Number(rule.patternId), args);
|
|
return {
|
|
success: result.success,
|
|
message: result.message,
|
|
targetPhone: phone,
|
|
args,
|
|
rawResponse: result.rawResponse,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Helper HTTP POST request to Payamak-Panel ASMX endpoints
|
|
*/
|
|
private async postAsmx(
|
|
endpoint: string,
|
|
params: Record<string, string | number>,
|
|
): Promise<string> {
|
|
const postData = Object.entries(params)
|
|
.map(
|
|
([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`,
|
|
)
|
|
.join("&");
|
|
|
|
return new Promise((resolve, reject) => {
|
|
const req = https.request(
|
|
`https://api.payamak-panel.com/post/SharedService.asmx/${endpoint}`,
|
|
{
|
|
method: "POST",
|
|
headers: {
|
|
"Content-Type": "application/x-www-form-urlencoded",
|
|
"Content-Length": Buffer.byteLength(postData),
|
|
},
|
|
},
|
|
(res) => {
|
|
let data = "";
|
|
res.on("data", (chunk: Buffer | string) => (data += String(chunk)));
|
|
res.on("end", () => resolve(data));
|
|
},
|
|
);
|
|
|
|
req.on("error", (err: Error) => reject(err));
|
|
req.write(postData);
|
|
req.end();
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Helper to write an SMS Log to PostgreSQL safely
|
|
*/
|
|
private async recordLog(entry: {
|
|
receptor: string;
|
|
type: string;
|
|
patternId?: number;
|
|
args?: string[];
|
|
messageText?: string;
|
|
status: string;
|
|
recId?: string;
|
|
errorMessage?: string;
|
|
}): Promise<void> {
|
|
try {
|
|
await this.prisma.smsLog.create({
|
|
data: {
|
|
receptor: entry.receptor,
|
|
type: entry.type || "GENERIC",
|
|
patternId: entry.patternId || null,
|
|
args: entry.args || [],
|
|
messageText: entry.messageText || null,
|
|
status: entry.status,
|
|
recId: entry.recId ? String(entry.recId) : null,
|
|
errorMessage: entry.errorMessage || null,
|
|
},
|
|
});
|
|
} catch (err: unknown) {
|
|
const msg = err instanceof Error ? err.message : String(err);
|
|
this.logger.error(`[SMS Log Save Failed]: ${msg}`);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Query paginated SMS Logs with Search, Filter and Sorting
|
|
*/
|
|
async getSmsLogs(query: SmsLogQuery = {}) {
|
|
const page = Math.max(1, Number(query.page) || 1);
|
|
const limit = Math.max(1, Math.min(100, Number(query.limit) || 15));
|
|
const skip = (page - 1) * limit;
|
|
|
|
const where: Prisma.SmsLogWhereInput = {};
|
|
|
|
if (query.search) {
|
|
const s = query.search.trim();
|
|
where.OR = [
|
|
{ receptor: { contains: s, mode: "insensitive" } },
|
|
{ recId: { contains: s, mode: "insensitive" } },
|
|
{ errorMessage: { contains: s, mode: "insensitive" } },
|
|
];
|
|
}
|
|
|
|
if (query.type && query.type !== "ALL") {
|
|
where.type = query.type;
|
|
}
|
|
|
|
if (query.status && query.status !== "ALL") {
|
|
where.status = query.status;
|
|
}
|
|
|
|
const sortField = query.sortBy || "createdAt";
|
|
const sortOrder = query.sortOrder === "asc" ? "asc" : "desc";
|
|
|
|
const [logs, total, totalSuccess, totalFailed] = await Promise.all([
|
|
this.prisma.smsLog.findMany({
|
|
where,
|
|
skip,
|
|
take: limit,
|
|
orderBy: { [sortField]: sortOrder },
|
|
}),
|
|
this.prisma.smsLog.count({ where }),
|
|
this.prisma.smsLog.count({ where: { status: "SUCCESS" } }),
|
|
this.prisma.smsLog.count({ where: { status: "FAILED" } }),
|
|
]);
|
|
|
|
return {
|
|
logs,
|
|
total,
|
|
page,
|
|
limit,
|
|
totalPages: Math.ceil(total / limit),
|
|
stats: {
|
|
total,
|
|
success: totalSuccess,
|
|
failed: totalFailed,
|
|
successRate: total > 0 ? Math.round((totalSuccess / total) * 100) : 100,
|
|
},
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Delete specific SMS log entry
|
|
*/
|
|
async deleteSmsLog(id: string) {
|
|
return this.prisma.smsLog.delete({ where: { id } });
|
|
}
|
|
|
|
/**
|
|
* Clear all SMS logs
|
|
*/
|
|
async clearAllSmsLogs() {
|
|
return this.prisma.smsLog.deleteMany();
|
|
}
|
|
|
|
/**
|
|
* Parse XML response for GetSharedServiceBody into structured pattern array
|
|
*/
|
|
private parsePatternsXml(xml: string): MeliPayamakPattern[] {
|
|
const patterns: MeliPayamakPattern[] = [];
|
|
// MeliPayamak uses <ShareServiceBody> and child tags <BodyID>, <Title>, <Body>, <BodyStatus>
|
|
// We match both <ShareServiceBody> and <SharedServiceBody> for backwards/cross compatibility
|
|
const itemRegex =
|
|
/<(?:Share|Shared)ServiceBody>([\s\S]*?)<\/(?:Share|Shared)ServiceBody>/gi;
|
|
let match: RegExpExecArray | null;
|
|
|
|
while ((match = itemRegex.exec(xml)) !== null) {
|
|
const block = match[1];
|
|
const idMatch = block.match(/<(?:BodyID|Id)>(\d+)<\/(?:BodyID|Id)>/i);
|
|
const titleMatch = block.match(/<Title>([\s\S]*?)<\/Title>/i);
|
|
const bodyMatch = block.match(/<Body>([\s\S]*?)<\/Body>/i);
|
|
const statusMatch = block.match(
|
|
/<(?:BodyStatus|Status)>(-?\d+)<\/(?:BodyStatus|Status)>/i,
|
|
);
|
|
|
|
if (idMatch) {
|
|
const id = parseInt(idMatch[1], 10);
|
|
const title = (titleMatch ? titleMatch[1] : "")
|
|
.replace(/</g, "<")
|
|
.replace(/>/g, ">")
|
|
.replace(/&/g, "&")
|
|
.trim();
|
|
const body = (bodyMatch ? bodyMatch[1] : "")
|
|
.replace(/</g, "<")
|
|
.replace(/>/g, ">")
|
|
.replace(/&/g, "&")
|
|
.trim();
|
|
const status = statusMatch ? parseInt(statusMatch[1], 10) : 0;
|
|
|
|
let statusText = "در انتظار تایید";
|
|
if (status === 1) statusText = "تایید شده";
|
|
else if (status === 2 || status === -1) statusText = "نیاز به ویرایش";
|
|
|
|
patterns.push({ id, title, body, status, statusText });
|
|
}
|
|
}
|
|
|
|
return patterns;
|
|
}
|
|
|
|
/**
|
|
* Fetch remaining SMS balance/credit (in Rials or count) from MeliPayamak
|
|
*/
|
|
async getCredit(): Promise<{
|
|
success: boolean;
|
|
credit: number;
|
|
message?: string;
|
|
}> {
|
|
const config = await this.getSmsConfig();
|
|
|
|
if (!config.username || !config.password) {
|
|
return {
|
|
success: false,
|
|
credit: 0,
|
|
message: "نام کاربری و کلمه عبور ملی پیامک تنظیم نشده است.",
|
|
};
|
|
}
|
|
|
|
return new Promise((resolve) => {
|
|
const payload = JSON.stringify({
|
|
username: config.username,
|
|
password: config.password,
|
|
});
|
|
|
|
const req = https.request(
|
|
"https://rest.payamak-panel.com/api/SendSMS/GetCredit",
|
|
{
|
|
method: "POST",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
"Content-Length": Buffer.byteLength(payload),
|
|
},
|
|
},
|
|
(res) => {
|
|
let data = "";
|
|
res.on("data", (chunk: Buffer | string) => (data += String(chunk)));
|
|
res.on("end", () => {
|
|
try {
|
|
const json = JSON.parse(data);
|
|
const val = Number(json.Value ?? json.value ?? 0);
|
|
resolve({
|
|
success: true,
|
|
credit: val,
|
|
message: `اعتبار با موفقیت دریافت شد: ${val}`,
|
|
});
|
|
} catch (err: unknown) {
|
|
const msg = err instanceof Error ? err.message : String(err);
|
|
resolve({
|
|
success: false,
|
|
credit: 0,
|
|
message: `خطای دریافت اعتبار: ${data || msg}`,
|
|
});
|
|
}
|
|
});
|
|
},
|
|
);
|
|
|
|
req.on("error", (err: Error) => {
|
|
resolve({
|
|
success: false,
|
|
credit: 0,
|
|
message: `خطای برقراری ارتباط با وبسرویس ملی پیامک: ${err.message}`,
|
|
});
|
|
});
|
|
|
|
req.write(payload);
|
|
req.end();
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Render interpolated message text using pattern body template and arguments
|
|
*/
|
|
async renderPatternMessage(
|
|
patternId?: number | null,
|
|
args: string[] = [],
|
|
): Promise<string> {
|
|
if (!patternId) {
|
|
return args.join(" ");
|
|
}
|
|
|
|
try {
|
|
const patterns = await this.getPatterns();
|
|
const target = patterns.find((p) => p.id === patternId);
|
|
if (!target || !target.body) {
|
|
return args.length > 0
|
|
? `الگو ${patternId} با مقادیر: ${args.join(" ، ")}`
|
|
: `الگو ${patternId}`;
|
|
}
|
|
|
|
let rendered = target.body;
|
|
args.forEach((val, idx) => {
|
|
const regex = new RegExp(`\\{${idx}\\}`, "g");
|
|
rendered = rendered.replace(regex, val || "");
|
|
});
|
|
return rendered;
|
|
} catch {
|
|
return args.length > 0
|
|
? `الگو ${patternId} با مقادیر: ${args.join(" ، ")}`
|
|
: `الگو ${patternId}`;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Fetch all registered patterns from MeliPayamak (with local cache sync)
|
|
*/
|
|
async getPatterns(): Promise<MeliPayamakPattern[]> {
|
|
const config = await this.getSmsConfig();
|
|
|
|
let remotePatterns: MeliPayamakPattern[] = [];
|
|
if (config.username && config.password) {
|
|
try {
|
|
const rawXml = await this.postAsmx("GetSharedServiceBody", {
|
|
username: config.username,
|
|
password: config.password,
|
|
});
|
|
remotePatterns = this.parsePatternsXml(rawXml);
|
|
if (remotePatterns.length > 0) {
|
|
// Cache patterns asynchronously in database
|
|
this.prisma.setting
|
|
.upsert({
|
|
where: { key: "sms_patterns_cache" },
|
|
update: { value: remotePatterns as any },
|
|
create: {
|
|
key: "sms_patterns_cache",
|
|
category: "sms_patterns",
|
|
value: remotePatterns as any,
|
|
},
|
|
})
|
|
.catch((err) => {
|
|
this.logger.warn(`Failed to cache SMS patterns: ${err.message}`);
|
|
});
|
|
}
|
|
} catch (err: unknown) {
|
|
const msg = err instanceof Error ? err.message : String(err);
|
|
this.logger.warn(
|
|
`[SMS Patterns] Remote fetch failed: ${msg}. Using stored patterns.`,
|
|
);
|
|
}
|
|
}
|
|
|
|
// Load cached patterns from settings table
|
|
const storedSetting = await this.prisma.setting.findFirst({
|
|
where: {
|
|
category: "sms_patterns",
|
|
key: { in: ["sms_patterns_cache", "sms_patterns_config"] },
|
|
},
|
|
orderBy: { updatedAt: "desc" },
|
|
});
|
|
const cachedPatterns: MeliPayamakPattern[] = Array.isArray(
|
|
storedSetting?.value,
|
|
)
|
|
? (storedSetting.value as unknown as MeliPayamakPattern[])
|
|
: [];
|
|
|
|
// Prioritize remote patterns, then cached patterns, then fallback defaults only if completely empty
|
|
const map = new Map<number, MeliPayamakPattern>();
|
|
|
|
// 1. If we have remote patterns, use them
|
|
for (const rp of remotePatterns) {
|
|
if (rp && rp.id) {
|
|
map.set(rp.id, { ...rp });
|
|
}
|
|
}
|
|
|
|
// 2. If remote returned empty or offline, use cached patterns
|
|
if (map.size === 0) {
|
|
for (const cp of cachedPatterns) {
|
|
if (cp && cp.id) {
|
|
map.set(cp.id, { ...cp });
|
|
}
|
|
}
|
|
}
|
|
|
|
// 3. Only if map is still completely empty (brand new install / unconfigured account), provide fallback defaults
|
|
if (map.size === 0) {
|
|
const defaultConfigs: Array<{
|
|
id: number;
|
|
title: string;
|
|
body: string;
|
|
}> = [
|
|
{
|
|
id: config.otpBodyId,
|
|
title: "کد تایید ورود و ثبتنام (OTP)",
|
|
body: "کد تایید ورود به کنینا ایران: {0} میباشد. @canina.ir #{0}",
|
|
},
|
|
{
|
|
id: config.orderBodyId,
|
|
title: "تایید و ثبت فاکتور سفارش",
|
|
body: "{0} عزیز ، سفارش شما به شماره {1} به مبلغ {2} با موفقیت ثبت شد.\nکنینا ایران",
|
|
},
|
|
{
|
|
id: config.shippingBodyId,
|
|
title: "ارسال کد رهگیری پستی",
|
|
body: "مرسوله سفارش {0} با کد رهگیری پستی {1} ارسال شد.",
|
|
},
|
|
{
|
|
id: config.b2bBodyId,
|
|
title: "اطلاعرسانی درخواست B2B",
|
|
body: "همکار گرامی {0} درخواست شما دریافت شد.",
|
|
},
|
|
];
|
|
|
|
for (const d of defaultConfigs) {
|
|
if (d.id > 0) {
|
|
map.set(d.id, {
|
|
id: d.id,
|
|
title: d.title,
|
|
body: d.body,
|
|
status: 1,
|
|
statusText: "تایید شده",
|
|
assignedTo: [],
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
// Bind current scenario triggers and system assignments
|
|
const result = Array.from(map.values()).map((p) => {
|
|
const assigned: string[] = [];
|
|
|
|
// Check dynamic scenario rules (Primary Assignment)
|
|
if (Array.isArray(config.rules)) {
|
|
for (const r of config.rules) {
|
|
if (Number(r.patternId) === p.id && r.enabled) {
|
|
const ruleTag = `سناریو: ${r.title}`;
|
|
if (!assigned.includes(ruleTag)) {
|
|
assigned.push(ruleTag);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check legacy default bindings
|
|
if (
|
|
p.id === config.otpBodyId &&
|
|
!assigned.some((a) => a.includes("OTP"))
|
|
) {
|
|
assigned.push("کد تایید OTP");
|
|
}
|
|
if (
|
|
p.id === config.orderBodyId &&
|
|
!assigned.some((a) => a.includes("سفارش"))
|
|
) {
|
|
assigned.push("پترن پیشفرض سفارش");
|
|
}
|
|
if (
|
|
p.id === config.shippingBodyId &&
|
|
!assigned.some((a) => a.includes("پست"))
|
|
) {
|
|
assigned.push("پترن پیشفرض پست");
|
|
}
|
|
if (
|
|
p.id === config.b2bBodyId &&
|
|
!assigned.some((a) => a.includes("B2B"))
|
|
) {
|
|
assigned.push("پترن پیشفرض B2B");
|
|
}
|
|
if (
|
|
p.id === config.petCareBodyId &&
|
|
!assigned.some((a) => a.includes("پت"))
|
|
) {
|
|
assigned.push("پترن پیشفرض پرونده پت");
|
|
}
|
|
|
|
return { ...p, assignedTo: assigned };
|
|
});
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Add a new pattern to MeliPayamak
|
|
*/
|
|
async addPattern(
|
|
title: string,
|
|
body: string,
|
|
blackListId: number = 0,
|
|
): Promise<{ success: boolean; bodyId?: number; message: string }> {
|
|
const config = await this.getSmsConfig();
|
|
|
|
if (!config.username || !config.password) {
|
|
return {
|
|
success: false,
|
|
message: "مشخصات نام کاربری و رمز عبور سامانه پیامک تنظیم نشده است.",
|
|
};
|
|
}
|
|
|
|
try {
|
|
const rawXml = await this.postAsmx("SharedServiceBodyAdd", {
|
|
username: config.username,
|
|
password: config.password,
|
|
title,
|
|
body,
|
|
blackListId,
|
|
});
|
|
|
|
const match =
|
|
rawXml.match(/<int.*?>(-?\d+)<\/int>/i) || rawXml.match(/>(-?\d+)</);
|
|
const code = match ? parseInt(match[1], 10) : 0;
|
|
|
|
if (code > 0) {
|
|
await this.saveLocalPattern({
|
|
id: code,
|
|
title,
|
|
body,
|
|
status: 0,
|
|
statusText: "در انتظار تایید",
|
|
});
|
|
|
|
return {
|
|
success: true,
|
|
bodyId: code,
|
|
message: `الگو با موفقیت ثبت شد و شناسه اختصاصی ${code} دریافت گردید. (وضعیت: در انتظار تایید ناظر)`,
|
|
};
|
|
} else if (code === 0) {
|
|
return {
|
|
success: false,
|
|
message: "نام کاربری یا کلمه عبور ملی پیامک اشتباه است.",
|
|
};
|
|
} else if (code === -2) {
|
|
return {
|
|
success: false,
|
|
message: "شناسه لیست سیاه ویژه اشتباه است.",
|
|
};
|
|
} else {
|
|
return {
|
|
success: false,
|
|
message: `خطا در ثبت پترن با کد پاسخ: ${code}`,
|
|
};
|
|
}
|
|
} catch (err: unknown) {
|
|
const msg = err instanceof Error ? err.message : String(err);
|
|
const generatedId = Math.floor(500000 + Math.random() * 90000);
|
|
await this.saveLocalPattern({
|
|
id: generatedId,
|
|
title,
|
|
body,
|
|
status: 0,
|
|
statusText: "ثبت محلی (در انتظار اتصال سرور)",
|
|
});
|
|
|
|
return {
|
|
success: true,
|
|
bodyId: generatedId,
|
|
message: `الگو به صورت محلی با شناسه موقت ${generatedId} ذخیره شد (${msg}).`,
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Edit an existing pattern in MeliPayamak
|
|
*/
|
|
async editPattern(
|
|
bodyId: number,
|
|
body: string,
|
|
): Promise<{ success: boolean; message: string }> {
|
|
const config = await this.getSmsConfig();
|
|
|
|
if (!config.username || !config.password) {
|
|
return {
|
|
success: false,
|
|
message: "مشخصات نام کاربری و رمز عبور سامانه پیامک تنظیم نشده است.",
|
|
};
|
|
}
|
|
|
|
try {
|
|
const rawXml = await this.postAsmx("SharedServiceBodyEdit", {
|
|
username: config.username,
|
|
password: config.password,
|
|
bodyId,
|
|
body,
|
|
});
|
|
|
|
const match =
|
|
rawXml.match(/<int.*?>(-?\d+)<\/int>/i) || rawXml.match(/>(-?\d+)</);
|
|
const code = match ? parseInt(match[1], 10) : 0;
|
|
|
|
if (code === 1) {
|
|
await this.updateLocalPattern(bodyId, body);
|
|
return {
|
|
success: true,
|
|
message:
|
|
"ویرایش الگو با موفقیت انجام شد و منتظر تایید مجدد ناظر میباشد.",
|
|
};
|
|
} else if (code === -1) {
|
|
await this.updateLocalPattern(bodyId, body);
|
|
return {
|
|
success: true,
|
|
message:
|
|
"متن الگو در سیستم بروز شد (توجه: فقط الگوهای در وضعیت نیاز به ویرایش در وبسرویس اصلاح میشوند).",
|
|
};
|
|
} else {
|
|
return {
|
|
success: false,
|
|
message: `خطا در ویرایش الگو با کد پاسخ: ${code}`,
|
|
};
|
|
}
|
|
} catch (err: unknown) {
|
|
const msg = err instanceof Error ? err.message : String(err);
|
|
await this.updateLocalPattern(bodyId, body);
|
|
return {
|
|
success: true,
|
|
message: `متن الگو در دیتابیس داخلی بروز شد (${msg}).`,
|
|
};
|
|
}
|
|
}
|
|
|
|
private async saveLocalPattern(pattern: MeliPayamakPattern) {
|
|
try {
|
|
const setting = await this.prisma.setting.findFirst({
|
|
where: { category: "sms_patterns" },
|
|
});
|
|
const list: MeliPayamakPattern[] = Array.isArray(setting?.value)
|
|
? (setting.value as unknown as MeliPayamakPattern[])
|
|
: [];
|
|
const updated = [pattern, ...list.filter((p) => p.id !== pattern.id)];
|
|
|
|
await this.prisma.setting.upsert({
|
|
where: { key: "sms_patterns_config" },
|
|
update: {
|
|
category: "sms_patterns",
|
|
value: updated as unknown as Prisma.InputJsonValue,
|
|
},
|
|
create: {
|
|
key: "sms_patterns_config",
|
|
category: "sms_patterns",
|
|
value: updated as unknown as Prisma.InputJsonValue,
|
|
},
|
|
});
|
|
} catch (err: unknown) {
|
|
const msg = err instanceof Error ? err.message : String(err);
|
|
this.logger.error(`Failed to save local pattern: ${msg}`);
|
|
}
|
|
}
|
|
|
|
private async updateLocalPattern(bodyId: number, newBody: string) {
|
|
try {
|
|
const setting = await this.prisma.setting.findFirst({
|
|
where: { category: "sms_patterns" },
|
|
});
|
|
const list: MeliPayamakPattern[] = Array.isArray(setting?.value)
|
|
? (setting.value as unknown as MeliPayamakPattern[])
|
|
: [];
|
|
const updated = list.map((p) =>
|
|
p.id === bodyId
|
|
? {
|
|
...p,
|
|
body: newBody,
|
|
status: 0,
|
|
statusText: "در انتظار تایید",
|
|
}
|
|
: p,
|
|
);
|
|
|
|
await this.prisma.setting.upsert({
|
|
where: { key: "sms_patterns_config" },
|
|
update: {
|
|
category: "sms_patterns",
|
|
value: updated as unknown as Prisma.InputJsonValue,
|
|
},
|
|
create: {
|
|
key: "sms_patterns_config",
|
|
category: "sms_patterns",
|
|
value: updated as unknown as Prisma.InputJsonValue,
|
|
},
|
|
});
|
|
} catch (err: unknown) {
|
|
const msg = err instanceof Error ? err.message : String(err);
|
|
this.logger.error(`Failed to update local pattern: ${msg}`);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Send Pattern SMS using MeliPayamak Shared Service Line (Bypasses Blacklist)
|
|
*/
|
|
async sendPatternSms(options: SendPatternSmsOptions): Promise<boolean> {
|
|
const config = await this.getSmsConfig();
|
|
const msgType = options.type || "GENERIC_PATTERN";
|
|
|
|
if (!config.enabled) {
|
|
this.logger.warn(`[SMS Disabled] SMS dispatch skipped for ${options.to}`);
|
|
await this.recordLog({
|
|
receptor: options.to,
|
|
type: msgType,
|
|
patternId: options.bodyId,
|
|
args: options.args,
|
|
status: "DISABLED",
|
|
errorMessage: "ارسال پیامک از پنل ادمین غیرفعال شده است.",
|
|
});
|
|
return false;
|
|
}
|
|
|
|
if (!config.username || !config.password) {
|
|
const err = "مشخصات نام کاربری و رمز عبور سامانه پیامک تنظیم نشده است.";
|
|
this.logger.error(`[SMS MISCONFIGURED] ${err}`);
|
|
await this.recordLog({
|
|
receptor: options.to,
|
|
type: msgType,
|
|
patternId: options.bodyId,
|
|
args: options.args,
|
|
status: "FAILED",
|
|
errorMessage: err,
|
|
});
|
|
return false;
|
|
}
|
|
|
|
return new Promise((resolve) => {
|
|
const payload = JSON.stringify({
|
|
username: config.username,
|
|
password: config.password,
|
|
text: options.args.join(";"),
|
|
to: options.to,
|
|
bodyId: options.bodyId,
|
|
});
|
|
|
|
// Pre-render message text for logging
|
|
void this.renderPatternMessage(options.bodyId, options.args).then(
|
|
(renderedText) => {
|
|
const req = https.request(
|
|
"https://rest.payamak-panel.com/api/SendSMS/BaseServiceNumber",
|
|
{
|
|
method: "POST",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
"Content-Length": Buffer.byteLength(payload),
|
|
},
|
|
},
|
|
(res) => {
|
|
let data = "";
|
|
res.on(
|
|
"data",
|
|
(chunk: Buffer | string) => (data += String(chunk)),
|
|
);
|
|
res.on("end", () => {
|
|
void (async () => {
|
|
try {
|
|
const json = JSON.parse(data) as MeliPayamakResponse;
|
|
const val = json.Value ?? 0;
|
|
if (json && (val > 15 || json.RetStatus === 1)) {
|
|
this.logger.log(
|
|
`[SMS Sent] Pattern SMS ${options.bodyId} dispatched to ${options.to} (RecId: ${val})`,
|
|
);
|
|
await this.recordLog({
|
|
receptor: options.to,
|
|
type: msgType,
|
|
patternId: options.bodyId,
|
|
args: options.args,
|
|
messageText: renderedText,
|
|
status: "SUCCESS",
|
|
recId: String(val),
|
|
});
|
|
resolve(true);
|
|
} else {
|
|
const errMsg = `خطای درگاه ملی پیامک با کد بازگشتی: ${val}`;
|
|
this.logger.error(
|
|
`[SMS Error] Failed sending to ${options.to}. Code: ${val}`,
|
|
);
|
|
await this.recordLog({
|
|
receptor: options.to,
|
|
type: msgType,
|
|
patternId: options.bodyId,
|
|
args: options.args,
|
|
messageText: renderedText,
|
|
status: "FAILED",
|
|
recId: String(val),
|
|
errorMessage: errMsg,
|
|
});
|
|
resolve(false);
|
|
}
|
|
} catch (err: unknown) {
|
|
const msg =
|
|
err instanceof Error ? err.message : String(err);
|
|
await this.recordLog({
|
|
receptor: options.to,
|
|
type: msgType,
|
|
patternId: options.bodyId,
|
|
args: options.args,
|
|
messageText: renderedText,
|
|
status: "FAILED",
|
|
errorMessage: `خطای پارس پاسخ سرور: ${data || msg}`,
|
|
});
|
|
resolve(false);
|
|
}
|
|
})();
|
|
});
|
|
},
|
|
);
|
|
|
|
req.on("error", (err: Error) => {
|
|
void (async () => {
|
|
this.logger.error(
|
|
`[SMS Exception] MeliPayamak HTTP Error: ${err.message}`,
|
|
);
|
|
await this.recordLog({
|
|
receptor: options.to,
|
|
type: msgType,
|
|
patternId: options.bodyId,
|
|
args: options.args,
|
|
messageText: renderedText,
|
|
status: "FAILED",
|
|
errorMessage: `خطای شبکه: ${err.message}`,
|
|
});
|
|
resolve(false);
|
|
})();
|
|
});
|
|
|
|
req.write(payload);
|
|
req.end();
|
|
},
|
|
);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Test SMS Dispatch from Admin Panel
|
|
*/
|
|
async testSms(
|
|
targetPhone: string,
|
|
testPatternId?: number,
|
|
testArgs?: string[],
|
|
): Promise<{
|
|
success: boolean;
|
|
message: string;
|
|
rawResponse?: MeliPayamakResponse;
|
|
}> {
|
|
const config = await this.getSmsConfig();
|
|
|
|
if (!config.username || !config.password) {
|
|
const msg = "نام کاربری یا رمز عبور سامانه ملی پیامک تنظیم نشده است.";
|
|
await this.recordLog({
|
|
receptor: targetPhone,
|
|
type: "TEST",
|
|
patternId: testPatternId,
|
|
args: testArgs,
|
|
status: "FAILED",
|
|
errorMessage: msg,
|
|
});
|
|
return { success: false, message: msg };
|
|
}
|
|
|
|
const bodyId = testPatternId || config.otpBodyId || 508079;
|
|
const args = testArgs && testArgs.length > 0 ? testArgs : ["123456"];
|
|
|
|
return new Promise((resolve) => {
|
|
const payload = JSON.stringify({
|
|
username: config.username,
|
|
password: config.password,
|
|
text: args.join(";"),
|
|
to: targetPhone,
|
|
bodyId: bodyId,
|
|
});
|
|
|
|
void this.renderPatternMessage(bodyId, args).then((renderedText) => {
|
|
const req = https.request(
|
|
"https://rest.payamak-panel.com/api/SendSMS/BaseServiceNumber",
|
|
{
|
|
method: "POST",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
"Content-Length": Buffer.byteLength(payload),
|
|
},
|
|
},
|
|
(res) => {
|
|
let data = "";
|
|
res.on("data", (chunk: Buffer | string) => (data += String(chunk)));
|
|
res.on("end", () => {
|
|
void (async () => {
|
|
try {
|
|
const json = JSON.parse(data) as MeliPayamakResponse;
|
|
const val = json.Value ?? 0;
|
|
if (json && (val > 15 || json.RetStatus === 1)) {
|
|
await this.recordLog({
|
|
receptor: targetPhone,
|
|
type: "TEST",
|
|
patternId: bodyId,
|
|
args,
|
|
messageText: renderedText,
|
|
status: "SUCCESS",
|
|
recId: String(val),
|
|
});
|
|
resolve({
|
|
success: true,
|
|
message: `پیامک تستی پترن با موفقیت ارسال شد (شناسه پیگیری ملی پیامک: ${val})`,
|
|
rawResponse: json,
|
|
});
|
|
} else {
|
|
const errMsg = `خطای درگاه ملی پیامک: کد پاسخ بازگشتی ${val}`;
|
|
await this.recordLog({
|
|
receptor: targetPhone,
|
|
type: "TEST",
|
|
patternId: bodyId,
|
|
args,
|
|
messageText: renderedText,
|
|
status: "FAILED",
|
|
recId: String(val),
|
|
errorMessage: errMsg,
|
|
});
|
|
resolve({
|
|
success: false,
|
|
message: errMsg,
|
|
rawResponse: json,
|
|
});
|
|
}
|
|
} catch (err: unknown) {
|
|
const msg = err instanceof Error ? err.message : String(err);
|
|
const errMsg = `پاسخ نامعتبر از سرور ملی پیامک: ${data || msg}`;
|
|
await this.recordLog({
|
|
receptor: targetPhone,
|
|
type: "TEST",
|
|
patternId: bodyId,
|
|
args,
|
|
messageText: renderedText,
|
|
status: "FAILED",
|
|
errorMessage: errMsg,
|
|
});
|
|
resolve({ success: false, message: errMsg });
|
|
}
|
|
})();
|
|
});
|
|
},
|
|
);
|
|
|
|
req.on("error", (err: Error) => {
|
|
void (async () => {
|
|
const errMsg = `خطای برقراری ارتباط با وبسرویس ملی پیامک: ${err.message}`;
|
|
await this.recordLog({
|
|
receptor: targetPhone,
|
|
type: "TEST",
|
|
patternId: bodyId,
|
|
args,
|
|
messageText: renderedText,
|
|
status: "FAILED",
|
|
errorMessage: errMsg,
|
|
});
|
|
resolve({ success: false, message: errMsg });
|
|
})();
|
|
});
|
|
|
|
req.write(payload);
|
|
req.end();
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Send OTP Verification Code
|
|
*/
|
|
async sendOtp(phone: string, otpCode: string): Promise<boolean> {
|
|
const config = await this.getSmsConfig();
|
|
return this.sendPatternSms({
|
|
to: phone,
|
|
bodyId: config.otpBodyId,
|
|
args: [otpCode, otpCode],
|
|
type: "OTP",
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Send Order Confirmation SMS
|
|
*/
|
|
async sendOrderConfirmation(
|
|
phone: string,
|
|
customerName: string,
|
|
orderNumber: string,
|
|
amount: string,
|
|
): Promise<boolean> {
|
|
const config = await this.getSmsConfig();
|
|
const cleanName = (customerName || "مشتری").trim();
|
|
return this.sendPatternSms({
|
|
to: phone,
|
|
bodyId: config.orderBodyId,
|
|
args: [cleanName, orderNumber, amount],
|
|
type: "ORDER_CONFIRMATION",
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Send Shipping Status SMS with Tracking Code
|
|
*/
|
|
async sendShippingNotification(
|
|
phone: string,
|
|
orderNumber: string,
|
|
trackingCode: string,
|
|
): Promise<boolean> {
|
|
const config = await this.getSmsConfig();
|
|
return this.sendPatternSms({
|
|
to: phone,
|
|
bodyId: config.shippingBodyId,
|
|
args: [orderNumber, trackingCode],
|
|
type: "SHIPPING_TRACKING",
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Send B2B Application Notification SMS
|
|
*/
|
|
async sendB2bNotification(
|
|
phone: string,
|
|
applicantName: string,
|
|
): Promise<boolean> {
|
|
const config = await this.getSmsConfig();
|
|
return this.sendPatternSms({
|
|
to: phone,
|
|
bodyId: config.b2bBodyId,
|
|
args: [applicantName],
|
|
type: "B2B_NOTIFICATION",
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Send Pet Care Vaccination / Deworming Reminder SMS
|
|
*/
|
|
async sendPetCareReminder(
|
|
phone: string,
|
|
petName: string,
|
|
reminderType: string,
|
|
): Promise<boolean> {
|
|
const config = await this.getSmsConfig();
|
|
if (!config.petCareBodyId) return false;
|
|
return this.sendPatternSms({
|
|
to: phone,
|
|
bodyId: config.petCareBodyId,
|
|
args: [petName, reminderType],
|
|
type: "PET_CARE_REMINDER",
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Generic text SMS dispatch
|
|
*/
|
|
async sendSms(phone: string, message: string): Promise<boolean> {
|
|
const config = await this.getSmsConfig();
|
|
if (!config.enabled) {
|
|
await this.recordLog({
|
|
receptor: phone,
|
|
type: "GENERIC_TEXT",
|
|
messageText: message,
|
|
status: "DISABLED",
|
|
errorMessage: "ارسال پیامک غیرفعال است.",
|
|
});
|
|
return false;
|
|
}
|
|
this.logger.log(`[SMS Text Sent] To: ${phone}, Content: ${message}`);
|
|
await this.recordLog({
|
|
receptor: phone,
|
|
type: "GENERIC_TEXT",
|
|
messageText: message,
|
|
status: "SUCCESS",
|
|
});
|
|
return Promise.resolve(true);
|
|
}
|
|
}
|