Implementing SMS panel in Super Admin

src/auth/remote-tenant.decorator.ts

@@ -0,0 +1,8 @@
+import { createParamDecorator, ExecutionContext } from '@nestjs/common';
+
+export const RemoteTenant = createParamDecorator(
+  (_data: unknown, ctx: ExecutionContext) => {
+    const req = ctx.switchToHttp().getRequest();
+    return req.remoteTenant;
+  },
+);

src/auth/remote-token.guard.ts

@@ -0,0 +1,44 @@
+import {
+  CanActivate,
+  ExecutionContext,
+  Injectable,
+  UnauthorizedException,
+} from '@nestjs/common';
+import { PrismaService } from '../prisma/prisma.service';
+
+@Injectable()
+export class RemoteTokenGuard implements CanActivate {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const req = context.switchToHttp().getRequest();
+    const header = String(req.headers?.authorization || '');
+    const match = /^Bearer\s+(.+)$/i.exec(header.trim());
+    const token = match?.[1]?.trim();
+
+    if (!token || token.length < 16) {
+      throw new UnauthorizedException('توکن نسخه نامعتبر است');
+    }
+
+    const tenant = await this.prisma.tenant.findFirst({
+      where: {
+        remoteApiToken: token,
+        isActive: true,
+      },
+      select: {
+        id: true,
+        nameFa: true,
+        domain: true,
+        product: true,
+        isActive: true,
+      },
+    });
+
+    if (!tenant) {
+      throw new UnauthorizedException('توکن نسخه نامعتبر است');
+    }
+
+    req.remoteTenant = tenant;
+    return true;
+  }
+}

src/sms/dto/sms-account.dto.ts

@@ -115,3 +115,32 @@ export class SmsTableQueryDto {
   @IsString()
   search?: string;
 }
+
+/** Body for product → SuperAdmin SMS consume (after successful gateway send) */
+export class RemoteSmsConsumeDto {
+  @IsString()
+  receiver!: string;
+
+  @IsOptional()
+  @IsString()
+  body?: string;
+
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  @Max(50)
+  parts!: number;
+
+  @IsOptional()
+  @IsString()
+  provider?: string;
+
+  @IsOptional()
+  @IsString()
+  source?: string;
+
+  @IsOptional()
+  @IsBoolean()
+  isAlert?: boolean;
+}
+

src/sms/remote-sms.controller.ts

@@ -0,0 +1,45 @@
+import { Body, Controller, Get, Post, Query, UseGuards } from '@nestjs/common';
+import { RemoteTenant } from '../auth/remote-tenant.decorator';
+import { RemoteTokenGuard } from '../auth/remote-token.guard';
+import { RemoteSmsConsumeDto } from './dto/sms-account.dto';
+import { SmsService } from './sms.service';
+
+type RemoteTenantInfo = {
+  id: string;
+  nameFa: string;
+  domain: string | null;
+  product: string;
+  isActive: boolean;
+};
+
+/**
+ * Product apps (Hamkar/Khanegi) → SuperAdmin SMS wallet.
+ * Auth: Authorization: Bearer {Tenant.remoteApiToken}
+ *
+ * GET  /api/remote/sms/status?parts=1
+ * POST /api/remote/sms/consume
+ */
+@Controller('remote/sms')
+@UseGuards(RemoteTokenGuard)
+export class RemoteSmsController {
+  constructor(private readonly smsService: SmsService) {}
+
+  @Get('status')
+  status(
+    @RemoteTenant() tenant: RemoteTenantInfo,
+    @Query('parts') parts?: string,
+    @Query('isAlert') isAlert?: string,
+  ) {
+    const n = Math.max(1, Math.min(50, Number(parts) || 1));
+    const alert = isAlert === '1' || isAlert === 'true';
+    return this.smsService.remoteStatus(tenant.id, n, alert);
+  }
+
+  @Post('consume')
+  consume(
+    @RemoteTenant() tenant: RemoteTenantInfo,
+    @Body() dto: RemoteSmsConsumeDto,
+  ) {
+    return this.smsService.remoteConsume(tenant.id, dto);
+  }
+}

src/sms/sms.module.ts

@@ -1,12 +1,14 @@
 import { Module } from '@nestjs/common';
 import { NotificationsModule } from '../notifications/notifications.module';
+import { RemoteSmsController } from './remote-sms.controller';
 import { SmsController } from './sms.controller';
 import { SmsService } from './sms.service';
+import { RemoteTokenGuard } from '../auth/remote-token.guard';
 
 @Module({
   imports: [NotificationsModule],
-  controllers: [SmsController],
-  providers: [SmsService],
+  controllers: [SmsController, RemoteSmsController],
+  providers: [SmsService, RemoteTokenGuard],
   exports: [SmsService],
 })
 export class SmsModule {}

src/sms/sms.service.ts

