Zig

Global Payments Card Authorization

See more Global Payments Examples

Demonstrates how to send a card payments authorization request. Zig

const std = @import("std");
const chilkat = @import("chilkat");

pub fn main(init: std.process.Init) !void {
    const alloc = init.arena.allocator();

    // This example requires the Chilkat API to have been previously unlocked.
    // See Global Unlock Sample for sample code.

    const http = try chilkat.Http.init();
    defer http.deinit();

    // if you don't have a Client ID yet you can still quickly test some basic request types using the following URL and credentials:

    // Test URL - https://test.realexpayments.com/epage-remote.cgi
    // Client ID: realexsandbox
    // Shared Secret: Po8lRRT67a
    const test_url = "https://test.realexpayments.com/epage-remote.cgi";
    const client_id = "realexsandbox";
    const shared_secret = "Po8lRRT67a";

    const amount = "1001";
    const currency = "EUR";
    const card_number = "4263970000005262";

    // We'll be sending the following XML in the body of the request:

    // <?xml version="1.0" encoding="UTF-8"?>
    // <request type="auth" timestamp="20180613141207">
    //   <merchantid>MerchantId</merchantid>
    //   <account>internet</account>
    //   <channel>ECOM</channel>
    //   <orderid>N6qsk4kYRZihmPrTXWYS6g</orderid>
    //   <amount currency="EUR">1001</amount>
    //   <card>
    //     <number>4263970000005262</number>
    //     <expdate>0425</expdate>
    //     <chname>James Mason</chname>
    //     <type>VISA</type>
    //     <cvn>
    //       <number>123</number>
    //       <presind>1</presind>
    //     </cvn>
    //   </card>
    //   <autosettle flag="1"/>
    //   <sha1hash>87707637a34ba651b6185718c863abc64b673f20</sha1hash>
    // </request>

    // Use this online tool to generate code from sample XML:
    // Generate Code to Create XML

    // Get the current date/time in this format:  20180613141207
    const dt = try chilkat.DateTime.init();
    defer dt.deinit();
    dt.setFromCurrentSystemTime() catch {};
    const dt_str = try dt.getAsIso8601(alloc, "YYYYMMDDhhmmss", true);

    // Generate a unique order ID
    const prng = try chilkat.Prng.init();
    defer prng.deinit();
    const order_id = try prng.genRandom(alloc, 32, "base64url");

    // Compute the sha1hash
    const crypt = try chilkat.Crypt2.init();
    defer crypt.deinit();
    crypt.setHashAlgorithm("sha1");
    crypt.setEncodingMode("hexlower");

    const sb_a = try chilkat.StringBuilder.init();
    defer sb_a.deinit();
    sb_a.append("timestamp.merchantid.orderid.amount.currency.cardnumber") catch {};
    var num_replaced: i32 = sb_a.replace("timestamp", dt_str);
    num_replaced = sb_a.replace("merchantid", client_id);
    num_replaced = sb_a.replace("orderid", order_id);
    num_replaced = sb_a.replace("amount", amount);
    num_replaced = sb_a.replace("currency", currency);
    num_replaced = sb_a.replace("cardnumber", card_number);

    const hash_a = try crypt.hashStringENC(alloc, try sb_a.getAsString(alloc));

    const sb_b = try chilkat.StringBuilder.init();
    defer sb_b.deinit();
    sb_b.append(hash_a) catch {};
    sb_b.append(".") catch {};
    sb_b.append(shared_secret) catch {};

    const hash_b = try crypt.hashStringENC(alloc, try sb_b.getAsString(alloc));

    const xml = try chilkat.Xml.init();
    defer xml.deinit();
    xml.setTag("request");
    xml.addAttribute("type", "auth") catch {};
    xml.addAttribute("timestamp", dt_str) catch {};
    xml.updateChildContent("merchantid", client_id);
    xml.updateChildContent("account", "internet");
    xml.updateChildContent("channel", "ECOM");
    xml.updateChildContent("orderid", order_id);
    xml.updateAttrAt("amount", true, "currency", currency) catch {};
    xml.updateChildContent("amount", amount);
    xml.updateChildContent("card|number", card_number);
    xml.updateChildContent("card|expdate", "0425");
    xml.updateChildContent("card|chname", "James Mason");
    xml.updateChildContent("card|type", "VISA");
    xml.updateChildContent("card|cvn|number", "123");
    xml.updateChildContent("card|cvn|presind", "1");
    xml.updateAttrAt("autosettle", true, "flag", "1") catch {};
    xml.updateChildContent("sha1hash", hash_b);

    const resp = try chilkat.HttpResponse.init();
    defer resp.deinit();
    http.httpStr("POST", test_url, try xml.getXml(alloc), "utf-8", "application/xml", resp) catch {
        std.debug.print("{s}\n", .{try http.getLastErrorText(alloc)});
        return;
    };

    std.debug.print("Response Status Code: {d}\n", .{resp.getStatusCode()});

    std.debug.print("Response Body:\n", .{});
    std.debug.print("{s}\n", .{try resp.getBodyStr(alloc)});

    if (resp.getStatusCode() != 200) {
        std.debug.print("Failed.\n", .{});
        return;
    }

    // A status code of 200 indicates we received an XML response, but it could be an error message.
    // Here's an example of an error response:

    // <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    // <response timestamp="20200418142356">
    //     <orderid>N6qsk4kYRZihmPrTXWYS6g</orderid>
    //     <result>508</result>
    //     <message>Invalid timestamp: '{' Value exceeds allowable limit: '}'</message>
    // </response>

    // We need to check the "result" within the XML.
    xml.loadXml(try resp.getBodyStr(alloc)) catch {};

    const result = xml.getChildIntValue("result");
    std.debug.print("result = {d}\n", .{result});

    // A successful result looks like this:

    // <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    // <response timestamp="20200418145519">
    //     <merchantid>realexsandbox</merchantid>
    //     <account>internet</account>
    //     <orderid>Cw93I1nFWVZuaATh46qMUCBlCcfrOvLo65C2cq5X-AY</orderid>
    //     <result>00</result>
    //     <authcode>L3pHww</authcode>
    //     <message>AUTH CODE: L3pHww</message>
    //     <pasref>96838535689610806</pasref>
    //     <cvnresult>M</cvnresult>
    //     <timetaken>87</timetaken>
    //     <authtimetaken>67</authtimetaken>
    //     <batchid>6322506</batchid>
    //     <sha1hash>2fd2f15f97f1775779fe9bda536dc8317a4b39f6</sha1hash>
    // </response>

    if (result == 0) {
        std.debug.print("authcode = {s}\n", .{try xml.getChildContent(alloc, "authcode")});
        std.debug.print("Success.\n", .{});
    } else {
        std.debug.print("Failed.\n", .{});
    }
}