Integración con Salesforce

/**
 * CertyoService — Apex class for Certyo API integration.
 * Uses Named Credential 'Certyo_API' for authentication.
 *
 * Methods:
 *   ingestRecord()  — POST /api/v1/records (async via @future)
 *   verifyRecord()  — POST /api/v1/verify/record
 *   queryRecord()   — GET  /api/v1/records?tenantId=X&recordId=Y
 */
public with sharing class CertyoService {

    private static final String NAMED_CREDENTIAL = 'callout:Certyo_API';
    private static final String INGEST_PATH      = '/api/v1/records';
    private static final String VERIFY_PATH      = '/api/v1/verify/record';
    private static final String QUERY_PATH       = '/api/v1/records';

    // Tenant ID — configure via Custom Metadata Type or Custom Setting
    private static String getTenantId() {
        Certyo_Settings__c settings = Certyo_Settings__c.getOrgDefaults();
        return settings.Tenant_Id__c != null
            ? settings.Tenant_Id__c
            : 'default';
    }

    /**
     * Ingest a record asynchronously.
     * Called via @future so it runs outside the trigger transaction.
     *
     * @param orderId      The Order record ID (Salesforce ID)
     * @param orderNumber  The Order number (used as Certyo recordId)
     * @param payloadJson  Serialized JSON of the order data
     */
    @future(callout=true)
    public static void ingestRecord(
        Id orderId,
        String orderNumber,
        String payloadJson
    ) {
        String tenantId = getTenantId();
        String today = String.valueOf(Date.today());

        Map<String, Object> body = new Map<String, Object>{
            'tenantId'       => tenantId,
            'database'       => 'salesforce',
            'collection'     => 'orders',
            'recordId'       => orderNumber,
            'recordVersion'  => '1',
            'operationType'  => 'insert',
            'recordPayload'  => (Map<String, Object>) JSON.deserializeUntyped(payloadJson),
            'sourceTimestamp' => Datetime.now().formatGmt('yyyy-MM-dd\'T\'HH:mm:ss\'Z\''),
            'idempotencyKey' => orderNumber + '-v1-' + today
        };

        HttpRequest req = new HttpRequest();
        req.setEndpoint(NAMED_CREDENTIAL + INGEST_PATH);
        req.setMethod('POST');
        req.setHeader('Content-Type', 'application/json');
        req.setBody(JSON.serialize(body));
        req.setTimeout(30000);

        Http http = new Http();
        HttpResponse res = http.send(req);

        Certificate__c cert = new Certificate__c(
            Order__c       = orderId,
            RecordId__c    = orderNumber,
            AnchorStatus__c = 'Pending'
        );

        if (res.getStatusCode() == 202) {
            Map<String, Object> result =
                (Map<String, Object>) JSON.deserializeUntyped(res.getBody());
            cert.RecordHash__c = (String) result.get('recordHash');
            System.debug('Certyo ingestion accepted: ' + orderNumber +
                         ' hash=' + cert.RecordHash__c);
        } else {
            cert.AnchorStatus__c = 'Failed';
            System.debug('Certyo ingestion failed: HTTP ' +
                         res.getStatusCode() + ' ' + res.getBody());
        }

        upsert cert RecordId__c;
    }

    /**
     * Verify a record against the on-chain Merkle root.
     *
     * @param recordId    The Certyo recordId (e.g. Order number)
     * @param payloadJson The original record payload as JSON
     * @return Map with verification result fields
     */
    public static Map<String, Object> verifyRecord(
        String recordId,
        String payloadJson
    ) {
        String tenantId = getTenantId();

        Map<String, Object> body = new Map<String, Object>{
            'tenantId'   => tenantId,
            'database'   => 'salesforce',
            'collection' => 'orders',
            'recordId'   => recordId,
            'payload'    => (Map<String, Object>) JSON.deserializeUntyped(payloadJson)
        };

        HttpRequest req = new HttpRequest();
        req.setEndpoint(NAMED_CREDENTIAL + VERIFY_PATH);
        req.setMethod('POST');
        req.setHeader('Content-Type', 'application/json');
        req.setBody(JSON.serialize(body));
        req.setTimeout(30000);

        Http http = new Http();
        HttpResponse res = http.send(req);

        if (res.getStatusCode() == 200) {
            return (Map<String, Object>) JSON.deserializeUntyped(res.getBody());
        }

        return new Map<String, Object>{
            'verified' => false,
            'error'    => 'HTTP ' + res.getStatusCode() + ': ' + res.getBody()
        };
    }

    /**
     * Query Certyo for the anchoring status of a record.
     *
     * @param recordId The Certyo recordId
     * @return The first matching snapshot or null
     */
    public static Map<String, Object> queryRecordStatus(String recordId) {
        String tenantId = getTenantId();

        HttpRequest req = new HttpRequest();
        req.setEndpoint(NAMED_CREDENTIAL + QUERY_PATH +
            '?tenantId=' + EncodingUtil.urlEncode(tenantId, 'UTF-8') +
            '&recordId=' + EncodingUtil.urlEncode(recordId, 'UTF-8'));
        req.setMethod('GET');
        req.setTimeout(15000);

        Http http = new Http();
        HttpResponse res = http.send(req);

        if (res.getStatusCode() == 200) {
            Map<String, Object> data =
                (Map<String, Object>) JSON.deserializeUntyped(res.getBody());
            List<Object> items = (List<Object>) data.get('items');
            if (items != null && !items.isEmpty()) {
                return (Map<String, Object>) items[0];
            }
        }

        return null;
    }
}