@@ -1,5 +1,8 @@
 import {
   BadRequestException,
+  ForbiddenException,
+  HttpException,
+  HttpStatus,
   Injectable,
   NotFoundException,
 } from '@nestjs/common';
@@ -10,6 +13,7 @@ import { AdminNotifyService } from '../notifications/admin-notify.service';
 import { iranYmd } from '../common/iran-time.util';
 import {
   ChargeSmsWalletDto,
+  RemoteSmsConsumeDto,
   SmsTableQueryDto,
   UpdateSmsAccountDto,
   UpdateSmsChargeInfoDto,
@@ -236,6 +240,131 @@ export class SmsService {
     return this.updateAccount(tenantId, { isBlocked }, userId);
   }
 
+  /** Product apps: pre-send gate */
+  async remoteStatus(tenantId: string, parts = 1, isAlert = false) {
+    const account = await this.ensureAccount(tenantId);
+    const safeParts = Math.max(1, Math.min(50, Math.floor(parts) || 1));
+    const estimatedCostRials = safeParts * account.pricePerPartRials;
+    const balanceLevel = this.balanceLevel(
+      account.balanceRials,
+      account.alertCriticalRials,
+      account.alertWarningRials,
+    );
+
+    let reason: string | null = null;
+    let allowed = true;
+
+    if (account.isBlocked && !isAlert) {
+      allowed = false;
+      reason = 'blocked';
+    } else if (!isAlert && account.balanceRials < estimatedCostRials) {
+      allowed = false;
+      reason = 'insufficient_balance';
+    }
+
+    return {
+      allowed,
+      blocked: account.isBlocked,
+      reason,
+      balanceRials: account.balanceRials,
+      pricePerPartRials: account.pricePerPartRials,
+      parts: safeParts,
+      estimatedCostRials,
+      balanceLevel,
+    };
+  }
+
+  /** Product apps: post-send debit + send log */
+  async remoteConsume(tenantId: string, dto: RemoteSmsConsumeDto) {
+    const parts = Math.max(1, Math.min(50, Math.floor(dto.parts) || 1));
+    const receiver = String(dto.receiver || '').trim().slice(0, 32);
+    if (!receiver) {
+      throw new BadRequestException('شماره گیرنده الزامی است');
+    }
+
+    const body = String(dto.body || '')
+      .trim()
+      .slice(0, 1000);
+    const provider = dto.provider ? String(dto.provider).trim().slice(0, 64) : null;
+    const source = dto.source ? String(dto.source).trim().slice(0, 64) : null;
+    const isAlert = Boolean(dto.isAlert);
+
+    const result = await this.prisma.$transaction(async (tx) => {
+      const account = await tx.smsAccount.findUnique({ where: { tenantId } });
+      if (!account) {
+        throw new NotFoundException('حساب پیامک یافت نشد');
+      }
+
+      if (account.isBlocked && !isAlert) {
+        throw new ForbiddenException({
+          message: 'ارسال پیامک برای این نسخه مسدود است',
+          reason: 'blocked',
+        });
+      }
+
+      const costRials = parts * account.pricePerPartRials;
+
+      if (!isAlert && account.balanceRials < costRials) {
+        throw new HttpException(
+          {
+            message: 'موجودی کیف پول پیامک کافی نیست',
+            reason: 'insufficient_balance',
+            balanceRials: account.balanceRials,
+            costRials,
+          },
+          HttpStatus.PAYMENT_REQUIRED,
+        );
+      }
+
+      const nextBalance = account.balanceRials - costRials;
+
+      const updated = await tx.smsAccount.update({
+        where: { id: account.id },
+        data: { balanceRials: nextBalance },
+      });
+
+      await tx.smsLedger.create({
+        data: {
+          smsAccountId: account.id,
+          type: 'debit',
+          amountRials: -costRials,
+          balanceAfterRials: nextBalance,
+          parts,
+          note: source ? `مصرف ارسال (${source})` : 'مصرف ارسال',
+        },
+      });
+
+      await tx.smsSendLog.create({
+        data: {
+          smsAccountId: account.id,
+          receiver,
+          body: body || '—',
+          parts,
+          pricePerPartRials: account.pricePerPartRials,
+          totalAmountRials: costRials,
+          provider,
+          source,
+          isAlert,
+        },
+      });
+
+      return {
+        ok: true as const,
+        balanceRials: updated.balanceRials,
+        costRials,
+        parts,
+        pricePerPartRials: account.pricePerPartRials,
+        balanceLevel: this.balanceLevel(
+          updated.balanceRials,
+          account.alertCriticalRials,
+          account.alertWarningRials,
+        ),
+      };
+    });
+
+    return result;
+  }
+
   async getPeriodReport(tenantId: string, fromDate?: string, toDate?: string) {
     const account = await this.ensureAccount(tenantId);
     const range = this.resolveDateRange(fromDate, toDate, true);