feat: send account and invoice SMS from stored template IDs

Move sms.ir template IDs out of env into settings so SuperAdmin can manage them, and record every outbound SMS status in notifications.

components/payments/paymentService.js

@@ -7,6 +7,8 @@ const eventEmitter = require('../../events/eventEmitter');
 const EVENT_NAMES = require('../../constants/eventNames');
 const { calculateMeta, escapeRegex, getSearchTerm } = require('../../utils/pagination');
 const User = require('../users/userModel');
+const { sendInvoiceCreatedSms } = require('../../utils/senders/smsMessages');
+const logger = require('../../utils/logger');
 
 const getAllPayments = async (query) => {
   const page = parseInt(query.page) || 1;
@@ -71,6 +73,15 @@ const createPayment = async (body, actorId = null) => {
     });
   }
 
+  try {
+    const user = await User.findById(payment.user).select('phoneNumber').lean();
+    if (user?.phoneNumber) {
+      await sendInvoiceCreatedSms(user.phoneNumber, payment.amount, user._id);
+    }
+  } catch (err) {
+    logger.error(`[createPayment] Invoice SMS failed for payment ${payment._id}: ${err.message}`);
+  }
+
   return getPaymentById(payment._id);
 };
 

components/settings/settingController.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const catchAsync = require('../../utils/catchAsync');
+const settingService = require('./settingService');
+const { successResponse } = require('../../utils/apiResponse');
+
+exports.getSettings = catchAsync(async (req, res) => {
+  const settings = await settingService.getSettings();
+  return successResponse(res, 200, 'Settings retrieved', settings);
+});
+
+exports.saveSettings = catchAsync(async (req, res) => {
+  const settings = await settingService.saveSettings(req.body);
+  return successResponse(res, 200, 'Settings saved', settings);
+});

components/settings/settingModel.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const mongoose = require('mongoose');
+
+const SETTINGS_KEY = 'app';
+
+const settingSchema = new mongoose.Schema({
+  key: {
+    type: String,
+    required: true,
+    unique: true,
+    default: SETTINGS_KEY,
+    index: true
+  },
+  smsTemplates: {
+    type: mongoose.Schema.Types.Mixed,
+    default: {}
+  }
+}, {
+  timestamps: true
+});
+
+const Setting = mongoose.model('Setting', settingSchema);
+
+module.exports = {
+  Setting,
+  SETTINGS_KEY
+};

components/settings/settingRoutes.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const express = require('express');
+const settingController = require('./settingController');
+const authMiddleware = require('../../middlewares/authMiddleware');
+const requireSuperAdmin = require('../../middlewares/requireSuperAdmin');
+
+const router = express.Router();
+
+router.use(authMiddleware);
+router.use(requireSuperAdmin);
+
+router.get('/', settingController.getSettings);
+router.put('/', settingController.saveSettings);
+
+module.exports = router;

components/settings/settingService.js

