-- SMS Notification Preferences Table

CREATE TABLE `sms_notification_preferences` (

`id` int(11) NOT NULL AUTO_INCREMENT,

`customer_id` int(11) NOT NULL,

`phone_number` varchar(20) NOT NULL,

`phone_verified` tinyint(1) DEFAULT 0,

`order_confirmation` tinyint(1) DEFAULT 1,

`payment_confirmation` tinyint(1) DEFAULT 1,

`shipping_notification` tinyint(1) DEFAULT 1,

`delivery_confirmation` tinyint(1) DEFAULT 1,

`order_cancelled` tinyint(1) DEFAULT 1,

`promotional_messages` tinyint(1) DEFAULT 0,

`opt_in_date` timestamp DEFAULT CURRENT_TIMESTAMP,

`opt_out_date` timestamp NULL,

`created_at` timestamp DEFAULT CURRENT_TIMESTAMP,

`updated_at` timestamp DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,

PRIMARY KEY (`id`),

UNIQUE KEY `customer_id` (`customer_id`),

INDEX `phone_number` (`phone_number`)

);

-- SMS Message Queue Table

CREATE TABLE `sms_message_queue` (

`id` int(11) NOT NULL AUTO_INCREMENT,

`customer_id` int(11),

`order_id` int(11),

`phone_number` varchar(20) NOT NULL,

`message_type` varchar(50) NOT NULL,

`message_content` text NOT NULL,

`priority` tinyint(1) DEFAULT 1,

`status` enum('pending','processing','sent','failed','cancelled') DEFAULT 'pending',

`attempts` tinyint(1) DEFAULT 0,

`max_attempts` tinyint(1) DEFAULT 3,

`scheduled_at` timestamp DEFAULT CURRENT_TIMESTAMP,

`sent_at` timestamp NULL,

`error_message` text,

`provider_response` text,

`created_at` timestamp DEFAULT CURRENT_TIMESTAMP,

`updated_at` timestamp DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,

PRIMARY KEY (`id`),

INDEX `status_scheduled` (`status`, `scheduled_at`),

INDEX `customer_order` (`customer_id`, `order_id`)

);

-- SMS Delivery Log Table

CREATE TABLE `sms_delivery_log` (

`id` int(11) NOT NULL AUTO_INCREMENT,

`queue_id` int(11) NOT NULL,

`provider_id` varchar(100),

`delivery_status` enum('delivered','failed','unknown') DEFAULT 'unknown',

`delivery_timestamp` timestamp NULL,

`provider_status_code` varchar(20),

`provider_error_code` varchar(20),

`cost` decimal(10,6),

`created_at` timestamp DEFAULT CURRENT_TIMESTAMP,

PRIMARY KEY (`id`),

INDEX `queue_id` (`queue_id`),

INDEX `delivery_status` (`delivery_status`)

);

<?php

namespace YourCompany\SmsNotification\Observer;

use Magento\Framework\Event\Observer;

use Magento\Framework\Event\ObserverInterface;

use YourCompany\SmsNotification\Service\SmsNotificationService;

use YourCompany\SmsNotification\Helper\ConfigHelper;

use Psr\Log\LoggerInterface;

class OrderStatusChangeObserver implements ObserverInterface

{

private $smsNotificationService;

private $configHelper;

private $logger;

public function __construct(

SmsNotificationService $smsNotificationService,

ConfigHelper $configHelper,

LoggerInterface $logger

) {

$this->smsNotificationService = $smsNotificationService;

$this->configHelper = $configHelper;

$this->logger = $logger;

}

public function execute(Observer $observer)

{

if (!$this->configHelper->isEnabled()) {

return;

}

$order = $observer->getEvent()->getOrder();

$originalOrder = $order->getOrigData();

$currentStatus = $order->getStatus();

$previousStatus = $originalOrder['status'] ?? null;

if ($currentStatus !== $previousStatus) {

try {

$this->smsNotificationService->handleOrderStatusChange(

$order,

$previousStatus,

$currentStatus

);

} catch (\Exception $e) {

$this->logger->error(

'SMS notification failed for order status change',

[

'order_id' => $order->getId(),

'previous_status' => $previousStatus,

'current_status' => $currentStatus,

'error' => $e->getMessage()

]

);

}

}

}

}

