PHP code example of mbsoft31 / loyalty-rewards

    
        
<?php
require_once('vendor/autoload.php');

/* Start to develop here. Best regards https://php-download.com/ */

    

mbsoft31 / loyalty-rewards example snippets

declare(strict_types=1);

use LoyaltyRewards\Core\Services\LoyaltyService;
use LoyaltyRewards\Core\Services\AuditService;
use LoyaltyRewards\Core\Services\FraudDetectionService;
use LoyaltyRewards\Core\Engine\RulesEngine;
use LoyaltyRewards\Domain\ValueObjects\{ConversionRate, Currency, CustomerId, Money, Points, TransactionContext};
use LoyaltyRewards\Infrastructure\Database\DatabaseAccountRepository;
use LoyaltyRewards\Infrastructure\Database\DatabaseAuditRepository;
use LoyaltyRewards\Infrastructure\Database\DatabaseConnectionFactory;
use LoyaltyRewards\Infrastructure\Database\DatabaseTransactionRepository;
use LoyaltyRewards\Rules\Earning\CategoryMultiplierRule;
use LoyaltyRewards\Rules\Earning\TierBonusRule;
use LoyaltyRewards\Rules\Redemption\BasicRedemptionRule;
use Psr\EventDispatcher\EventDispatcherInterface;
use Psr\Log\NullLogger;

$pdo = DatabaseConnectionFactory::create([
    'driver' => 'sqlite',
    'database' => ':memory:',
]);

$accountRepository = new DatabaseAccountRepository(
    $pdo,
    new DatabaseTransactionRepository($pdo)
);
$auditRepository = new DatabaseAuditRepository($pdo);

$rulesEngine = new RulesEngine(new NullLogger);
$rulesEngine->addEarningRule(new CategoryMultiplierRule('electronics', 2.0, ConversionRate::standard()));
$rulesEngine->addEarningRule(new TierBonusRule('gold', 1.25, ConversionRate::standard()));
$rulesEngine->addRedemptionRule(new BasicRedemptionRule(Currency::USD(), 100, 100));

$loyaltyService = new LoyaltyService(
    $accountRepository,
    $rulesEngine,
    new FraudDetectionService(new NullLogger),
    new AuditService($auditRepository, new NullLogger),
    new class implements EventDispatcherInterface {
        public function dispatch(object $event): object
        {
            return $event;
        }
    },
    new NullLogger
);

// Create customer account
$customerId = CustomerId::fromString('customer_12345');
$loyaltyService->createAccount($customerId);

// Earn points from purchase
$result = $loyaltyService->earnPoints(
    $customerId,
    Money::fromDollars(99.99, Currency::USD()),
    TransactionContext::earning('electronics', 'online_store')
);
$loyaltyService->confirmPendingPoints($customerId);
$availableBalance = $loyaltyService->getAccountBalance($customerId);

echo "Earned: {$result->pointsEarned->value()} points\n";
echo "Balance (available): {$availableBalance->value()} points\n";

// Redeem points
$redemption = $loyaltyService->redeemPoints(
    $customerId,
    Points::fromInt(1000),
    TransactionContext::redemption(['channel' => 'store'])
);

echo "Redeemed: {$redemption->redemptionValue->toDollars()} {$redemption->redemptionValue->currency()->code()}";

use LoyaltyRewards\Domain\ValueObjects\{ConversionRate, Currency, CustomerId, Money, TransactionContext};
use LoyaltyRewards\Rules\Earning\{CategoryMultiplierRule, TierBonusRule};

$goldCustomerId = CustomerId::fromString('customer_gold_100');
$loyaltyService->createAccount($goldCustomerId);

// Setup category-based earning
$rulesEngine->addEarningRule(new CategoryMultiplierRule('electronics', 3.0, ConversionRate::standard()));
$rulesEngine->addEarningRule(new CategoryMultiplierRule('books', 2.0, ConversionRate::standard()));
$rulesEngine->addEarningRule(new CategoryMultiplierRule('groceries', 1.5, ConversionRate::standard()));

// Tier-based bonuses
$rulesEngine->addEarningRule(new TierBonusRule('gold', 1.25, ConversionRate::standard()));
$rulesEngine->addEarningRule(new TierBonusRule('platinum', 1.5, ConversionRate::standard()));

// Customer purchases $200 laptop (electronics + gold tier)
$result = $loyaltyService->earnPoints(
    $goldCustomerId,
    Money::fromDollars(200.00, Currency::USD()),
    TransactionContext::earning('electronics', null, ['tier' => 'gold'])
);
// Earns: 200 * 100 * 3.0 * 1.25 = 75,000 points

