diff --git a/src/auth/auth-services/user.auth.service.ts b/src/auth/auth-services/user.auth.service.ts index 542a959..77f1e39 100644 --- a/src/auth/auth-services/user.auth.service.ts +++ b/src/auth/auth-services/user.auth.service.ts @@ -14,6 +14,7 @@ import { UserDbService } from "src/users/entities/db-service/user.db.service"; import { HashService } from "src/utils/hash/hash.service"; import { OtpService } from "src/utils/otp/otp.service"; import { SmsManagerService } from "src/utils/sms-manager/sms-manager.service"; +import { describeSmsError } from "src/utils/sms-manager/sms-provider.exception"; // TODO FIX REGISTER TO USER.SERVICE AND AUTH IN THIS MODULE @Injectable() @@ -117,25 +118,26 @@ export class UserAuthService { } private async smsSender(otp: string, mobile: string) { - return this.smsManagerService - .verifyLookUp({ + try { + await this.smsManagerService.verifyLookUp({ token: otp, template: process.env.AUTH_SMS_TEMPLATE, receptor: mobile, - }) - .then((smsRes) => { - this.logger.log( - `${"phone : " + mobile + " " + ", status : " + smsRes["return"]?.status + ", otp : " + otp} `, - ); - }) - .catch((er) => { - this.logger.error( - `${"phone : " + mobile + " " + ", status : " + er["return"]?.status + ", otp : " + otp} `, - ); - throw new HttpException( - " auth sms send failed", - HttpStatus.INTERNAL_SERVER_ERROR, - ); }); + this.logger.log( + `Auth OTP SMS accepted by provider phone=${mobile} otp=${otp}`, + ); + } catch (err) { + this.logger.error( + `Auth OTP SMS failed phone=${mobile} otp=${otp} ${describeSmsError(err)}`, + ); + if (err instanceof HttpException) { + throw err; + } + throw new HttpException( + "auth sms send failed", + HttpStatus.BAD_GATEWAY, + ); + } } } diff --git a/src/request-management/request-management.service.ts b/src/request-management/request-management.service.ts index e046f91..5bdd838 100644 --- a/src/request-management/request-management.service.ts +++ b/src/request-management/request-management.service.ts @@ -33,6 +33,7 @@ import { ExpertDbService } from "src/users/entities/db-service/expert.db.service import { UserDbService } from "src/users/entities/db-service/user.db.service"; import { AutoCloseRequestService } from "src/utils/cron/cron.service"; import { SmsManagerService } from "src/utils/sms-manager/sms-manager.service"; +import { describeSmsError } from "src/utils/sms-manager/sms-provider.exception"; import { DescriptionDto, LocationDto, @@ -1190,7 +1191,7 @@ export class RequestManagementService { ); } catch (err) { this.logger.error( - `[SMS] Failed to send invitation to ${secondPartyPhone}: ${err?.message || err}`, + `[SMS] Failed to send invitation to ${secondPartyPhone}: ${describeSmsError(err)}`, ); } return { @@ -1247,7 +1248,7 @@ export class RequestManagementService { ); } catch (err) { this.logger.error( - `[SMS] Failed to send invitation to ${phoneNumber}: ${err?.message || err}`, + `[SMS] Failed to send invitation to ${phoneNumber}: ${describeSmsError(err)}`, ); // Don't block the request flow if SMS fails } @@ -2170,14 +2171,18 @@ export class RequestManagementService { // Send the SMS after the database update is complete. const URL = `${process.env.URL}/${frontendRoutes}?token=${requestId}`; try { - const smsRes = await this.smsManagerService.verifyLookUp({ + await this.smsManagerService.verifyLookUp({ token: URL, template: "yara724-invite-link", receptor: phoneNumber, }); - this.logger.log(smsRes); + this.logger.log( + `[SMS] Invite link verifyLookUp ok receptor=${phoneNumber}`, + ); } catch (er) { - this.logger.error("SMS sending failed:", er); + this.logger.error( + `[SMS] Invite link failed receptor=${phoneNumber}: ${describeSmsError(er)}`, + ); } return { url: URL }; @@ -2708,10 +2713,16 @@ export class RequestManagementService { // TODO SMS Sending if (phoneNumberToNotify) { const message = `متاسفانه طرف مقابل با نظر کارشناس مخالفت کرد. فرآیند آنلاین این پرونده بسته شده است و جهت پیگیری حضوری اقدام نمایید.`; - await this.smsManagerService.sendMessage({ - receptor: phoneNumberToNotify, - message, - }); + try { + await this.smsManagerService.sendMessage({ + receptor: phoneNumberToNotify, + message, + }); + } catch (err) { + this.logger.error( + `[SMS] PartiesDisagree notify failed receptor=${phoneNumberToNotify}: ${describeSmsError(err)}`, + ); + } } } @@ -2892,10 +2903,16 @@ export class RequestManagementService { if (phoneNumber) { // TODO FIX SMS SENDING FOR PARTIES - await this.smsManagerService.sendMessage({ - receptor: phoneNumber, - message, - }); + try { + await this.smsManagerService.sendMessage({ + receptor: phoneNumber, + message, + }); + } catch (err) { + this.logger.error( + `[SMS] One-party-replied notify failed receptor=${phoneNumber}: ${describeSmsError(err)}`, + ); + } } await this.autoCloseRequestService.scheduleAutoClose({ diff --git a/src/utils/sms-manager/kavenegar-response.ts b/src/utils/sms-manager/kavenegar-response.ts new file mode 100644 index 0000000..a164e2f --- /dev/null +++ b/src/utils/sms-manager/kavenegar-response.ts @@ -0,0 +1,78 @@ +const MAX_RAW_LEN = 8000; + +export interface KavenegarNormalized { + httpLikeStatus?: number; + message?: string; + raw: string; +} + +export function safeJsonStringify(value: unknown): string { + try { + const s = JSON.stringify(value); + return s.length > MAX_RAW_LEN + ? `${s.slice(0, MAX_RAW_LEN)}...[truncated]` + : s; + } catch { + return String(value); + } +} + +/** + * Kavenegar REST responses use `{ return: { status, message }, ... }`. + * Transport failures may yield non-JSON strings or malformed bodies. + */ +export function normalizeKavenegarBody(body: unknown): KavenegarNormalized { + if (typeof body === "string") { + try { + return normalizeKavenegarBody(JSON.parse(body) as unknown); + } catch { + const raw = + body.length > MAX_RAW_LEN + ? `${body.slice(0, MAX_RAW_LEN)}...[truncated]` + : body; + return { raw }; + } + } + + let httpLikeStatus: number | undefined; + let message: string | undefined; + + if (body && typeof body === "object" && !Array.isArray(body)) { + const ret = (body as { return?: { status?: unknown; message?: unknown } }) + .return; + if (ret && typeof ret === "object") { + if (typeof ret.status === "number" && Number.isFinite(ret.status)) { + httpLikeStatus = ret.status; + } + if (typeof ret.message === "string") { + message = ret.message; + } + } + } + + return { + httpLikeStatus, + message, + raw: safeJsonStringify(body), + }; +} + +/** Kavenegar uses `return.status === 200` for a successful API call. */ +export function isKavenegarSuccess(body: unknown): boolean { + return normalizeKavenegarBody(body).httpLikeStatus === 200; +} + +/** The nest client sometimes rejects with a JSON string `{ "error": "..." }`. */ +export function unwrapKavenegarTransportError(err: unknown): unknown { + if (typeof err === "string") { + try { + return JSON.parse(err) as unknown; + } catch { + return { transportMessage: err }; + } + } + if (err instanceof Error) { + return { name: err.name, message: err.message }; + } + return err; +} diff --git a/src/utils/sms-manager/sms-manager.service.ts b/src/utils/sms-manager/sms-manager.service.ts index 6dd8b3a..dbc96fe 100644 --- a/src/utils/sms-manager/sms-manager.service.ts +++ b/src/utils/sms-manager/sms-manager.service.ts @@ -1,5 +1,16 @@ import { KavenegarService } from "@fraybabak/kavenegar_nest"; -import { Injectable } from "@nestjs/common"; +import { Injectable, Logger } from "@nestjs/common"; +import { + isKavenegarSuccess, + KavenegarNormalized, + normalizeKavenegarBody, + safeJsonStringify, + unwrapKavenegarTransportError, +} from "./kavenegar-response"; +import { + SmsProviderException, + SmsTransportException, +} from "./sms-provider.exception"; export interface SendMessage { message: string; @@ -15,16 +26,84 @@ export interface VerifyLookUpMessage { @Injectable() export class SmsManagerService { + private readonly logger = new Logger(SmsManagerService.name); + constructor(private readonly sender: KavenegarService) {} async sendMessage(data: SendMessage) { - return await this.sender.Send({ - sender: "10008663", - ...data, - }); + try { + const body = await this.sender.Send({ + sender: "10008663", + ...data, + }); + if (!isKavenegarSuccess(body)) { + const normalized = normalizeKavenegarBody(body); + this.logProviderRejection("send", data.receptor, undefined, normalized); + throw new SmsProviderException("send", { + receptor: data.receptor, + providerBody: body, + normalized, + }); + } + this.logger.log( + `Kavenegar Send ok receptor=${data.receptor} status=200`, + ); + return body; + } catch (e) { + if (e instanceof SmsProviderException) throw e; + const detail = safeJsonStringify(unwrapKavenegarTransportError(e)); + this.logger.error( + `Kavenegar Send transport error receptor=${data.receptor} detail=${detail}`, + ); + throw new SmsTransportException("send", { receptor: data.receptor }, e); + } } async verifyLookUp(data: VerifyLookUpMessage) { - return await this.sender.verifyLookup(data); + try { + const body = await this.sender.verifyLookup(data); + if (!isKavenegarSuccess(body)) { + const normalized = normalizeKavenegarBody(body); + this.logProviderRejection( + "verifyLookUp", + data.receptor, + data.template, + normalized, + ); + throw new SmsProviderException("verifyLookup", { + receptor: data.receptor, + template: data.template, + providerBody: body, + normalized, + }); + } + this.logger.log( + `Kavenegar verifyLookUp ok receptor=${data.receptor} template=${data.template} status=200`, + ); + return body; + } catch (e) { + if (e instanceof SmsProviderException) throw e; + const detail = safeJsonStringify(unwrapKavenegarTransportError(e)); + this.logger.error( + `Kavenegar verifyLookUp transport error receptor=${data.receptor} template=${data.template} detail=${detail}`, + ); + throw new SmsTransportException( + "verifyLookup", + { receptor: data.receptor, template: data.template }, + e, + ); + } + } + + private logProviderRejection( + op: "send" | "verifyLookUp", + receptor: string, + template: string | undefined, + normalized: KavenegarNormalized, + ) { + const t = template != null && template !== "" ? ` template=${template}` : ""; + this.logger.warn( + `Kavenegar ${op} rejected receptor=${receptor}${t} providerStatus=${normalized.httpLikeStatus ?? "unknown"} providerMessage=${normalized.message ?? "n/a"} body=${normalized.raw}`, + ); } } diff --git a/src/utils/sms-manager/sms-provider.exception.ts b/src/utils/sms-manager/sms-provider.exception.ts new file mode 100644 index 0000000..ba6a26e --- /dev/null +++ b/src/utils/sms-manager/sms-provider.exception.ts @@ -0,0 +1,69 @@ +import { HttpException, HttpStatus } from "@nestjs/common"; +import { + KavenegarNormalized, + safeJsonStringify, + unwrapKavenegarTransportError, +} from "./kavenegar-response"; + +export type SmsOperation = "verifyLookup" | "send"; + +export class SmsProviderException extends HttpException { + constructor( + public readonly operation: SmsOperation, + public readonly meta: { + receptor: string; + template?: string; + providerBody: unknown; + normalized: KavenegarNormalized; + }, + ) { + super( + "SMS delivery could not be confirmed by the provider.", + HttpStatus.BAD_GATEWAY, + ); + } +} + +export class SmsTransportException extends HttpException { + constructor( + public readonly operation: SmsOperation, + public readonly meta: { receptor: string; template?: string }, + public readonly causeUnknown: unknown, + ) { + super( + "SMS service failed before a provider response was received.", + HttpStatus.BAD_GATEWAY, + ); + } +} + +/** Single-line detail for logs (provider vs transport vs unexpected). */ +export function describeSmsError(err: unknown): string { + if (err instanceof SmsProviderException) { + const n = err.meta.normalized; + return [ + `SmsProviderException(${err.operation})`, + `receptor=${err.meta.receptor}`, + err.meta.template ? `template=${err.meta.template}` : "", + `providerStatus=${n.httpLikeStatus ?? "unknown"}`, + `providerMessage=${n.message ?? "n/a"}`, + `body=${n.raw}`, + ] + .filter(Boolean) + .join(" "); + } + if (err instanceof SmsTransportException) { + return [ + `SmsTransportException(${err.operation})`, + `receptor=${err.meta.receptor}`, + err.meta.template ? `template=${err.meta.template}` : "", + `detail=${safeJsonStringify(unwrapKavenegarTransportError(err.causeUnknown))}`, + ] + .filter(Boolean) + .join(" "); + } + if (err instanceof Error) { + return `${err.name}: ${err.message}`; + } + return safeJsonStringify(err); +}