/**
 * OrderCertyoTrigger
 * Fires after update on Order. When status changes to 'Activated',
 * publishes a Platform Event for async Certyo ingestion.
 */
trigger OrderCertyoTrigger on Order (after update) {

    List<Certyo_Record_Ingest__e> events = new List<Certyo_Record_Ingest__e>();

    for (Order newOrder : Trigger.new) {
        Order oldOrder = Trigger.oldMap.get(newOrder.Id);

        // Only fire when status transitions to Activated
        if (newOrder.Status == 'Activated' && oldOrder.Status != 'Activated') {

            // Build the payload from Order fields
            Map<String, Object> payload = new Map<String, Object>{
                'orderNumber'    => newOrder.OrderNumber,
                'accountId'      => newOrder.AccountId,
                'effectiveDate'  => String.valueOf(newOrder.EffectiveDate),
                'totalAmount'    => newOrder.TotalAmount,
                'status'         => newOrder.Status,
                'description'    => newOrder.Description,
                'contractId'     => newOrder.ContractId,
                'poNumber'       => newOrder.PoNumber,
                'billingCity'    => newOrder.BillingCity,
                'billingCountry' => newOrder.BillingCountry,
                'shippingCity'   => newOrder.ShippingCity,
                'shippingCountry'=> newOrder.ShippingCountry
            };

            events.add(new Certyo_Record_Ingest__e(
                Order_Id__c     = newOrder.Id,
                Order_Number__c = newOrder.OrderNumber,
                Payload_JSON__c = JSON.serialize(payload)
            ));
        }
    }

    if (!events.isEmpty()) {
        List<Database.SaveResult> results = EventBus.publish(events);
        for (Database.SaveResult sr : results) {
            if (!sr.isSuccess()) {
                for (Database.Error err : sr.getErrors()) {
                    System.debug('Platform Event publish failed: ' +
                                 err.getStatusCode() + ' - ' + err.getMessage());
                }
            }
        }
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<CustomObject xmlns="http://soap.sforce.com/2006/04/metadata">
    <deploymentStatus>Deployed</deploymentStatus>
    <eventType>HighVolume</eventType>
    <label>Certyo Record Ingest</label>
    <pluralLabel>Certyo Record Ingests</pluralLabel>
    <publishBehavior>PublishAfterCommit</publishBehavior>

    <fields>
        <fullName>Order_Id__c</fullName>
        <label>Order ID</label>
        <type>Text</type>
        <length>18</length>
        <isFilteringDisabled>false</isFilteringDisabled>
        <isNameField>false</isNameField>
        <isSortingDisabled>true</isSortingDisabled>
    </fields>

    <fields>
        <fullName>Order_Number__c</fullName>
        <label>Order Number</label>
        <type>Text</type>
        <length>80</length>
        <isFilteringDisabled>false</isFilteringDisabled>
        <isNameField>false</isNameField>
        <isSortingDisabled>true</isSortingDisabled>
    </fields>

    <fields>
        <fullName>Payload_JSON__c</fullName>
        <label>Payload JSON</label>
        <type>LongTextArea</type>
        <length>131072</length>
        <visibleLines>5</visibleLines>
        <isFilteringDisabled>true</isFilteringDisabled>
        <isNameField>false</isNameField>
        <isSortingDisabled>true</isSortingDisabled>
    </fields>
</CustomObject>

/**
 * CertyoRecordIngestTrigger
 * Subscribes to Certyo_Record_Ingest__e Platform Events.
 * Calls CertyoService.ingestRecord() via @future for each event.
 */
trigger CertyoRecordIngestTrigger on Certyo_Record_Ingest__e (after insert) {

    for (Certyo_Record_Ingest__e event : Trigger.new) {
        // @future(callout=true) runs asynchronously outside this transaction
        CertyoService.ingestRecord(
            event.Order_Id__c,
            event.Order_Number__c,
            event.Payload_JSON__c
        );
    }
}

/**
 * CertyoVerificationScheduler
 * Schedulable Apex that polls Certyo for anchoring status and updates
 * Certificate__c records.
 *
 * Schedule via Anonymous Apex:
 *   System.schedule(
 *       'Certyo Verification Poller',
 *       '0 0/15 * * * ?',
 *       new CertyoVerificationScheduler()
 *   );
 */
public with sharing class CertyoVerificationScheduler implements Schedulable {

    public void execute(SchedulableContext ctx) {
        // Delegate to Queueable so we can make callouts
        System.enqueueJob(new CertyoVerificationJob());
    }
}

/**
 * CertyoVerificationJob
 * Queueable with callout support. Processes pending certificates
 * in batches to respect Salesforce governor limits.
 */
public with sharing class CertyoVerificationJob implements Queueable, Database.AllowsCallouts {

    private static final Integer BATCH_SIZE = 50;

    public void execute(QueueableContext ctx) {
        List<Certificate__c> pending = [
            SELECT Id, RecordId__c, RecordHash__c, Order__c, Order__r.OrderNumber
            FROM Certificate__c
            WHERE AnchorStatus__c = 'Pending'
            ORDER BY CreatedDate ASC
            LIMIT :BATCH_SIZE
        ];

        if (pending.isEmpty()) {
            return;
        }

        List<Certificate__c> toUpdate = new List<Certificate__c>();

        for (Certificate__c cert : pending) {
            try {
                Map<String, Object> snapshot =
                    CertyoService.queryRecordStatus(cert.RecordId__c);

                if (snapshot == null) {
                    continue; // Not yet processed
                }

                String status = (String) snapshot.get('status');

                if (status == 'Anchored') {
                    cert.AnchorStatus__c  = 'Anchored';
                    cert.PolygonTxHash__c = (String) snapshot.get('polygonTxHash');
                    cert.MerkleRoot__c    = (String) snapshot.get('merkleRoot');
                    cert.IpfsCid__c       = (String) snapshot.get('ipfsCid');
                    cert.SnapshotId__c    = (String) snapshot.get('id');
                    cert.VerifiedAt__c    = Datetime.now();
                    toUpdate.add(cert);

                    System.debug('Certyo: ' + cert.RecordId__c + ' anchored — ' +
                                 cert.PolygonTxHash__c);
                } else if (status == 'Failed') {
                    cert.AnchorStatus__c = 'Failed';
                    toUpdate.add(cert);
                    System.debug('Certyo: ' + cert.RecordId__c + ' failed anchoring');
                }
                // If Batched or Pending, skip — will be picked up next run

            } catch (Exception e) {
                System.debug('Certyo verification error for ' +
                             cert.RecordId__c + ': ' + e.getMessage());
            }
        }

        if (!toUpdate.isEmpty()) {
            update toUpdate;
        }

        // If we processed a full batch, chain another job for remaining records
        if (pending.size() == BATCH_SIZE) {
            Integer remainingCount = [
                SELECT COUNT()
                FROM Certificate__c
                WHERE AnchorStatus__c = 'Pending'
            ];
            if (remainingCount > 0) {
                System.enqueueJob(new CertyoVerificationJob());
            }
        }
    }
}