<?php

namespace YourCompany\SmsNotification\Service;

use YourCompany\SmsNotification\Model\SmsQueueRepository;

use YourCompany\SmsNotification\Model\SmsQueue;

use YourCompany\SmsNotification\Service\Provider\SmsProviderInterface;

use YourCompany\SmsNotification\Service\TemplateProcessor;

use YourCompany\SmsNotification\Helper\ConfigHelper;

use Magento\Framework\Stdlib\DateTime\DateTime;

class SmsNotificationService

{

private $smsQueueRepository;

private $smsProvider;

private $templateProcessor;

private $configHelper;

private $dateTime;

public function __construct(

SmsQueueRepository $smsQueueRepository,

SmsProviderInterface $smsProvider,

TemplateProcessor $templateProcessor,

ConfigHelper $configHelper,

DateTime $dateTime

) {

$this->smsQueueRepository = $smsQueueRepository;

$this->smsProvider = $smsProvider;

$this->templateProcessor = $templateProcessor;

$this->configHelper = $configHelper;

$this->dateTime = $dateTime;

}

<?php

namespace YourCompany\SmsNotification\Service\Provider;

interface SmsProviderInterface

{

public function sendSms(string $phoneNumber, string $message, array $options = []): SmsResult;

public function getDeliveryReport(string $messageId): DeliveryReport;

public function validatePhoneNumber(string $phoneNumber): bool;

public function getBalance(): float;

public function getSupportedCountries(): array;

}

<?php

namespace YourCompany\SmsNotification\Service\Provider;

use Twilio\Rest\Client;

use YourCompany\SmsNotification\Helper\ConfigHelper;

class TwilioProvider implements SmsProviderInterface

{

private $client;

private $configHelper;

public function __construct(ConfigHelper $configHelper)

{

$this->configHelper = $configHelper;

$this->client = new Client(

$this->configHelper->getTwilioAccountSid(),

$this->configHelper->getTwilioAuthToken()

);

}

public function sendSms(string $phoneNumber, string $message, array $options = []): SmsResult

{

try {

$twilioMessage = $this->client->messages->create(

$phoneNumber,

[

'from' => $this->configHelper->getTwilioFromNumber(),

'body' => $message,

'statusCallback' => $this->configHelper->getWebhookUrl(),

'provideFeedback' => true

]

);

return new SmsResult(

true,

$twilioMessage->sid,

$twilioMessage->status,

json_encode($twilioMessage->toArray())

);

} catch (\Exception $e) {

return new SmsResult(

false,

null,

'failed',

null,

$e->getMessage()

);

}

}

public function getDeliveryReport(string $messageId): DeliveryReport

{

try {

$message = $this->client->messages($messageId)->fetch();

return new DeliveryReport(

$messageId,

$message->status,

$message->dateUpdated,

$message->errorCode,

$message->errorMessage,

$message->price ? (float)$message->price : 0.0

);

} catch (\Exception $e) {

return new DeliveryReport($messageId, 'unknown', null, null, $e->getMessage());

}

}

public function validatePhoneNumber(string $phoneNumber): bool

{

try {

$lookup = $this->client->lookups->v1->phoneNumbers($phoneNumber)->fetch();

return $lookup->phoneNumber !== null;

} catch (\Exception $e) {

return false;

}

}

}

Welcome to [STORE_NAME], [FIRST_NAME]!

Your order #[ORDER_ID] for $[TOTAL] is confirmed.

As a new customer, enjoy free shipping

on your next order with code WELCOME10.

Track: [emmo.net.co]

VIP Alert: Your order #[ORDER_ID] has shipped with priority handling!

Tracking: [URL]

Thank you for being a valued customer.

Dedicated support: [VIP_PHONE]

Holiday order #[ORDER_ID] shipped!

Guaranteed delivery by [HOLIDAY_DATE].

Track: [URL]

Need gift wrapping?

Add to your next order: [LINK]

Order #[ORDER_ID] shipped to [CITY]! Local delivery partner [CARRIER] will deliver in [LOCAL_TIMEFRAME]. Track: [URL]

<?php

namespace YourCompany\SmsNotification\Service;

class OptInService

{

public function initiateOptIn($customerId, $phoneNumber)

{

// Generate secure verification code

$verificationCode = $this->generateSecureCode();

// Store pending opt-in with expiration

$this->storePendingOptIn($customerId, $phoneNumber, $verificationCode);

// Send verification SMS

$message = "Confirm SMS notifications for [STORE_NAME]: Reply with code {$verificationCode} or click [VERIFY_LINK]";

$this->sendVerificationSms($phoneNumber, $message);

// Log opt-in attempt for compliance

$this->logOptInAttempt($customerId, $phoneNumber, 'initiated');

}

public function confirmOptIn($phoneNumber, $verificationCode)

{

$pendingOptIn = $this->getPendingOptIn($phoneNumber, $verificationCode);

if (!$pendingOptIn || $this->isExpired($pendingOptIn)) {

throw new \Exception('Invalid or expired verification code');

}

// Create confirmed opt-in record

$this->createOptInRecord($pendingOptIn);

// Send welcome message

$this->sendWelcomeSms($phoneNumber);

// Clean up pending record

$this->cleanupPendingOptIn($pendingOptIn);

// Log confirmation for compliance

$this->logOptInAttempt($pendingOptIn->getCustomerId(), $phoneNumber, 'confirmed');

}

public function processOptOut($phoneNumber, $method = 'reply')

{

$preference = $this->getPreferenceByPhone($phoneNumber);

if ($preference) {

$preference->setOptOutDate(new \DateTime());

$preference->setOptOutMethod($method);

$this->savePreference($preference);

// Send opt-out confirmation

$message = "You've been unsubscribed from SMS notifications. To re-subscribe, visit [RESUBSCRIBE_LINK]";

$this->sendOptOutConfirmation($phoneNumber, $message);

// Log opt-out for compliance

$this->logOptOutEvent($preference->getCustomerId(), $phoneNumber, $method);

}

}

}

<?php

namespace YourCompany\SmsNotification\Service;

class QueueProcessor

{

private $maxConcurrentProcessors = 5;

private $batchSizes = [

1 => 10, // Critical

2 => 25, // High

3 => 50, // Medium

4 => 100 // Low

];

public function processQueues()

{

$activeProcessors = $this->getActiveProcessorCount();

if ($activeProcessors >= $this->maxConcurrentProcessors) {

return;

}

for ($priority = 1; $priority <= 4; $priority++) {

if ($this->hasMessagesInQueue($priority)) {

$this->spawnProcessor($priority);

if (++$activeProcessors >= $this->maxConcurrentProcessors) {

break;

}

}

}

}

private function spawnProcessor($priority)

{

$batchSize = $this->batchSizes[$priority];

$messages = $this->getQueuedMessages($priority, $batchSize);

foreach ($messages as $message) {

try {

$this->processWithRateLimit($message);

$this->updateMessageStatus($message, 'sent');

$this->logSuccess($message);

} catch (RateLimitException $e) {

$this->requeueWithDelay($message, $e->getRetryAfter());

} catch (\Exception $e) {

$this->handleProcessingError($message, $e);

}

}

}

private function processWithRateLimit($message)

{

$provider = $this->getProviderForMessage($message);

$rateLimiter = $this->getRateLimiter($provider);

if (!$rateLimiter->attempt()) {

throw new RateLimitException($rateLimiter->getRetryAfter());

}

return $provider->sendSms(

$message->getPhoneNumber(),

$message->getMessageContent(),

$message->getMetadata()

);

}

private function handleProcessingError($message, $exception)

{

$attempts = $message->getAttempts();

$maxAttempts = $message->getMaxAttempts();

if ($attempts < $maxAttempts) {

$delay = min(300, pow(2, $attempts) * 30);

$this->requeueWithDelay($message, $delay);

} else {

$this->markAsFailed($message, $exception->getMessage());

$this->notifyAdministrators($message, $exception);

}

}

}

-- Optimized indexes for high-volume SMS operations

CREATE INDEX idx_sms_queue_priority_status_scheduled ON sms_message_queue (priority, status, scheduled_at);

CREATE INDEX idx_sms_queue_customer_status ON sms_message_queue (customer_id, status);

CREATE INDEX idx_sms_queue_order_status ON sms_message_queue (order_id, status);

CREATE INDEX idx_sms_delivery_log_status_timestamp ON sms_delivery_log (delivery_status, delivery_timestamp);

-- Partitioning for large message logs

ALTER TABLE sms_delivery_log

PARTITION BY RANGE (UNIX_TIMESTAMP(created_at)) (

PARTITION p_2024_01 VALUES LESS THAN (UNIX_TIMESTAMP('2024-02-01')) ,

PARTITION p_2024_02 VALUES LESS THAN (UNIX_TIMESTAMP('2024-03-01')) ,

PARTITION p_2024_03 VALUES LESS THAN (UNIX_TIMESTAMP('2024-04-01')) ,

-- Continue partitioning by month

PARTITION p_future VALUES LESS THAN MAXVALUE

);

<?php

namespace YourCompany\SmsNotification\Service;

use Magento\Framework\Cache\FrontendInterface;

class CacheManager

{

private $cache;

private $cacheLifetime = 3600; // 1 hour

public function __construct(FrontendInterface $cache)

{

$this->cache = $cache;

}

public function getCustomerPreferences($customerId)

{

$cacheKey = "sms_preferences_{$customerId}";

$cached = $this->cache->load($cacheKey);

if ($cached) {

return unserialize($cached);

}

$preferences = $this->loadPreferencesFromDatabase($customerId);

$this->cache->save(

serialize($preferences),

$cacheKey,

['sms_preferences'],

$this->cacheLifetime

);

return $preferences;

}

public function getTemplate($templateId, $storeId)

{

$cacheKey = "sms_template_{$templateId}_{$storeId}";

$cached = $this->cache->load($cacheKey);

if ($cached) {

return unserialize($cached);

}

$template = $this->loadTemplateFromDatabase($templateId, $storeId);

$this->cache->save(

serialize($template),

$cacheKey,

['sms_templates'],

$this->cacheLifetime * 24 // Templates cache longer

);

return $template;

}

public function invalidateCustomerCache($customerId)

{

$this->cache->remove("sms_preferences_{$customerId}");

}

public function invalidateTemplateCache($templateId = null)

{

if ($templateId) {

$this->cache->clean(\Zend_Cache::CLEANING_MODE_MATCHING_TAG, ["sms_template_{$templateId}"]);

} else {

$this->cache->clean(\Zend_Cache::CLEANING_MODE_MATCHING_TAG, ['sms_templates']);

}

}

}

<?php

namespace YourCompany\SmsNotification\Service;

class ProviderManager

{

private $providers = [];

private $fallbackChain = [];

private $healthChecker;

public function __construct(

array $providers,

array $fallbackChain,

ProviderHealthChecker $healthChecker

) {

$this->providers = $providers;

$this->fallbackChain = $fallbackChain;

$this->healthChecker = $healthChecker;

}

public function sendSms($phoneNumber, $message, $options = [])

{

$countryCode = $this->extractCountryCode($phoneNumber);

$primaryProvider = $this->selectPrimaryProvider($countryCode, $options);

try {

if ($this->healthChecker->isHealthy($primaryProvider)) {

return $primaryProvider->sendSms($phoneNumber, $message, $options);

}

} catch (\Exception $e) {

$this->logProviderFailure($primaryProvider, $e);

}

foreach ($this->fallbackChain as $providerId) {

$provider = $this->providers[$providerId];

try {

if ($this->healthChecker->isHealthy($provider)) {

$result = $provider->sendSms($phoneNumber, $message, $options);

$this->logFallbackUsage($provider, $primaryProvider);

return $result;

}

} catch (\Exception $e) {

$this->logProviderFailure($provider, $e);

continue;

}

}

throw new \Exception('All SMS providers failed');

}

private function selectPrimaryProvider($countryCode, $options)

{

$routingRules = $this->getRoutingRules();

if (isset($routingRules[$countryCode])) {

return $this->providers[$routingRules[$countryCode]];

}

return $this->getLoadBalancedProvider($options);

}

private function getLoadBalancedProvider($options)

{

$availableProviders = array_filter($this->providers, function($provider) {

return $this->healthChecker->isHealthy($provider);

});

if (empty($availableProviders)) {

throw new \Exception('No healthy SMS providers available');

}

return $this->selectByWeight($availableProviders);

}

}

class ProviderHealthChecker

{

private $cache;

private $healthCheckInterval = 300;

public function isHealthy($provider)

{

$cacheKey = "provider_health_" . $provider->getId();

$lastCheck = $this->cache->load($cacheKey);

if ($lastCheck && (time() - $lastCheck['timestamp']) < $this->healthCheckInterval) {

return $lastCheck['healthy'];

}

$healthy = $this->performHealthCheck($provider);

$this->cache->save([

'healthy' => $healthy,

'timestamp' => time()

], $cacheKey, [], $this->healthCheckInterval);

return $healthy;

}

private function performHealthCheck($provider)

{

try {

$balance = $provider->getBalance();

return $balance > 0;

} catch (\Exception $e) {

return false;

}

}

}

<?php

namespace YourCompany\SmsNotification\Service;

class AnalyticsService

{

private $metricsCollector;

private $reportGenerator;

private $segmentationEngine;

public function trackDelivery($messageId, $deliveryData)

{

$metrics = [

'message_id' => $messageId,

'delivery_status' => $deliveryData->getStatus(),

'delivery_time' => $deliveryData->getDeliveryTime(),

'provider_id' => $deliveryData->getProviderId(),

'country_code' => $deliveryData->getCountryCode(),

'cost' => $deliveryData->getCost(),

'error_code' => $deliveryData->getErrorCode(),

'timestamp' => time()

];

$this->metricsCollector->record('sms_delivery', $metrics);

$this->checkDeliveryThresholds($deliveryData);

}

public function trackEngagement($messageId, $engagementType, $data = [])

{

$metrics = [

'message_id' => $messageId,

'engagement_type' => $engagementType,

'data' => $data,

'timestamp' => time()

];

$this->metricsCollector->record('sms_engagement', $metrics);

$this->updateCustomerEngagementScore($messageId, $engagementType);

}

public function generatePerformanceReport($dateRange, $filters = [])

{

$baseQuery = $this->buildReportQuery($dateRange, $filters);

$report = [

'summary' => $this->calculateSummaryMetrics($baseQuery),

'delivery_analysis' => $this->analyzeDeliveryPerformance($baseQuery),

'engagement_analysis' => $this->analyzeEngagementMetrics($baseQuery),

'cost_analysis' => $this->analyzeCostMetrics($baseQuery),

'provider_comparison' => $this->compareProviderPerformance($baseQuery),

'geographic_analysis' => $this->analyzeGeographicPerformance($baseQuery),

'recommendations' => $this->generateRecommendations($baseQuery)

];

return $this->reportGenerator->format($report, $filters['format'] ?? 'json');

}

private function calculateSummaryMetrics($query)

{

$results = $query->execute();

return [

'total_messages_sent' => $results->getTotalCount(),

'successful_deliveries' => $results->getSuccessfulCount(),

'delivery_rate' => $results->getDeliveryRate(),

'average_delivery_time' => $results->getAverageDeliveryTime(),

'total_cost' => $results->getTotalCost(),

'cost_per_message' => $results->getCostPerMessage(),

'engagement_rate' => $results->getEngagementRate(),

'conversion_rate' => $results->getConversionRate(),

'revenue_attributed' => $results->getAttributedRevenue(),

'roi' => $results->calculateROI()

];

}

private function analyzeDeliveryPerformance($query)

{

return [

'delivery_by_hour' => $query->groupBy('hour')->getDeliveryRates(),

'delivery_by_day' => $query->groupBy('day')->getDeliveryRates(),

'delivery_by_country' => $query->groupBy('country')->getDeliveryRates(),

'failure_analysis' => $query->analyzeFailures(),

'provider_performance' => $query->groupBy('provider')->getMetrics(),

'trending' => $query->getTrendAnalysis('delivery_rate', 30)

];

}

public function createCustomerSegments()

{

$segments = [

'high_engagement' => $this->segmentationEngine->findHighEngagementCustomers(),

'low_engagement' => $this->segmentationEngine->findLowEngagementCustomers(),

'new_customers' => $this->segmentationEngine->findNewCustomers(30),

'vip_customers' => $this->segmentationEngine->findVIPCustomers(),

'at_risk' => $this->segmentationEngine->findAtRiskCustomers(),

'potential_champions' => $this->segmentationEngine->findPotentialChampions()

];

return $segments;

}

private function generateRecommendations($query)

{

$performance = $query->getPerformanceMetrics();

$recommendations = [];

if ($performance['primary_provider_success_rate'] < 0.95) {

$recommendations[] = [

'type' => 'provider_optimization',

'priority' => 'high',

'message' => 'Primary SMS provider success rate below 95%. Consider switching providers or implementing failover.',

'action' => 'review_provider_performance'

];

}

$bestHours = $query->getBestPerformingHours();

if (count($bestHours) > 0) {

$recommendations[] = [

'type' => 'timing_optimization',

'priority' => 'medium',

'message' => "Peak engagement hours: " . implode(', ', $bestHours) . ". Schedule non-urgent messages during these times.",

'action' => 'optimize_send_times'

];

}

if ($performance['cost_per_conversion'] > $performance['benchmark_cost_per_conversion']) {

$recommendations[] = [

'type' => 'cost_optimization',

'priority' => 'medium',

'message' => 'SMS cost per conversion above benchmark. Review message frequency and targeting.',

'action' => 'optimize_targeting'

];

}

return $recommendations;

}

}

<?php

namespace YourCompany\SmsNotification\Block\Adminhtml;

class Dashboard extends \Magento\Backend\Block\Template

{

private $analyticsService;

private $dateTimeFactory;

public function __construct(

\Magento\Backend\Block\Template\Context $context,

\YourCompany\SmsNotification\Service\AnalyticsService $analyticsService,

\Magento\Framework\Stdlib\DateTime\DateTimeFactory $dateTimeFactory,

array $data = []

) {

$this->analyticsService = $analyticsService;

$this->dateTimeFactory = $dateTimeFactory;

parent::__construct($context, $data);

}

public function getTodayMetrics()

{

$today = $this->dateTimeFactory->create()->gmtDate('Y-m-d');

return $this->analyticsService->getDailyMetrics($today);

}

public function getRealtimeStats()

{

return [

'messages_in_queue' => $this->analyticsService->getQueueCount(),

'messages_sent_today' => $this->analyticsService->getTodayMessageCount(),

'current_delivery_rate' => $this->analyticsService->getCurrentDeliveryRate(),

'active_campaigns' => $this->analyticsService->getActiveCampaignCount(),

'system_health' => $this->analyticsService->getSystemHealthStatus()

];

}

public function getChartData($type, $period = 7)

{

switch ($type) {

case 'delivery_trends':

return $this->analyticsService->getDeliveryTrends($period);

case 'engagement_trends':

return $this->analyticsService->getEngagementTrends($period);

case 'cost_trends':

return $this->analyticsService->getCostTrends($period);

case 'provider_comparison':

return $this->analyticsService->getProviderComparison($period);

default:

return [];

}

}

}

<?php

namespace YourCompany\SmsNotification\Service;

class GdprComplianceService

{

const LAWFUL_BASIS_CONSENT = 'consent';

const LAWFUL_BASIS_CONTRACT = 'contract';

const LAWFUL_BASIS_LEGITIMATE_INTEREST = 'legitimate_interest';

private $consentManager;

private $dataProcessor;

private $auditLogger;

public function validateProcessingLawfulness($customerId, $processingType)

{

$customer = $this->getCustomer($customerId);

$consent = $this->consentManager->getConsent($customerId, 'sms_marketing');

switch ($processingType) {

case 'transactional_sms':

return $this->validateContractualBasis($customer, $processingType);

case 'marketing_sms':

return $this->validateConsentBasis($consent);

case 'service_sms':

return $this->validateLegitimateInterest($customer, $processingType);

default:

return false;

}

}

public function handleDataSubjectRequest($customerId, $requestType)

{

$this->auditLogger->logDataSubjectRequest($customerId, $requestType);

switch ($requestType) {

case 'access':

return $this->processAccessRequest($customerId);

case 'rectification':

return $this->processRectificationRequest($customerId);

case 'erasure':

return $this->processErasureRequest($customerId);

case 'portability':

return $this->processPortabilityRequest($customerId);

case 'restriction':

return $this->processRestrictionRequest($customerId);

case 'objection':

return $this->processObjectionRequest($customerId);

}

}

private function processAccessRequest($customerId)

{

$smsData = [

'preferences' => $this->getSmsPreferences($customerId),

'message_history' => $this->getMessageHistory($customerId),

'consent_records' => $this->getConsentHistory($customerId),

'opt_out_history' => $this->getOptOutHistory($customerId)

];

return $this->dataProcessor->exportToPortableFormat($smsData, 'json');

}

private function processErasureRequest($customerId)

{

if (!$this->canProcessErasure($customerId)) {

throw new \Exception('Erasure not possible due to legal obligations');

}

$this->anonymizeSmsData($customerId);

$this->removePersonalIdentifiers($customerId);

return true;

}

public function generateComplianceReport($dateRange)

{

return [

'consent_metrics' => $this->calculateConsentMetrics($dateRange),

'data_subject_requests' => $this->getDataSubjectRequestStats($dateRange),

'processing_activities' => $this->getProcessingActivityLog($dateRange),

'data_breaches' => $this->getDataBreachLog($dateRange),

'retention_compliance' => $this->checkRetentionCompliance(),

'third_party_sharing' => $this->getThirdPartySharing($dateRange)

];

}

}

<?php

namespace YourCompany\SmsNotification\Service;

class PhoneNumberSecurity

{

private $encryptor;

private $validator;

private $fraudDetector;

public function __construct(

\Magento\Framework\Encryption\EncryptorInterface $encryptor,

PhoneNumberValidator $validator,

FraudDetector $fraudDetector

) {

$this->encryptor = $encryptor;

$this->validator = $validator;

$this->fraudDetector = $fraudDetector;

}

public function securePhoneNumber($phoneNumber, $customerId)

{

if (!$this->validator->isValid($phoneNumber)) {

throw new \InvalidArgumentException('Invalid phone number format');

}

if ($this->fraudDetector->isSuspicious($phoneNumber, $customerId)) {

throw new \Exception('Phone number flagged for suspicious activity');

}

$normalized = $this->validator->normalize($phoneNumber);

$encrypted = $this->encryptor->encrypt($normalized);

$hash = hash('sha256', $normalized . $this->getSalt());

return [

'encrypted' => $encrypted,

'hash' => $hash,

'country_code' => $this->validator->getCountryCode($normalized)

];

}

public function decryptPhoneNumber($encryptedNumber)

{

return $this->encryptor->decrypt($encryptedNumber);

}

public function maskPhoneNumber($phoneNumber)

{

$length = strlen($phoneNumber);

if ($length < 8) {

return str_repeat('*', $length);

}

$start = substr($phoneNumber, 0, 4);

$end = substr($phoneNumber, -4);

$middle = str_repeat('*', $length - 8);

return $start . $middle . $end;

}

private function getSalt()

{

return 'sms_notification_salt_' . $this->encryptor->hash('magento_sms');

}

}

class FraudDetector

{

private $riskRules;

private $blacklistManager;

private $rateLimiter;

public function isSuspicious($phoneNumber, $customerId)

{

$riskScore = 0;

$riskScore += $this->checkBlacklist($phoneNumber);

$riskScore += $this->checkRateLimit($phoneNumber, $customerId);

$riskScore += $this->checkGeographicRisk($phoneNumber);

$riskScore += $this->checkBehaviorPattern($customerId);

return $riskScore > $this->getRiskThreshold();

}

private function checkBlacklist($phoneNumber)

{

if ($this->blacklistManager->isBlacklisted($phoneNumber)) {

return 100;

}

return $this->blacklistManager->getSimilarityRisk($phoneNumber);

}

private function checkRateLimit($phoneNumber, $customerId)

{

$attempts = $this->rateLimiter->getAttempts($phoneNumber, 3600);

if ($attempts > 10) {

return 50;

}

return 0;

}

}

<?php

namespace YourCompany\SmsNotification\Service;

class TcpaComplianceService

{

private $consentManager;

private $timeZoneService;

private $blacklistManager;

public function validateTcpaCompliance($phoneNumber, $messageType, $customerId)

{

$violations = [];

if (!$this->hasExplicitConsent($customerId, $messageType)) {

$violations[] = 'Missing explicit consent for SMS communications';

}

if (!$this->isWithinAllowedHours($phoneNumber)) {

$violations[] = 'Message scheduled outside allowed hours (8 AM - 9 PM)';

}

if ($this->isOnDoNotCallRegistry($phoneNumber)) {

$violations[] = 'Phone number on Do Not Call registry';

}

if ($this->hasOptedOut($phoneNumber)) {

$violations[] = 'Customer has opted out of SMS communications';

}

if (!empty($violations)) {

throw new TcpaViolationException(implode('; ', $violations));

}

return true;

}

private function isWithinAllowedHours($phoneNumber)

{

$timezone = $this->timeZoneService->getTimezoneByPhoneNumber($phoneNumber);

$currentTime = new \DateTime('now', new \DateTimeZone($timezone));

$hour = (int)$currentTime->format('H');

return $hour >= 8 && $hour < 21; // 8 AM to 9 PM

}

public function recordConsentEvent($customerId, $phoneNumber, $consentType, $method)

{

$consentRecord = [

'customer_id' => $customerId,

'phone_number' => $this->hashPhoneNumber($phoneNumber),

'consent_type' => $consentType,

'consent_method' => $method,

'ip_address' => $this->getClientIpAddress(),

'user_agent' => $this->getUserAgent(),

'timestamp' => new \DateTime(),

'consent_text' => $this->getConsentText($consentType),

'compliance_version' => $this->getCurrentComplianceVersion()

];

$this->consentManager->recordConsent($consentRecord);

}

public function generateComplianceAudit($dateRange)

{

return [

'consent_records' => $this->getConsentRecords($dateRange),

'opt_out_requests' => $this->getOptOutRequests($dateRange),

'time_violations' => $this->getTimeViolations($dateRange),

'suppression_list_updates' => $this->getSuppressionListUpdates($dateRange),

'complaint_records' => $this->getComplaintRecords($dateRange),

'regulatory_requests' => $this->getRegulatoryRequests($dateRange)

];

}

}

<?php

namespace YourCompany\SmsNotification\Service;

class InternationalSmsService

{

private $countryRules;

private $providerRouter;

private $complianceChecker;

public function __construct(

CountryRulesRepository $countryRules,

ProviderRouter $providerRouter,

ComplianceChecker $complianceChecker

) {

$this->countryRules = $countryRules;

$this->providerRouter = $providerRouter;

$this->complianceChecker = $complianceChecker;

}

public function sendInternationalSms($phoneNumber, $message, $options = [])

{

$countryCode = $this->extractCountryCode($phoneNumber);

$countryRules = $this->countryRules->getRules($countryCode);

$this->complianceChecker->validateCountryCompliance($countryCode, $options);

$localizedMessage = $this->localizeMessage($message, $countryCode);

$provider = $this->providerRouter->getOptimalProvider($countryCode);

$sendingOptions = $this->applySendingRules($options, $countryRules);

return $provider->sendSms($phoneNumber, $localizedMessage, $sendingOptions);

}