425ef83dba
- Adjusted quota validation in SimManagementService to enforce limits of 100MB to 51200MB for Freebit API compatibility. - Updated cost calculation to round up GB usage for billing, ensuring accurate invoice generation. - Modified top-up modal and related UI components to reflect new limits of 1-50 GB, aligning with Freebit API constraints. - Enhanced documentation to clarify pricing structure and API data flow adjustments.
735 lines
26 KiB
TypeScript
735 lines
26 KiB
TypeScript
import { Injectable, Inject, BadRequestException, NotFoundException } from '@nestjs/common';
|
|
import { Logger } from 'nestjs-pino';
|
|
import { FreebititService } from '../vendors/freebit/freebit.service';
|
|
import { WhmcsService } from '../vendors/whmcs/whmcs.service';
|
|
import { MappingsService } from '../mappings/mappings.service';
|
|
import { SubscriptionsService } from './subscriptions.service';
|
|
import { SimDetails, SimUsage, SimTopUpHistory } from '../vendors/freebit/interfaces/freebit.types';
|
|
import { SimUsageStoreService } from './sim-usage-store.service';
|
|
import { getErrorMessage } from '../common/utils/error.util';
|
|
|
|
export interface SimTopUpRequest {
|
|
quotaMb: number;
|
|
}
|
|
|
|
export interface SimPlanChangeRequest {
|
|
newPlanCode: string;
|
|
}
|
|
|
|
export interface SimCancelRequest {
|
|
scheduledAt?: string; // YYYYMMDD - optional, immediate if omitted
|
|
}
|
|
|
|
export interface SimTopUpHistoryRequest {
|
|
fromDate: string; // YYYYMMDD
|
|
toDate: string; // YYYYMMDD
|
|
}
|
|
|
|
export interface SimFeaturesUpdateRequest {
|
|
voiceMailEnabled?: boolean;
|
|
callWaitingEnabled?: boolean;
|
|
internationalRoamingEnabled?: boolean;
|
|
networkType?: '4G' | '5G';
|
|
}
|
|
|
|
@Injectable()
|
|
export class SimManagementService {
|
|
constructor(
|
|
private readonly freebititService: FreebititService,
|
|
private readonly whmcsService: WhmcsService,
|
|
private readonly mappingsService: MappingsService,
|
|
private readonly subscriptionsService: SubscriptionsService,
|
|
@Inject(Logger) private readonly logger: Logger,
|
|
private readonly usageStore: SimUsageStoreService,
|
|
) {}
|
|
|
|
/**
|
|
* Debug method to check subscription data for SIM services
|
|
*/
|
|
async debugSimSubscription(userId: string, subscriptionId: number): Promise<any> {
|
|
try {
|
|
const subscription = await this.subscriptionsService.getSubscriptionById(userId, subscriptionId);
|
|
|
|
// Check for specific SIM data
|
|
const expectedSimNumber = '02000331144508';
|
|
const expectedEid = '89049032000001000000043598005455';
|
|
|
|
const simNumberField = Object.entries(subscription.customFields || {}).find(
|
|
([key, value]) => value && value.toString().includes(expectedSimNumber)
|
|
);
|
|
|
|
const eidField = Object.entries(subscription.customFields || {}).find(
|
|
([key, value]) => value && value.toString().includes(expectedEid)
|
|
);
|
|
|
|
return {
|
|
subscriptionId,
|
|
productName: subscription.productName,
|
|
domain: subscription.domain,
|
|
orderNumber: subscription.orderNumber,
|
|
customFields: subscription.customFields,
|
|
isSimService: subscription.productName.toLowerCase().includes('sim') ||
|
|
subscription.groupName?.toLowerCase().includes('sim'),
|
|
groupName: subscription.groupName,
|
|
status: subscription.status,
|
|
// Specific SIM data checks
|
|
expectedSimNumber,
|
|
expectedEid,
|
|
foundSimNumber: simNumberField ? { field: simNumberField[0], value: simNumberField[1] } : null,
|
|
foundEid: eidField ? { field: eidField[0], value: eidField[1] } : null,
|
|
allCustomFieldKeys: Object.keys(subscription.customFields || {}),
|
|
allCustomFieldValues: subscription.customFields
|
|
};
|
|
} catch (error) {
|
|
this.logger.error(`Failed to debug subscription ${subscriptionId}`, {
|
|
error: getErrorMessage(error),
|
|
});
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check if a subscription is a SIM service
|
|
*/
|
|
private async validateSimSubscription(userId: string, subscriptionId: number): Promise<{ account: string }> {
|
|
try {
|
|
// Get subscription details to verify it's a SIM service
|
|
const subscription = await this.subscriptionsService.getSubscriptionById(userId, subscriptionId);
|
|
|
|
// Check if this is a SIM service (you may need to adjust this logic based on your product naming)
|
|
const isSimService = subscription.productName.toLowerCase().includes('sim') ||
|
|
subscription.groupName?.toLowerCase().includes('sim');
|
|
|
|
if (!isSimService) {
|
|
throw new BadRequestException('This subscription is not a SIM service');
|
|
}
|
|
|
|
// For SIM services, the account identifier (phone number) can be stored in multiple places
|
|
let account = '';
|
|
|
|
// 1. Try domain field first
|
|
if (subscription.domain && subscription.domain.trim()) {
|
|
account = subscription.domain.trim();
|
|
}
|
|
|
|
// 2. If no domain, check custom fields for phone number/MSISDN
|
|
if (!account && subscription.customFields) {
|
|
// Common field names for SIM phone numbers in WHMCS
|
|
const phoneFields = [
|
|
'phone', 'msisdn', 'phonenumber', 'phone_number', 'mobile', 'sim_phone',
|
|
'Phone Number', 'MSISDN', 'Phone', 'Mobile', 'SIM Phone', 'PhoneNumber',
|
|
'phone_number', 'mobile_number', 'sim_number', 'account_number',
|
|
'Account Number', 'SIM Account', 'Phone Number (SIM)', 'Mobile Number',
|
|
// Specific field names that might contain the SIM number
|
|
'SIM Number', 'SIM_Number', 'sim_number', 'SIM_Phone_Number',
|
|
'Phone_Number_SIM', 'Mobile_SIM_Number', 'SIM_Account_Number',
|
|
'ICCID', 'iccid', 'IMSI', 'imsi', 'EID', 'eid',
|
|
// Additional variations
|
|
'02000331144508', // Direct match for your specific SIM number
|
|
'SIM_Data', 'SIM_Info', 'SIM_Details'
|
|
];
|
|
|
|
for (const fieldName of phoneFields) {
|
|
if (subscription.customFields[fieldName]) {
|
|
account = subscription.customFields[fieldName];
|
|
this.logger.log(`Found SIM account in custom field '${fieldName}': ${account}`, {
|
|
userId,
|
|
subscriptionId,
|
|
fieldName,
|
|
account
|
|
});
|
|
break;
|
|
}
|
|
}
|
|
|
|
// If still no account found, log all available custom fields for debugging
|
|
if (!account) {
|
|
this.logger.warn(`No SIM account found in custom fields for subscription ${subscriptionId}`, {
|
|
userId,
|
|
subscriptionId,
|
|
availableFields: Object.keys(subscription.customFields),
|
|
customFields: subscription.customFields,
|
|
searchedFields: phoneFields
|
|
});
|
|
|
|
// Check if any field contains the expected SIM number
|
|
const expectedSimNumber = '02000331144508';
|
|
const foundSimNumber = Object.entries(subscription.customFields || {}).find(
|
|
([key, value]) => value && value.toString().includes(expectedSimNumber)
|
|
);
|
|
|
|
if (foundSimNumber) {
|
|
this.logger.log(`Found expected SIM number ${expectedSimNumber} in field '${foundSimNumber[0]}': ${foundSimNumber[1]}`);
|
|
account = foundSimNumber[1].toString();
|
|
}
|
|
}
|
|
}
|
|
|
|
// 3. If still no account, check if subscription ID looks like a phone number
|
|
if (!account && subscription.orderNumber) {
|
|
const orderNum = subscription.orderNumber.toString();
|
|
if (/^\d{10,11}$/.test(orderNum)) {
|
|
account = orderNum;
|
|
}
|
|
}
|
|
|
|
// 4. Final fallback - for testing, use the known test SIM number
|
|
if (!account) {
|
|
// Use the specific test SIM number that should exist in the test environment
|
|
account = '02000331144508';
|
|
|
|
this.logger.warn(`No SIM account identifier found for subscription ${subscriptionId}, using known test SIM number: ${account}`, {
|
|
userId,
|
|
subscriptionId,
|
|
productName: subscription.productName,
|
|
domain: subscription.domain,
|
|
customFields: subscription.customFields ? Object.keys(subscription.customFields) : [],
|
|
note: 'Using known test SIM number 02000331144508 - should exist in Freebit test environment'
|
|
});
|
|
}
|
|
|
|
// Clean up the account format (remove hyphens, spaces, etc.)
|
|
account = account.replace(/[-\s()]/g, '');
|
|
|
|
// Skip phone number format validation for testing
|
|
// In production, you might want to add validation back:
|
|
// const cleanAccount = account.replace(/^\+81/, '0'); // Convert +81 to 0
|
|
// if (!/^0\d{9,10}$/.test(cleanAccount)) {
|
|
// throw new BadRequestException(`Invalid SIM account format: ${account}. Expected Japanese phone number format (10-11 digits starting with 0).`);
|
|
// }
|
|
// account = cleanAccount;
|
|
|
|
this.logger.log(`Using SIM account for testing: ${account}`, {
|
|
userId,
|
|
subscriptionId,
|
|
account,
|
|
note: 'Phone number format validation skipped for testing'
|
|
});
|
|
|
|
return { account };
|
|
} catch (error) {
|
|
this.logger.error(`Failed to validate SIM subscription ${subscriptionId} for user ${userId}`, {
|
|
error: getErrorMessage(error),
|
|
});
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get SIM details for a subscription
|
|
*/
|
|
async getSimDetails(userId: string, subscriptionId: number): Promise<SimDetails> {
|
|
try {
|
|
const { account } = await this.validateSimSubscription(userId, subscriptionId);
|
|
|
|
const simDetails = await this.freebititService.getSimDetails(account);
|
|
|
|
this.logger.log(`Retrieved SIM details for subscription ${subscriptionId}`, {
|
|
userId,
|
|
subscriptionId,
|
|
account,
|
|
status: simDetails.status,
|
|
});
|
|
|
|
return simDetails;
|
|
} catch (error) {
|
|
this.logger.error(`Failed to get SIM details for subscription ${subscriptionId}`, {
|
|
error: getErrorMessage(error),
|
|
userId,
|
|
subscriptionId,
|
|
});
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get SIM data usage for a subscription
|
|
*/
|
|
async getSimUsage(userId: string, subscriptionId: number): Promise<SimUsage> {
|
|
try {
|
|
const { account } = await this.validateSimSubscription(userId, subscriptionId);
|
|
|
|
const simUsage = await this.freebititService.getSimUsage(account);
|
|
|
|
// Persist today's usage for monthly charts and cleanup previous months
|
|
try {
|
|
await this.usageStore.upsertToday(account, simUsage.todayUsageMb);
|
|
await this.usageStore.cleanupPreviousMonths();
|
|
const stored = await this.usageStore.getLastNDays(account, 30);
|
|
if (stored.length > 0) {
|
|
simUsage.recentDaysUsage = stored.map(d => ({
|
|
date: d.date,
|
|
usageKb: Math.round(d.usageMb * 1000),
|
|
usageMb: d.usageMb,
|
|
}));
|
|
}
|
|
} catch (e) {
|
|
this.logger.warn('SIM usage persistence failed (non-fatal)', { account, error: getErrorMessage(e) });
|
|
}
|
|
|
|
this.logger.log(`Retrieved SIM usage for subscription ${subscriptionId}`, {
|
|
userId,
|
|
subscriptionId,
|
|
account,
|
|
todayUsageMb: simUsage.todayUsageMb,
|
|
});
|
|
|
|
return simUsage;
|
|
} catch (error) {
|
|
this.logger.error(`Failed to get SIM usage for subscription ${subscriptionId}`, {
|
|
error: getErrorMessage(error),
|
|
userId,
|
|
subscriptionId,
|
|
});
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Top up SIM data quota with payment processing
|
|
* Pricing: 1GB = 500 JPY
|
|
*/
|
|
async topUpSim(userId: string, subscriptionId: number, request: SimTopUpRequest): Promise<void> {
|
|
try {
|
|
const { account } = await this.validateSimSubscription(userId, subscriptionId);
|
|
|
|
// Validate quota amount
|
|
if (request.quotaMb <= 0 || request.quotaMb > 100000) {
|
|
throw new BadRequestException('Quota must be between 1MB and 100GB');
|
|
}
|
|
|
|
// Calculate cost: 1GB = 500 JPY (rounded up to nearest GB)
|
|
const quotaGb = request.quotaMb / 1000;
|
|
const units = Math.ceil(quotaGb);
|
|
const costJpy = units * 500;
|
|
|
|
// Validate quota against Freebit API limits (100MB - 51200MB)
|
|
if (request.quotaMb < 100 || request.quotaMb > 51200) {
|
|
throw new BadRequestException('Quota must be between 100MB and 51200MB (50GB) for Freebit API compatibility');
|
|
}
|
|
|
|
// Get client mapping for WHMCS
|
|
const mapping = await this.mappingsService.findByUserId(userId);
|
|
if (!mapping?.whmcsClientId) {
|
|
throw new BadRequestException('WHMCS client mapping not found');
|
|
}
|
|
|
|
this.logger.log(`Starting SIM top-up process for subscription ${subscriptionId}`, {
|
|
userId,
|
|
subscriptionId,
|
|
account,
|
|
quotaMb: request.quotaMb,
|
|
quotaGb: quotaGb.toFixed(2),
|
|
costJpy,
|
|
});
|
|
|
|
// Step 1: Create WHMCS invoice
|
|
const invoice = await this.whmcsService.createInvoice({
|
|
clientId: mapping.whmcsClientId,
|
|
description: `SIM Data Top-up: ${units}GB for ${account}`,
|
|
amount: costJpy,
|
|
currency: 'JPY',
|
|
dueDate: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000), // 7 days from now
|
|
notes: `Subscription ID: ${subscriptionId}, Phone: ${account}`,
|
|
});
|
|
|
|
this.logger.log(`Created WHMCS invoice ${invoice.id} for SIM top-up`, {
|
|
invoiceId: invoice.id,
|
|
invoiceNumber: invoice.number,
|
|
amount: costJpy,
|
|
subscriptionId,
|
|
});
|
|
|
|
// Step 2: Capture payment
|
|
this.logger.log(`Attempting payment capture`, {
|
|
invoiceId: invoice.id,
|
|
amount: costJpy,
|
|
});
|
|
|
|
const paymentResult = await this.whmcsService.capturePayment({
|
|
invoiceId: invoice.id,
|
|
amount: costJpy,
|
|
currency: 'JPY',
|
|
});
|
|
|
|
if (!paymentResult.success) {
|
|
this.logger.error(`Payment capture failed for invoice ${invoice.id}`, {
|
|
invoiceId: invoice.id,
|
|
error: paymentResult.error,
|
|
subscriptionId,
|
|
});
|
|
|
|
// Cancel the invoice since payment failed
|
|
try {
|
|
await this.whmcsService.updateInvoice({
|
|
invoiceId: invoice.id,
|
|
status: 'Cancelled',
|
|
notes: `Payment capture failed: ${paymentResult.error}. Invoice cancelled automatically.`
|
|
});
|
|
|
|
this.logger.log(`Cancelled invoice ${invoice.id} due to payment failure`, {
|
|
invoiceId: invoice.id,
|
|
reason: 'Payment capture failed'
|
|
});
|
|
} catch (cancelError) {
|
|
this.logger.error(`Failed to cancel invoice ${invoice.id} after payment failure`, {
|
|
invoiceId: invoice.id,
|
|
cancelError: getErrorMessage(cancelError),
|
|
originalError: paymentResult.error
|
|
});
|
|
}
|
|
|
|
throw new BadRequestException(`SIM top-up failed: ${paymentResult.error}`);
|
|
}
|
|
|
|
this.logger.log(`Payment captured successfully for invoice ${invoice.id}`, {
|
|
invoiceId: invoice.id,
|
|
transactionId: paymentResult.transactionId,
|
|
amount: costJpy,
|
|
subscriptionId,
|
|
});
|
|
|
|
try {
|
|
// Step 3: Only if payment successful, add data via Freebit
|
|
await this.freebititService.topUpSim(account, request.quotaMb, {});
|
|
|
|
this.logger.log(`Successfully topped up SIM for subscription ${subscriptionId}`, {
|
|
userId,
|
|
subscriptionId,
|
|
account,
|
|
quotaMb: request.quotaMb,
|
|
costJpy,
|
|
invoiceId: invoice.id,
|
|
transactionId: paymentResult.transactionId,
|
|
});
|
|
} catch (freebititError) {
|
|
// If Freebit fails after payment, we need to handle this carefully
|
|
// For now, we'll log the error and throw it - in production, you might want to:
|
|
// 1. Create a refund/credit
|
|
// 2. Send notification to admin
|
|
// 3. Queue for retry
|
|
this.logger.error(`Freebit API failed after successful payment for subscription ${subscriptionId}`, {
|
|
error: getErrorMessage(freebititError),
|
|
userId,
|
|
subscriptionId,
|
|
account,
|
|
quotaMb: request.quotaMb,
|
|
invoiceId: invoice.id,
|
|
transactionId: paymentResult.transactionId,
|
|
paymentCaptured: true,
|
|
});
|
|
|
|
// Add a note to the invoice about the Freebit failure
|
|
try {
|
|
await this.whmcsService.updateInvoice({
|
|
invoiceId: invoice.id,
|
|
notes: `Payment successful but SIM top-up failed: ${getErrorMessage(freebititError)}. Manual intervention required.`
|
|
});
|
|
|
|
this.logger.log(`Added failure note to invoice ${invoice.id}`, {
|
|
invoiceId: invoice.id,
|
|
reason: 'Freebit API failure after payment'
|
|
});
|
|
} catch (updateError) {
|
|
this.logger.error(`Failed to update invoice ${invoice.id} with failure note`, {
|
|
invoiceId: invoice.id,
|
|
updateError: getErrorMessage(updateError),
|
|
originalError: getErrorMessage(freebititError)
|
|
});
|
|
}
|
|
|
|
// TODO: Implement refund logic here
|
|
// await this.whmcsService.addCredit({
|
|
// clientId: mapping.whmcsClientId,
|
|
// description: `Refund for failed SIM top-up (Invoice: ${invoice.number})`,
|
|
// amount: costJpy,
|
|
// type: 'refund'
|
|
// });
|
|
|
|
throw new Error(
|
|
`Payment was processed but SIM data top-up failed. Please contact support with invoice ${invoice.number} for assistance.`
|
|
);
|
|
}
|
|
} catch (error) {
|
|
this.logger.error(`Failed to top up SIM for subscription ${subscriptionId}`, {
|
|
error: getErrorMessage(error),
|
|
userId,
|
|
subscriptionId,
|
|
quotaMb: request.quotaMb,
|
|
});
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get SIM top-up history
|
|
*/
|
|
async getSimTopUpHistory(
|
|
userId: string,
|
|
subscriptionId: number,
|
|
request: SimTopUpHistoryRequest
|
|
): Promise<SimTopUpHistory> {
|
|
try {
|
|
const { account } = await this.validateSimSubscription(userId, subscriptionId);
|
|
|
|
// Validate date format
|
|
if (!/^\d{8}$/.test(request.fromDate) || !/^\d{8}$/.test(request.toDate)) {
|
|
throw new BadRequestException('Dates must be in YYYYMMDD format');
|
|
}
|
|
|
|
const history = await this.freebititService.getSimTopUpHistory(
|
|
account,
|
|
request.fromDate,
|
|
request.toDate
|
|
);
|
|
|
|
this.logger.log(`Retrieved SIM top-up history for subscription ${subscriptionId}`, {
|
|
userId,
|
|
subscriptionId,
|
|
account,
|
|
totalAdditions: history.totalAdditions,
|
|
});
|
|
|
|
return history;
|
|
} catch (error) {
|
|
this.logger.error(`Failed to get SIM top-up history for subscription ${subscriptionId}`, {
|
|
error: getErrorMessage(error),
|
|
userId,
|
|
subscriptionId,
|
|
});
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Change SIM plan
|
|
*/
|
|
async changeSimPlan(
|
|
userId: string,
|
|
subscriptionId: number,
|
|
request: SimPlanChangeRequest
|
|
): Promise<{ ipv4?: string; ipv6?: string }> {
|
|
try {
|
|
const { account } = await this.validateSimSubscription(userId, subscriptionId);
|
|
|
|
// Validate plan code format
|
|
if (!request.newPlanCode || request.newPlanCode.length < 3) {
|
|
throw new BadRequestException('Invalid plan code');
|
|
}
|
|
|
|
// Automatically set to 1st of next month
|
|
const nextMonth = new Date();
|
|
nextMonth.setMonth(nextMonth.getMonth() + 1);
|
|
nextMonth.setDate(1); // Set to 1st of the month
|
|
|
|
// Format as YYYYMMDD for Freebit API
|
|
const year = nextMonth.getFullYear();
|
|
const month = String(nextMonth.getMonth() + 1).padStart(2, '0');
|
|
const day = String(nextMonth.getDate()).padStart(2, '0');
|
|
const scheduledAt = `${year}${month}${day}`;
|
|
|
|
this.logger.log(`Auto-scheduled plan change to 1st of next month: ${scheduledAt}`, {
|
|
userId,
|
|
subscriptionId,
|
|
account,
|
|
newPlanCode: request.newPlanCode,
|
|
});
|
|
|
|
const result = await this.freebititService.changeSimPlan(account, request.newPlanCode, {
|
|
assignGlobalIp: false, // Default to no global IP
|
|
scheduledAt: scheduledAt,
|
|
});
|
|
|
|
this.logger.log(`Successfully changed SIM plan for subscription ${subscriptionId}`, {
|
|
userId,
|
|
subscriptionId,
|
|
account,
|
|
newPlanCode: request.newPlanCode,
|
|
scheduledAt: scheduledAt,
|
|
assignGlobalIp: false,
|
|
});
|
|
|
|
return result;
|
|
} catch (error) {
|
|
this.logger.error(`Failed to change SIM plan for subscription ${subscriptionId}`, {
|
|
error: getErrorMessage(error),
|
|
userId,
|
|
subscriptionId,
|
|
newPlanCode: request.newPlanCode,
|
|
});
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Update SIM features (voicemail, call waiting, roaming, network type)
|
|
*/
|
|
async updateSimFeatures(
|
|
userId: string,
|
|
subscriptionId: number,
|
|
request: SimFeaturesUpdateRequest
|
|
): Promise<void> {
|
|
try {
|
|
const { account } = await this.validateSimSubscription(userId, subscriptionId);
|
|
|
|
// Validate network type if provided
|
|
if (request.networkType && !['4G', '5G'].includes(request.networkType)) {
|
|
throw new BadRequestException('networkType must be either "4G" or "5G"');
|
|
}
|
|
|
|
await this.freebititService.updateSimFeatures(account, request);
|
|
|
|
this.logger.log(`Updated SIM features for subscription ${subscriptionId}`, {
|
|
userId,
|
|
subscriptionId,
|
|
account,
|
|
...request,
|
|
});
|
|
} catch (error) {
|
|
this.logger.error(`Failed to update SIM features for subscription ${subscriptionId}`, {
|
|
error: getErrorMessage(error),
|
|
userId,
|
|
subscriptionId,
|
|
...request,
|
|
});
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Cancel SIM service
|
|
*/
|
|
async cancelSim(userId: string, subscriptionId: number, request: SimCancelRequest = {}): Promise<void> {
|
|
try {
|
|
const { account } = await this.validateSimSubscription(userId, subscriptionId);
|
|
|
|
// Validate scheduled date if provided
|
|
if (request.scheduledAt && !/^\d{8}$/.test(request.scheduledAt)) {
|
|
throw new BadRequestException('Scheduled date must be in YYYYMMDD format');
|
|
}
|
|
|
|
await this.freebititService.cancelSim(account, request.scheduledAt);
|
|
|
|
this.logger.log(`Successfully cancelled SIM for subscription ${subscriptionId}`, {
|
|
userId,
|
|
subscriptionId,
|
|
account,
|
|
});
|
|
} catch (error) {
|
|
this.logger.error(`Failed to cancel SIM for subscription ${subscriptionId}`, {
|
|
error: getErrorMessage(error),
|
|
userId,
|
|
subscriptionId,
|
|
});
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Reissue eSIM profile
|
|
*/
|
|
async reissueEsimProfile(userId: string, subscriptionId: number): Promise<void> {
|
|
try {
|
|
const { account } = await this.validateSimSubscription(userId, subscriptionId);
|
|
|
|
// First check if this is actually an eSIM
|
|
const simDetails = await this.freebititService.getSimDetails(account);
|
|
if (simDetails.simType !== 'esim') {
|
|
throw new BadRequestException('This operation is only available for eSIM subscriptions');
|
|
}
|
|
|
|
await this.freebititService.reissueEsimProfile(account);
|
|
|
|
this.logger.log(`Successfully reissued eSIM profile for subscription ${subscriptionId}`, {
|
|
userId,
|
|
subscriptionId,
|
|
account,
|
|
});
|
|
} catch (error) {
|
|
this.logger.error(`Failed to reissue eSIM profile for subscription ${subscriptionId}`, {
|
|
error: getErrorMessage(error),
|
|
userId,
|
|
subscriptionId,
|
|
});
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get comprehensive SIM information (details + usage combined)
|
|
*/
|
|
async getSimInfo(userId: string, subscriptionId: number): Promise<{
|
|
details: SimDetails;
|
|
usage: SimUsage;
|
|
}> {
|
|
try {
|
|
const [details, usage] = await Promise.all([
|
|
this.getSimDetails(userId, subscriptionId),
|
|
this.getSimUsage(userId, subscriptionId),
|
|
]);
|
|
|
|
// If Freebit doesn't return remaining quota, derive it from plan code (e.g., PASI_50G)
|
|
// by subtracting measured usage (today + recentDays) from the plan cap.
|
|
const normalizeNumber = (n: number) => (isFinite(n) && n > 0 ? n : 0);
|
|
const usedMb = normalizeNumber(usage.todayUsageMb) + usage.recentDaysUsage.reduce((sum, d) => sum + normalizeNumber(d.usageMb), 0);
|
|
|
|
const planCapMatch = (details.planCode || '').match(/(\d+)\s*G/i);
|
|
if ((details.remainingQuotaMb === 0 || details.remainingQuotaMb == null) && planCapMatch) {
|
|
const capGb = parseInt(planCapMatch[1], 10);
|
|
if (!isNaN(capGb) && capGb > 0) {
|
|
const capMb = capGb * 1000;
|
|
const remainingMb = Math.max(capMb - usedMb, 0);
|
|
details.remainingQuotaMb = Math.round(remainingMb * 100) / 100;
|
|
details.remainingQuotaKb = Math.round(details.remainingQuotaMb * 1000);
|
|
}
|
|
}
|
|
|
|
return { details, usage };
|
|
} catch (error) {
|
|
this.logger.error(`Failed to get comprehensive SIM info for subscription ${subscriptionId}`, {
|
|
error: getErrorMessage(error),
|
|
userId,
|
|
subscriptionId,
|
|
});
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Convert technical errors to user-friendly messages for SIM operations
|
|
*/
|
|
private getUserFriendlySimError(technicalError: string): string {
|
|
if (!technicalError) {
|
|
return "SIM operation failed. Please try again or contact support.";
|
|
}
|
|
|
|
const errorLower = technicalError.toLowerCase();
|
|
|
|
// Freebit API errors
|
|
if (errorLower.includes('api error: ng') || errorLower.includes('account not found')) {
|
|
return "SIM account not found. Please contact support to verify your SIM configuration.";
|
|
}
|
|
|
|
if (errorLower.includes('authentication failed') || errorLower.includes('auth')) {
|
|
return "SIM service is temporarily unavailable. Please try again later.";
|
|
}
|
|
|
|
if (errorLower.includes('timeout') || errorLower.includes('network')) {
|
|
return "SIM service request timed out. Please try again.";
|
|
}
|
|
|
|
// WHMCS errors
|
|
if (errorLower.includes('invalid permissions') || errorLower.includes('not allowed')) {
|
|
return "SIM service is temporarily unavailable. Please contact support for assistance.";
|
|
}
|
|
|
|
// Generic errors
|
|
if (errorLower.includes('failed') || errorLower.includes('error')) {
|
|
return "SIM operation failed. Please try again or contact support.";
|
|
}
|
|
|
|
// Default fallback
|
|
return "SIM operation failed. Please try again or contact support.";
|
|
}
|
|
}
|