PHP code example of azaharizaman / nexus-procurement-operations

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

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

    

azaharizaman / nexus-procurement-operations example snippets

use Nexus\ProcurementOperations\Coordinators\RequisitionCoordinator;
use Nexus\ProcurementOperations\DTOs\CreateRequisitionRequest;

$coordinator = $container->get(RequisitionCoordinator::class);

$result = $coordinator->create(new CreateRequisitionRequest(
    tenantId: 'tenant-123',
    requestedBy: 'user-456',
    departmentId: 'dept-789',
    lineItems: [
        [
            'productId' => 'prod-001',
            'description' => 'Office Supplies',
            'quantity' => 100,
            'estimatedUnitPriceCents' => 1500,
            'uom' => 'EA',
        ],
    ],
    justification: 'Monthly office supplies replenishment',
));

if ($result->success) {
    echo "Requisition created: {$result->requisitionId}";
}

use Nexus\ProcurementOperations\Coordinators\InvoiceMatchingCoordinator;
use Nexus\ProcurementOperations\DTOs\MatchInvoiceRequest;

$coordinator = $container->get(InvoiceMatchingCoordinator::class);

$result = $coordinator->match(new MatchInvoiceRequest(
    tenantId: 'tenant-123',
    vendorBillId: 'bill-001',
    purchaseOrderId: 'po-001',
    goodsReceiptIds: ['gr-001', 'gr-002'],
    performedBy: 'user-456',
));

if ($result->matched) {
    echo "Invoice matched successfully!";
} else {
    echo "Match failed: {$result->failureReason}";
    print_r($result->variances);
}

use Nexus\ProcurementOperations\Coordinators\PaymentProcessingCoordinator;
use Nexus\ProcurementOperations\DTOs\Financial\ProcessPaymentRequest;

$coordinator = $container->get(PaymentProcessingCoordinator::class);

$result = $coordinator->process(new ProcessPaymentRequest(
    tenantId: 'tenant-123',
    vendorBillIds: ['bill-001', 'bill-002'],
    paymentMethod: 'ACH',
    bankAccountId: 'bank-001',
    scheduledDate: new \DateTimeImmutable('+3 days'),
    processedBy: 'user-456',
    captureEarlyPaymentDiscount: true,
));

if ($result->success) {
    echo "Payment scheduled: {$result->paymentReference}";
    echo "Discount captured: {$result->discountCaptured->format()}";
}

use Nexus\ProcurementOperations\Coordinators\SoxComplianceCoordinator;
use Nexus\ProcurementOperations\DTOs\Sox\SoxComplianceRequest;

$coordinator = $container->get(SoxComplianceCoordinator::class);

