sms-setting and campain

src/sms-settings/sms-dispatch.service.ts

@@ -0,0 +1,125 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { renderSmsTemplate } from '../sms-templates/utils/render-sms-template.util';
+import { SmsTemplatesService } from '../sms-templates/sms-templates.service';
+import { SmsService } from '../sms/sms.service';
+import {
+  getSampleVariables,
+  SMS_SCENARIOS,
+  SMS_SCENARIO_MAP,
+} from './constants/sms-scenarios.constants';
+import { PreviewSmsScenarioDto } from './dto/update-sms-scenario-setting.dto';
+import { SmsScenarioSetting } from './entities/sms-scenario-setting.entity';
+import { SmsScenarioKey } from './enums/sms-scenario-key.enum';
+
+@Injectable()
+export class SmsDispatchService {
+  constructor(
+    @InjectRepository(SmsScenarioSetting)
+    private readonly settingsRepository: Repository<SmsScenarioSetting>,
+    private readonly smsTemplatesService: SmsTemplatesService,
+    private readonly smsService: SmsService,
+  ) {}
+
+  getScenarioDefinitions() {
+    return SMS_SCENARIOS;
+  }
+
+  async findAllSettings(): Promise<SmsScenarioSetting[]> {
+    return this.settingsRepository.find({
+      relations: { template: true },
+      order: { key: 'ASC' },
+    });
+  }
+
+  async findSettingByKey(key: SmsScenarioKey): Promise<SmsScenarioSetting> {
+    const setting = await this.settingsRepository.findOne({
+      where: { key },
+      relations: { template: true },
+    });
+
+    if (!setting) {
+      throw new NotFoundException(`SMS scenario setting "${key}" not found`);
+    }
+
+    return setting;
+  }
+
+  async resolveMessage(
+    key: SmsScenarioKey,
+    variables: Record<string, string>,
+  ): Promise<string | null> {
+    const setting = await this.findSettingByKey(key);
+    if (!setting.isActive) {
+      return null;
+    }
+
+    const body = await this.resolveBody(setting);
+    if (!body) {
+      return null;
+    }
+
+    return renderSmsTemplate(body, variables);
+  }
+
+  async previewMessage(dto: PreviewSmsScenarioDto): Promise<string> {
+    const body = await this.resolvePreviewBody(dto);
+    const variables = getSampleVariables(dto.key);
+    return renderSmsTemplate(body, variables);
+  }
+
+  async sendScenarioSms(
+    key: SmsScenarioKey,
+    mobile: string,
+    variables: Record<string, string>,
+  ): Promise<boolean> {
+    const message = await this.resolveMessage(key, variables);
+    if (!message) {
+      return false;
+    }
+
+    return this.smsService.sendSms(mobile, message);
+  }
+
+  private async resolveBody(
+    setting: SmsScenarioSetting,
+  ): Promise<string | null> {
+    if (setting.templateId) {
+      const template = await this.smsTemplatesService.findOne(
+        setting.templateId,
+      );
+      if (!template.isActive) {
+        return null;
+      }
+      return template.body;
+    }
+
+    if (setting.body) {
+      return setting.body;
+    }
+
+    return SMS_SCENARIO_MAP.get(setting.key)?.defaultBody ?? null;
+  }
+
+  private async resolvePreviewBody(
+    dto: PreviewSmsScenarioDto,
+  ): Promise<string> {
+    if (dto.templateId) {
+      const template = await this.smsTemplatesService.findOne(dto.templateId);
+      return template.body;
+    }
+
+    if (dto.body) {
+      return dto.body;
+    }
+
+    const setting = await this.findSettingByKey(dto.key);
+    const resolved = await this.resolveBody(setting);
+    if (!resolved) {
+      throw new NotFoundException('No SMS body configured for this scenario');
+    }
+
+    return resolved;
+  }
+}