@@ -0,0 +1,97 @@
+'use strict';
+
+const AppError = require('../../utils/AppError');
+const { Setting, SETTINGS_KEY } = require('./settingModel');
+const {
+  SMS_TEMPLATE_DEFS,
+  envFallbackFor,
+  sanitizeTemplateId
+} = require('./smsTemplates');
+
+const emptyTemplateMap = () => {
+  const map = {};
+  SMS_TEMPLATE_DEFS.forEach((def) => {
+    map[def.key] = '';
+  });
+  return map;
+};
+
+const readStoredMap = (doc) => {
+  const stored = doc?.smsTemplates || {};
+  if (stored instanceof Map) {
+    return Object.fromEntries(stored.entries());
+  }
+  return { ...stored };
+};
+
+const resolveTemplateId = (storedMap, def) => {
+  const fromDb = String(storedMap[def.key] || '').trim();
+  if (fromDb) return fromDb;
+  return envFallbackFor(def);
+};
+
+const toPublicTemplates = (storedMap) => {
+  return SMS_TEMPLATE_DEFS.map((def) => ({
+    key: def.key,
+    label: def.label,
+    variables: def.variables,
+    templateId: resolveTemplateId(storedMap, def)
+  }));
+};
+
+const getSettings = async () => {
+  const doc = await Setting.findOne({ key: SETTINGS_KEY }).lean();
+  const storedMap = readStoredMap(doc);
+  return {
+    smsTemplates: toPublicTemplates(storedMap)
+  };
+};
+
+const getSmsTemplateId = async (key) => {
+  const def = SMS_TEMPLATE_DEFS.find((item) => item.key === key);
+  if (!def) return '';
+  const doc = await Setting.findOne({ key: SETTINGS_KEY }).lean();
+  return resolveTemplateId(readStoredMap(doc), def);
+};
+
+const saveSettings = async (body = {}) => {
+  const incoming = body.smsTemplates || {};
+  const incomingMap = Array.isArray(incoming)
+    ? Object.fromEntries(incoming.map((item) => [item.key, item.templateId]))
+    : incoming;
+
+  const existing = await Setting.findOne({ key: SETTINGS_KEY });
+  const storedMap = existing ? readStoredMap(existing) : emptyTemplateMap();
+  const nextMap = emptyTemplateMap();
+
+  for (const def of SMS_TEMPLATE_DEFS) {
+    const hasIncoming = Object.prototype.hasOwnProperty.call(incomingMap, def.key);
+    if (hasIncoming) {
+      const sanitized = sanitizeTemplateId(incomingMap[def.key]);
+      if (sanitized === null) {
+        throw new AppError('VALIDATION_FAILED', { field: def.key }, `Invalid SMS template ID for ${def.key}`);
+      }
+      nextMap[def.key] = sanitized;
+    } else if (storedMap[def.key]) {
+      nextMap[def.key] = String(storedMap[def.key]).trim();
+    } else {
+      nextMap[def.key] = envFallbackFor(def);
+    }
+  }
+
+  const doc = await Setting.findOneAndUpdate(
+    { key: SETTINGS_KEY },
+    { $set: { smsTemplates: nextMap } },
+    { upsert: true, new: true, setDefaultsOnInsert: true }
+  );
+
+  return {
+    smsTemplates: toPublicTemplates(readStoredMap(doc))
+  };
+};
+
+module.exports = {
+  getSettings,
+  saveSettings,
+  getSmsTemplateId
+};

components/settings/smsTemplates.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const SMS_TEMPLATE_DEFS = [
+  {
+    key: 'accountCreated',
+    label: 'ایجاد حساب کاربری',
+    variables: ['user', 'password'],
+    envKey: 'SMS_TEMPLATE_ACCOUNT_CREATED'
+  },
+  {
+    key: 'classRegistered',
+    label: 'ثبت‌نام در کلاس',
+    variables: ['className'],
+    envKey: 'SMS_TEMPLATE_CLASS_REGISTERED'
+  },
+  {
+    key: 'classReminder',
+    label: 'یادآوری کلاس',
+    variables: ['className', 'time', 'place'],
+    envKey: 'SMS_TEMPLATE_CLASS_REMINDER'
+  },
+  {
+    key: 'invoiceCreated',
+    label: 'ایجاد صورتحساب',
+    variables: ['amount'],
+    envKey: 'SMS_TEMPLATE_INVOICE_CREATED'
+  }
+];
+
+const SMS_TEMPLATE_KEYS = SMS_TEMPLATE_DEFS.map((def) => def.key);
+
+const envFallbackFor = (def) => {
+  if (!def?.envKey) return '';
+  return String(process.env[def.envKey] || '').trim();
+};
+
+const sanitizeTemplateId = (value) => {
+  if (value == null) return '';
+  const digits = String(value).trim();
+  if (!digits) return '';
+  if (!/^\d{1,20}$/.test(digits)) return null;
+  return digits;
+};
+
+module.exports = {
+  SMS_TEMPLATE_DEFS,
+  SMS_TEMPLATE_KEYS,
+  envFallbackFor,
+  sanitizeTemplateId
+};

components/users/userService.js

@@ -175,7 +175,7 @@ const createUserAdmin = async (body) => {
   });
 
   try {
-    await sendAccountCreatedSms(profile.phoneNumber, username, plainPassword);
+    await sendAccountCreatedSms(profile.phoneNumber, username, plainPassword, user._id);
   } catch (err) {
     logger.error(`[createUserAdmin] Account SMS failed for ${profile.phoneNumber}: ${err.message}`);
   }