$result = $coordinator->validateCompliance(new SoxComplianceRequest(
    tenantId: 'tenant-123',
    period: '2024-Q4',
    controlAreas: ['PROCUREMENT', 'PAYMENTS', 'VENDOR_MANAGEMENT'],
    

use Nexus\ProcurementOperations\Workflows\VendorOnboardingWorkflow;
use Nexus\ProcurementOperations\DTOs\Vendor\VendorOnboardingRequest;

$workflow = $container->get(VendorOnboardingWorkflow::class);

$result = $workflow->start(new VendorOnboardingRequest(
    tenantId: 'tenant-123',
    vendorName: 'Acme Supplies Ltd',
    registrationNumber: 'REG-12345',
    taxId: 'TAX-67890',
    primaryContact: [
        'name' => 'John Smith',
        'email' => '[email protected]',
        'phone' => '+1-555-0100',
    ],
    bankDetails: [
        'bankName' => 'First National Bank',
        'accountNumber' => '****1234',
        'routingNumber' => '021000021',
    ],
    complianceCertifications: ['ISO9001', 'SOC2'],
));

echo "Onboarding workflow started: {$result->workflowId}";
echo "Status: {$result->status->value}"; // PENDING_VERIFICATION

use Nexus\ProcurementOperations\Coordinators\SpendAnalyticsCoordinator;
use Nexus\ProcurementOperations\DTOs\SpendPolicy\SpendAnalysisRequest;

$coordinator = $container->get(SpendAnalyticsCoordinator::class);

$result = $coordinator->analyze(new SpendAnalysisRequest(
    tenantId: 'tenant-123',
    periodStart: new \DateTimeImmutable('2024-01-01'),
    periodEnd: new \DateTimeImmutable('2024-12-31'),
    dimensions: ['category', 'vendor', 'department'],
    

use Nexus\ProcurementOperations\Services\SharedServicesCenter;
use Nexus\ProcurementOperations\DTOs\MultiEntity\SharedProcurementRequest;

$sharedServices = $container->get(SharedServicesCenter::class);

$result = $sharedServices->processRequest(new SharedProcurementRequest(
    requestingEntityId: 'entity-001',
    serviceType: 'PROCUREMENT',
    items: [
        ['productId' => 'prod-001', 'quantity' => 1000],
    ],
    deliveryEntities: ['entity-001', 'entity-002'],
));

echo "Shared request ID: {$result->requestId}";
echo "Allocated to entities: " . implode(', ', $result->allocations);

use Nexus\ProcurementOperations\Services\ControlTestingService;
use Nexus\ProcurementOperations\DTOs\Sox\ControlTestRequest;

$testingService = $container->get(ControlTestingService::class);

$result = $testingService->executeTest(new ControlTestRequest(
    tenantId: 'tenant-123',
    controlId: 'CTRL-PR-001',
    testingPeriod: '2024-Q4',
    sampleSize: 25, // PCAOB standard
    testProcedures: ['vouching', 'recalculation', 'observation'],
));

if ($result->isEffective) {
    echo "Control is operating effectively";
    echo "Exceptions: {$result->exceptionCount}/{$result->sampleSize}";
} else {
    echo "Control deficiency detected: {$result->deficiencyType}";
}

use Nexus\ProcurementOperations\Services\Sox404EvidenceService;
use Nexus\ProcurementOperations\DTOs\Sox\EvidencePackageRequest;

$evidenceService = $container->get(Sox404EvidenceService::class);

$package = $evidenceService->generatePackage(new EvidencePackageRequest(
    tenantId: 'tenant-123',
    auditPeriod: '2024',
    controlAreas: ['ALL'],
    format: 'PDF',
));

echo "Evidence package generated: {$package->packageId}";
echo "Total documents: {$package->documentCount}";
echo "Ready for external audit: " . ($package->isComplete ? 'Yes' : 'No');

use Nexus\ProcurementOperations\Rules\SegregationOfDutiesRule;
use Nexus\ProcurementOperations\DTOs\Sox\SodCheckRequest;

$sodRule = $container->get(SegregationOfDutiesRule::class);

$result = $sodRule->validate(new SodCheckRequest(
    userId: 'user-123',
    action: 'APPROVE_PAYMENT',
    relatedActions: [
        ['action' => 'CREATE_INVOICE', 'performedBy' => 'user-123'],
    ],
));

if (!$result->passed) {
    throw new SodViolationException($result->conflictDetails);
}

use Nexus\ProcurementOperations\Services\DocumentRetentionService;
use Nexus\ProcurementOperations\DTOs\Audit\LegalHoldRequest;

$retentionService = $container->get(DocumentRetentionService::class);

// Place documents on legal hold
$holdResult = $retentionService->placeLegalHold(new LegalHoldRequest(
    tenantId: 'tenant-123',
    matterReference: 'Litigation #2024-001',
    documentTypes: ['VENDOR_CONTRACTS', 'PURCHASE_ORDERS'],
    vendorIds: ['vendor-456'],
    initiatedBy: 'legal-counsel',
    reason: 'Ongoing vendor dispute litigation',
));

echo "Legal hold placed: {$holdResult->holdId}";
echo "Documents affected: {$holdResult->documentCount}";

use Nexus\ProcurementOperations\Services\Approval\ApprovalLimitsManager;
use Nexus\ProcurementOperations\DTOs\ApprovalLimitCheckRequest;

$manager = $container->get(ApprovalLimitsManager::class);

// Check if user can approve a requisition
$result = $manager->checkApprovalLimit(new ApprovalLimitCheckRequest(
    tenantId: 'tenant-123',
    approverId: 'user-456',
    documentType: 'requisition',
    amountCents: 500000, // $5,000
    currency: 'USD',
));

if ($result->canApprove) {
    echo "User authorized to approve";
    echo "Authority level: {$result->authorityLevel}";
} else {
    echo "Approval limit exceeded: {$result->reason}";
}

// Get user's approval authority
$authority = $manager->getApprovalAuthority('tenant-123', 'user-456');
echo "Max requisition: {$authority->getMaxAmountForType('requisition')} cents";

use Nexus\ProcurementOperations\Services\Compliance\DocumentRetentionService;

$service = $container->get(DocumentRetentionService::class);

// Apply retention policy to a document
$result = $service->applyRetentionPolicy(
    tenantId: 'tenant-123',
    documentId: 'doc-001',
    documentType: 'purchase_order',
    createdDate: new \DateTimeImmutable('2024-01-15'),
);

echo "Retention expires: {$result['expiresAt']->format('Y-m-d')}";

// Check disposal eligibility (respects legal holds)
$eligibility = $service->checkDisposalEligibility(
    tenantId: 'tenant-123',
    documentId: 'doc-001',
);

if ($eligibility['eligible']) {
    echo "Document can be disposed";
} else {
    echo "Blocked: {$eligibility['reason']}";
    // e.g., "Document is under legal hold: LH-2024-001"
}

// Apply legal hold
$service->applyLegalHold(
    tenantId: 'tenant-123',
    legalHoldId: 'LH-2024-002',
    documentIds: ['doc-001', 'doc-002', 'doc-003'],
    reason: 'Pending litigation - Jones v. Acme Corp',
);

use Nexus\ProcurementOperations\Services\Compliance\ProcurementAuditService;

$service = $container->get(ProcurementAuditService::class);

// Generate SOX 404 evidence package
$evidence = $service->generateSox404EvidencePackage(
    tenantId: 'tenant-123',
    periodStart: new \DateTimeImmutable('2024-01-01'),
    periodEnd: new \DateTimeImmutable('2024-12-31'),
);

echo "Control areas covered: " . implode(', ', $evidence['controlAreas']);
echo "Evidence items: {$evidence['evidenceCount']}";
echo "Compliant: " . ($evidence['overallCompliant'] ? 'Yes' : 'No');

// Get Segregation of Duties report
$sodReport = $service->getSegregationOfDutiesReport('tenant-123');

foreach ($sodReport['conflictGroups'] as $group) {
    echo "Users with conflicts in {$group['conflictType']}: ";
    echo implode(', ', $group['users']);
}

// Perform control test
$testResult = $service->performControlTest(
    tenantId: 'tenant-123',
    controlId: 'CTRL-PR-001',
    sampleSize: 25,
    testProcedures: ['vouching', 'recalculation'],
);

echo "Control effective: " . ($testResult['isEffective'] ? 'Yes' : 'No');
echo "Exceptions found: {$testResult['exceptionsFound']}";