use DateTimeImmutable;
use LoyaltyRewards\Domain\ValueObjects\{ConversionRate, Currency, CustomerId, Money, TransactionContext};
use LoyaltyRewards\Rules\Earning\TimeBasedRule;

$customerId = CustomerId::fromString('customer_restaurant_100');
$loyaltyService->createAccount($customerId);

// Happy hour promotions
$happyHourRule = new TimeBasedRule(
    new DateTimeImmutable('2025-01-01 14:00:00'),
    new DateTimeImmutable('2025-12-31 17:00:00'),
    2.0, // Double points
    ConversionRate::standard(),
    ['monday', 'tuesday', 'wednesday']
);

$rulesEngine->addEarningRule($happyHourRule);

// Customer orders during happy hour
$result = $loyaltyService->earnPoints(
    $customerId,
    Money::fromDollars(12.50, Currency::USD()),
    TransactionContext::earning('food', 'mobile_app')
);
// Earns: 12.50 * 100 * 2.0 = 2,500 points

use LoyaltyRewards\Domain\ValueObjects\{Currency, CustomerId, Money, TransactionContext};

$referrerId = CustomerId::fromString('customer_referrer_200');
$loyaltyService->createAccount($referrerId);

// Referral bonus
$result = $loyaltyService->earnPoints(
    $referrerId,
    Money::zero(Currency::USD()), // No monetary transaction
    TransactionContext::create([
        'type' => 'referral_conversion',
        'referred_customer' => 'new_customer_789',
        'subscription_tier' => 'pro'
    ])
);

use LoyaltyRewards\Infrastructure\Database\DatabaseConnectionFactory;

$pdo = DatabaseConnectionFactory::create([
    'driver' => 'sqlite',
    'database' => '/absolute/path/to/loyalty.sqlite',
]);

use LoyaltyRewards\Core\Services\LoyaltyService;
use LoyaltyRewards\Core\Services\AuditService;
use LoyaltyRewards\Core\Services\FraudDetectionService;
use LoyaltyRewards\Core\Engine\RulesEngine;
use LoyaltyRewards\Infrastructure\Database\DatabaseAccountRepository;
use LoyaltyRewards\Infrastructure\Database\DatabaseAuditRepository;
use LoyaltyRewards\Infrastructure\Database\DatabaseConnectionFactory;
use LoyaltyRewards\Infrastructure\Database\DatabaseTransactionRepository;
use Psr\EventDispatcher\EventDispatcherInterface;
use Psr\Log\NullLogger;

$pdo = DatabaseConnectionFactory::create([
    'driver' => 'sqlite',
    'database' => ':memory:',
]);

$accountRepository = new DatabaseAccountRepository(
    $pdo,
    new DatabaseTransactionRepository($pdo)
);
$auditRepository = new DatabaseAuditRepository($pdo);

$loyaltyService = new LoyaltyService(
    $accountRepository,
    new RulesEngine(new NullLogger),
    new FraudDetectionService(new NullLogger),
    new AuditService($auditRepository, new NullLogger),
    new class implements EventDispatcherInterface {
        public function dispatch(object $event): object
        {
            return $event;
        }
    },
    new NullLogger
);

use LoyaltyRewards\Core\Engine\RulesEngine;
use LoyaltyRewards\Domain\ValueObjects\ConversionRate;
use LoyaltyRewards\Rules\Earning\{CategoryMultiplierRule, TierBonusRule};

$rulesEngine = new RulesEngine();

// Base earning: 1 point per cent spent
$rulesEngine->addEarningRule(
    new CategoryMultiplierRule('default', 1.0, ConversionRate::standard())
);

// Category bonuses
$rulesEngine->addEarningRule(
    new CategoryMultiplierRule('premium', 5.0, ConversionRate::standard())
);

// Tier bonuses stack with category multipliers
$rulesEngine->addEarningRule(
    new TierBonusRule('vip', 2.0, ConversionRate::standard())
);

use LoyaltyRewards\Core\Exceptions\FraudDetectedException;
use LoyaltyRewards\Core\Services\FraudDetectionService;
use LoyaltyRewards\Domain\ValueObjects\{Currency, CustomerId, Money, TransactionContext};

$fraudDetection = new FraudDetectionService();
$customerId = CustomerId::fromString('customer_12345');
$account = $accountRepository->findByCustomerId($customerId);
$amount = Money::fromDollars(99.99, Currency::USD());
$context = TransactionContext::earning('electronics', 'online_store');

// Automatic fraud checking on all transactions
$fraudResult = $fraudDetection->analyze($account, $amount, $context);

if ($fraudResult->shouldBlock()) {
    throw new FraudDetectedException('Transaction blocked');
}