@aptos-scp/scp-component-rn-device-services 0.0.1 → 0.0.4-hm

package/lib/AurusDevice/AurusDevice.js

@@ -0,0 +1,730 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const scp_component_logging_1 = require("@aptos-scp/scp-component-logging");
+const inversify_1 = require("inversify");
+const react_native_1 = require("react-native");
+const _1 = require("../");
+const constants_1 = require("./constants");
+const sdk_interface_1 = require("./sdk-interface");
+const xml_js = require("xml-js");
+const logger = scp_component_logging_1.LogManager.getLogger("com.aptos.deviceservices.AurusDevice");
+const native_onAESDKResponse = react_native_1.NativeModules.AurusPaymentTerminal.native_onAESDKResponse;
+const native_onNotificationReceived = react_native_1.NativeModules.AurusPaymentTerminal.native_onNotificationReceived;
+const native_onAESDKLogResponse = react_native_1.NativeModules.AurusPaymentTerminal.native_onAESDKLogResponse;
+const NotificationEvent = react_native_1.NativeModules.AurusPaymentTerminal.NotificationEvent;
+let AurusDevice = class AurusDevice {
+    /**
+     * To avoid pushing native component awareness onto the rest of the app, the native objects
+     * are created in the constructor, which only accepts JavaScript parameters.
+     */
+    constructor() {
+        this._initializeCalled = false;
+        this._listenersAdded = false;
+        this._registrationInProgress = false; // EMV Config now happens during registration
+        this._waitingForDeviceConnected = false;
+        this._scannerEnabled = false;
+        this._paymentEnvironment = "Aurus"; // string representation of payment environment for trans object
+        this._requestInProgress = false;
+        this._requestQueue = [];
+        const entryMessage = logger.traceEntry("constructor");
+        this._devicePaymentTerminal = react_native_1.NativeModules.AurusPaymentTerminal;
+        this._nativeEventEmitter = new react_native_1.NativeEventEmitter(react_native_1.NativeModules.AurusPaymentTerminal);
+        logger.traceExit(entryMessage);
+    }
+    configurePaymentDevice(emitter, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entryMessage = logger.traceEntry("configurePaymentDevice", emitter, config);
+            this._paymentEmitter = emitter;
+            this._paymentConfig = config;
+            let payEnvDesc = "Unknown Aurus Environment";
+            let storeType = "";
+            let corpId = "";
+            let hostUrl = "";
+            if (config && config.vendorConfiguration) {
+                storeType = config.vendorConfiguration.storeType;
+                corpId = config.vendorConfiguration.corpId;
+                hostUrl = config.vendorConfiguration.hostUrl;
+                if (storeType === "PROD") {
+                    payEnvDesc = "Aurus Production";
+                }
+                else if (storeType === "UAT") {
+                    payEnvDesc = "Aurus UAT Sandbox";
+                }
+            }
+            this._paymentEnvironment = `${payEnvDesc} (StoreType: ${storeType}, CorpID: ${corpId}, HostUrl: ${hostUrl})`;
+            logger.traceExit(entryMessage);
+        });
+    }
+    configureScannerDevice(emitter, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entryMessage = logger.traceEntry("configureScannerDevice", emitter, config);
+            this._scannerEmitter = emitter;
+            this._scannerConfig = config;
+            this._scannerEnabled = config.initiallyEnabled;
+            logger.traceExit(entryMessage);
+        });
+    }
+    startPaymentDevice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entryMessage = logger.traceEntry("startPaymentDevice");
+            this.initializeNative();
+            logger.traceExit(entryMessage);
+        });
+    }
+    startScannerDevice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entryMessage = logger.traceEntry("startScannerDevice");
+            this.initializeNative();
+            logger.traceExit(entryMessage);
+        });
+    }
+    captureSale(authRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entryMessage = logger.traceEntry("captureSale", authRequest);
+            yield this.authorize(Object.assign({}, authRequest, { requestType: _1.PaymentRequestType.Sale }));
+            logger.traceExit(entryMessage);
+        });
+    }
+    captureRefund(authRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entryMessage = logger.traceEntry("captureRefund", authRequest);
+            yield this.authorize(Object.assign({}, authRequest, { requestType: _1.PaymentRequestType.Refund }));
+            logger.traceExit(entryMessage);
+        });
+    }
+    captureVoid(authRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entryMessage = logger.traceEntry("captureVoid", authRequest);
+            yield this.authorize(Object.assign({}, authRequest, { requestType: _1.PaymentRequestType.Void }));
+            logger.traceExit(entryMessage);
+        });
+    }
+    enableScannerDevice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entryMessage = logger.traceEntry("enableScannerDevice");
+            this._scannerEnabled = true;
+            this.sendUpgradeRequest(constants_1.UpgradeType.ENABLE_SCANNER);
+            logger.traceExit(entryMessage);
+        });
+    }
+    disableScannerDevice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entryMessage = logger.traceEntry("disableScannerDevice");
+            this._scannerEnabled = false;
+            this.sendUpgradeRequest(constants_1.UpgradeType.DISABLE_SCANNER);
+            logger.traceExit(entryMessage);
+        });
+    }
+    giftcardActivate(authRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entryMessage = logger.traceEntry("giftcardActivate", authRequest);
+            yield this.authorize(Object.assign({}, authRequest, { requestType: _1.PaymentRequestType.GiftCardActivate }));
+            logger.traceExit(entryMessage);
+        });
+    }
+    giftcardBalance(authRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entryMessage = logger.traceEntry("giftcardBalance", authRequest);
+            yield this.authorize(Object.assign({}, authRequest, { requestType: _1.PaymentRequestType.GiftCardBalanceInquiry }));
+            logger.traceExit(entryMessage);
+        });
+    }
+    giftcardIssue(authRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entryMessage = logger.traceEntry("giftcardIssue", authRequest);
+            yield this.authorize(Object.assign({}, authRequest, { requestType: _1.PaymentRequestType.GiftCardIssue }));
+            logger.traceExit(entryMessage);
+        });
+    }
+    giftcardRedeem(authRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entryMessage = logger.traceEntry("giftcardRedeem", authRequest);
+            yield this.authorize(Object.assign({}, authRequest, { requestType: _1.PaymentRequestType.GiftCardRedeem }));
+            logger.traceExit(entryMessage);
+        });
+    }
+    giftcardVoid(authRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entryMessage = logger.traceEntry("giftcardVoid", authRequest);
+            yield this.authorize(Object.assign({}, authRequest, { requestType: _1.PaymentRequestType.Void }));
+            logger.traceExit(entryMessage);
+        });
+    }
+    stopPaymentDevice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entryMessage = logger.traceEntry("stopPaymentDevice");
+            logger.traceExit(entryMessage);
+        });
+    }
+    stopScannerDevice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entryMessage = logger.traceEntry("stopScannerDevice");
+            logger.traceExit(entryMessage);
+        });
+    }
+    tearDownPaymentDevice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entryMessage = logger.traceEntry("tearDownPaymentDevice");
+            yield this.tearDownNative();
+            logger.traceExit(entryMessage);
+        });
+    }
+    tearDownScannerDevice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entryMessage = logger.traceEntry("tearDownScannerDevice");
+            yield this.tearDownNative();
+            logger.traceExit(entryMessage);
+        });
+    }
+    processTimeout() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entryMessage = logger.traceEntry("processTimeout");
+            this.emitAuthorizationResponse(_1.ResponseCodes.Timeout, "TIMEOUT WAITING FOR RESPONSE");
+            //Send cancel to aurus
+            this.sendCancelTranRequest();
+            logger.traceExit(entryMessage);
+        });
+    }
+    authorize(authRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entryMessage = logger.traceEntry("authorize", authRequest);
+            sdk_interface_1.AurusSupport.authRequest = authRequest;
+            sdk_interface_1.AurusSupport.authResponse = Object.assign({ paymentEnvironment: this._paymentEnvironment }, authRequest);
+            if (this._registrationInProgress) {
+                logger.debug("Payment is unavailalbe while device registration is in progress. Emitting error response.");
+                this.emitAuthorizationResponse(_1.ResponseCodes.Error, "Payment Unavailable. Device Registration in Progress");
+            }
+            else if (sdk_interface_1.AurusSupport.requireGetCard(authRequest)) {
+                this.sendGetCardBin(authRequest);
+            }
+            else {
+                this.sendCardTransRequest();
+            }
+            logger.traceExit(entryMessage);
+        });
+    }
+    initializeNative() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entryMessage = logger.traceEntry("initializeNative");
+            if (!this._listenersAdded) {
+                this._listenersAdded = true;
+                let context = {};
+                this._nativeSubscriptions = [
+                    this._nativeEventEmitter.addListener(native_onAESDKResponse, this.onAESDKResponse.bind(this), context),
+                    this._nativeEventEmitter.addListener(native_onNotificationReceived, this.onNotificationReceived.bind(this), context),
+                    this._nativeEventEmitter.addListener(native_onAESDKLogResponse, this.onAESDKLogResponse.bind(this), context)
+                ];
+            }
+            if (!this._initializeCalled) {
+                this._initializeCalled = true;
+                this._waitingForDeviceConnected = true;
+                this._devicePaymentTerminal.initialize();
+            }
+            logger.traceExit(entryMessage);
+        });
+    }
+    tearDownNative() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entryMessage = logger.traceEntry("tearDownNative");
+            if (this._nativeSubscriptions) {
+                while (this._nativeSubscriptions.length > 0) {
+                    this._nativeSubscriptions.pop().remove();
+                }
+            }
+            this._listenersAdded = false;
+            logger.traceExit(entryMessage);
+        });
+    }
+    /**
+     * This method handles events published by the native components. This is an adapter between the native and JavaScript
+     * components for asynchronous events from the native layer.
+     */
+    onAESDKResponse(...args) {
+        const entryMessage = logger.traceEntry("onAESDKResponse", args);
+        if (args.length >= 1 && args[0]) {
+            // Note: This could check that it received the correct type of argument using a guard function, if multiple types
+            // of events can be sent or just for safety.
+            let withResponse = args[0];
+            logger.debug(`In onAESDKResponse, withResponse: ${JSON.stringify(withResponse)}`);
+            // update in-progress and check queue
+            this.receiveResponse();
+            // Parse xml and determine next steps. Call back into native if needed.
+            this.handleAESDKResponse(withResponse);
+        }
+        else {
+            throw logger.throwing(new Error("Empty event received. withResponse data is missing"), entryMessage);
+        }
+        logger.traceExit(entryMessage);
+    }
+    sendCancelTranRequest() {
+        const entryMessage = logger.traceEntry("sendCancelTranRequest");
+        sdk_interface_1.AurusSupport.requestType = constants_1.RequestTypes.CancelTransaction;
+        let xmlreq = sdk_interface_1.AurusSupport.createCancelTranRequest();
+        this.sendRequest(xmlreq);
+        logger.traceExit(entryMessage);
+    }
+    sendCancelLastTranRequest() {
+        const entryMessage = logger.traceEntry("sendCancelLastTranRequest");
+        sdk_interface_1.AurusSupport.requestType = constants_1.RequestTypes.CancelTransaction;
+        let xmlreq = sdk_interface_1.AurusSupport.createCancelLastTranRequest();
+        this.sendRequest(xmlreq);
+        logger.traceExit(entryMessage);
+    }
+    sendTransRequest(getCardBinResp) {
+        const entryMessage = logger.traceEntry("sendTransRequest", getCardBinResp);
+        sdk_interface_1.AurusSupport.requestType = constants_1.RequestTypes.Transaction;
+        let xmlreq = sdk_interface_1.AurusSupport.createCardTranRequest(getCardBinResp);
+        this.sendRequest(xmlreq);
+        logger.traceExit(entryMessage);
+    }
+    sendCardTransRequest() {
+        const entryMessage = logger.traceEntry("sendCardTransRequest");
+        sdk_interface_1.AurusSupport.requestType = constants_1.RequestTypes.Transaction;
+        let xmlreq = sdk_interface_1.AurusSupport.createCardTranRequest();
+        this.sendRequest(xmlreq);
+        logger.traceExit(entryMessage);
+    }
+    /**
+     * Sends a GetCardBinRequest to request card data from teh device
+     * @param authRequest
+     */
+    sendGetCardBin(authRequest) {
+        const entryMessage = logger.traceEntry("sendGetCardBin", authRequest);
+        sdk_interface_1.AurusSupport.requestType = constants_1.RequestTypes.GetCardBin;
+        let xmlreq = sdk_interface_1.AurusSupport.createGetCardBinRequest();
+        this.sendRequest(xmlreq);
+        logger.traceExit(entryMessage);
+    }
+    /**
+     * Sends an AESDKRegistrationRequest to register the device
+     */
+    sendAESDKRegistration() {
+        const entryMessage = logger.traceEntry("sendAESDKRegistration");
+        sdk_interface_1.AurusSupport.requestType = constants_1.RequestTypes.Registration;
+        let xmlreq = sdk_interface_1.AurusSupport.createAESDKRegistrationRequest(this._paymentConfig.storeNumber, this._paymentConfig.terminalNumber, this._paymentConfig.vendorConfiguration.storeType, this._paymentConfig.vendorConfiguration.corpId, this._paymentConfig.vendorConfiguration.hostUrl);
+        this._registrationInProgress = true;
+        this.sendRequest(xmlreq);
+        logger.traceExit(entryMessage);
+    }
+    sendUpgradeRequest(upgradeType) {
+        const entryMessage = logger.traceEntry("sendUpgradeRequest");
+        if (upgradeType !== constants_1.UpgradeType.ENABLE_SCANNER && upgradeType !== constants_1.UpgradeType.DISABLE_SCANNER) {
+            // Enable/Disable scanner is fire and forget and may interrupt other calls. Don't update the request type.
+            sdk_interface_1.AurusSupport.requestType = constants_1.RequestTypes.Upgrade;
+        }
+        let xmlreq = sdk_interface_1.AurusSupport.createUpgradeRequest(this._paymentConfig.storeNumber, this._paymentConfig.terminalNumber, upgradeType);
+        this.sendRequest(xmlreq);
+        logger.traceExit(entryMessage);
+    }
+    sendByPassScreen(reason) {
+        const entryMessage = logger.traceEntry("sendByPassScreen");
+        let xmlreq = sdk_interface_1.AurusSupport.createByPassScreenRequest(this._paymentConfig.storeNumber, this._paymentConfig.terminalNumber, reason);
+        this.sendRequest(xmlreq);
+        logger.traceExit(entryMessage);
+    }
+    handleAESDKResponse(xml) {
+        const entryMessage = logger.traceEntry("handleAESDKResponse", xml);
+        let xmlResponse = this.convertXmlToJs(xml);
+        if (!xmlResponse) {
+            logger.warn(`In handleAESDKResponse, unable to convert to JSON: ${xml}`);
+        }
+        else if (constants_1.AesdkResponseTypes.Registration in xmlResponse) {
+            this.processAESDKRegistration(xmlResponse[constants_1.AesdkResponseTypes.Registration]);
+        }
+        else if (constants_1.AesdkResponseTypes.GetCardBin in xmlResponse) {
+            this.processGetCardBin(xmlResponse[constants_1.AesdkResponseTypes.GetCardBin]);
+        }
+        else if (constants_1.AesdkResponseTypes.Transaction in xmlResponse) {
+            this.processTrans(xmlResponse[constants_1.AesdkResponseTypes.Transaction]);
+        }
+        else if (constants_1.AesdkResponseTypes.AESDK in xmlResponse) {
+            this.processAESDK(xmlResponse[constants_1.AesdkResponseTypes.AESDK]);
+        }
+        else if (constants_1.AesdkResponseTypes.CancelTransaction in xmlResponse) {
+            this.processCancelTrans(xmlResponse[constants_1.AesdkResponseTypes.CancelTransaction]);
+        }
+        logger.traceExit(entryMessage);
+    }
+    convertXmlToJs(xml) {
+        const entryMessage = logger.traceEntry("convertXmlToJs", xml);
+        let jsObject = undefined;
+        try {
+            jsObject = xml_js.xml2js(xml, { compact: true, textKey: "value", trim: true });
+        }
+        catch (error) {
+        }
+        return logger.traceExit(entryMessage, jsObject);
+    }
+    processTrans(response) {
+        const entryMessage = logger.traceEntry("processTrans", response);
+        let tranDetails = response.TransDetailsData.TransDetailData;
+        const responseCode = this.mapAurusResponseCode(tranDetails.ResponseCode.value);
+        if (responseCode === _1.ResponseCodes.Approved) {
+            sdk_interface_1.AurusSupport.authResponse.approvedAmount = sdk_interface_1.AurusSupport.stringToMoney(tranDetails.TransactionAmount.value);
+            sdk_interface_1.AurusSupport.authResponse.cardNumber = tranDetails.CardNumber.value;
+            sdk_interface_1.AurusSupport.authResponse.cardType = this.mapAurusCardType(tranDetails.CardType.value);
+            sdk_interface_1.AurusSupport.authResponse.tenderType = this.mapAurusTenderType(tranDetails.CardType.value);
+            sdk_interface_1.AurusSupport.authResponse.referenceNumber = response.AurusPayTicketNum.value;
+            sdk_interface_1.AurusSupport.authResponse.balance = sdk_interface_1.AurusSupport.stringToMoney(tranDetails.BalanceAmount.value);
+            sdk_interface_1.AurusSupport.authResponse.approvalCode = tranDetails.ApprovalCode.value;
+            sdk_interface_1.AurusSupport.authResponse.EMVData = this.parseEMVData(tranDetails.EMVData.value);
+            sdk_interface_1.AurusSupport.authResponse.EMVData.receiptData = tranDetails.EMVData && tranDetails.EMVData.value &&
+                tranDetails.EMVData.value.replace(/~/g, ": ").split("[FS]");
+            // FIXME: AdditionalReceiptInfo should be parsed based on the format of the aurus response.
+            // Resolve when we receive next sdk with correct format
+            sdk_interface_1.AurusSupport.authResponse.receiptData =
+                tranDetails.AdditionalReceiptInfo && [tranDetails.AdditionalReceiptInfo.value];
+            sdk_interface_1.AurusSupport.authResponse.entryMethod = this.mapAurusEntryMethod(tranDetails.CardEntryMode.value);
+            sdk_interface_1.AurusSupport.authResponse.signatureRequired =
+                this.mapAurusSignatureRequired(tranDetails.SignatureReceiptFlag.value);
+            sdk_interface_1.AurusSupport.authResponse.pinCaptured = this.mapAurusPinCaptured(tranDetails.SignatureReceiptFlag.value);
+        }
+        this.emitAuthorizationResponse(responseCode, tranDetails.TransactionResponseText.value);
+        logger.traceExit(entryMessage);
+    }
+    processGetCardBin(response) {
+        const entryMessage = logger.traceEntry("processGetCardBin", response);
+        if (sdk_interface_1.AurusSupport.requestType === constants_1.RequestTypes.GetCardBin) {
+            if (response.ResponseCode.value === constants_1.ResponseCodes.Approved) {
+                this.sendTransRequest(response);
+            }
+            else {
+                this.emitAuthorizationResponse(this.mapAurusResponseCode(response.ResponseCode.value), response.ResponseText.value);
+            }
+        }
+        else {
+            //handle additional request types with getcardbinresponses
+            this.emitAuthorizationResponse(_1.ResponseCodes.Error, response.ResponseText.value);
+        }
+        logger.traceExit(entryMessage);
+    }
+    processCancelTrans(response) {
+        const entryMessage = logger.traceEntry("processCancelTrans", response);
+        if (response.ResponseCode.value === constants_1.ResponseCodes.Approved) {
+            logger.debug(`processCancelTrans success: ${sdk_interface_1.AurusSupport.authResponse.posReference}`);
+        }
+        else {
+            sdk_interface_1.AurusSupport.requestType = "";
+            logger.debug(`processCancelTrans failed, attempting CancelLastTrans: ${sdk_interface_1.AurusSupport.authRequest.transactionNumber}`);
+            this.sendCancelLastTranRequest();
+        }
+        logger.traceExit(entryMessage);
+    }
+    processAESDKRegistration(response) {
+        const entryMessage = logger.traceEntry("processAESDKRegistration", response);
+        if (sdk_interface_1.AurusSupport.requestType === constants_1.RequestTypes.GetCardBin) {
+            if (response.ResponseCode.value === constants_1.ResponseCodes.DeviceNotRegistered) {
+                this.sendAESDKRegistration();
+            }
+            this.emitAuthorizationResponse(_1.ResponseCodes.Error, response.ResponseText.value);
+        }
+        if (sdk_interface_1.AurusSupport.requestType === constants_1.RequestTypes.Registration) {
+            this._registrationInProgress = false;
+            this.emitPaymentStatus(true, _1.StatusCode.InitializationComplete);
+            //enable/disable scanner
+            this._scannerEnabled ? this.enableScannerDevice() : this.disableScannerDevice();
+        }
+        logger.traceExit(entryMessage);
+    }
+    processAESDK(response) {
+        const entryMessage = logger.traceEntry("processAESDK", response);
+        if (sdk_interface_1.AurusSupport.requestType === constants_1.RequestTypes.GetCardBin) {
+            this.emitAuthorizationResponse(_1.ResponseCodes.Error, response.ResponseText.value);
+        }
+        // this scenario could happen if the registration request fails
+        if (sdk_interface_1.AurusSupport.requestType === constants_1.RequestTypes.Registration) {
+            this._registrationInProgress = false;
+            // enable payment button or it will be permanately disabled without the user knowing why
+            // registration can be re-attempted when clicked and/or an error given to the user
+            this.emitPaymentStatus(true, _1.StatusCode.InitializationComplete);
+            //enable/disable scanner
+            this._scannerEnabled ? this.enableScannerDevice() : this.disableScannerDevice();
+        }
+        logger.traceExit(entryMessage);
+    }
+    mapAurusResponseCode(responseCode) {
+        const entryMessage = logger.traceEntry("mapAurusResponseCode", responseCode);
+        let retVal = _1.ResponseCodes.Error;
+        switch (responseCode) {
+            case constants_1.ResponseCodes.Approved:
+                retVal = _1.ResponseCodes.Approved;
+                break;
+            case constants_1.ResponseCodes.Timeout:
+                retVal = _1.ResponseCodes.Timeout;
+                break;
+            default:
+                retVal = _1.ResponseCodes.Decline;
+                break;
+        }
+        return logger.traceExit(entryMessage, retVal);
+    }
+    mapAurusCardType(aurusCardType) {
+        const entryMessage = logger.traceEntry("mapAurusCardType", aurusCardType);
+        let retVal = constants_1.cardTypeMap[aurusCardType];
+        if (!retVal) {
+            logger.debug(`mapAurusCardType: Unknown cardType: ${aurusCardType}`);
+            retVal = _1.CardType.Unknown;
+        }
+        return logger.traceExit(entryMessage, retVal);
+    }
+    mapAurusTenderType(aurusCardType) {
+        const entryMessage = logger.traceEntry("mapAurusTenderType", aurusCardType);
+        let retVal = constants_1.tenderTypeMap[aurusCardType];
+        if (!retVal) {
+            logger.debug(`mapAurusTenderType: Unknown cardType: ${aurusCardType}`);
+            retVal = _1.TenderType.Unknown;
+        }
+        return logger.traceExit(entryMessage, retVal);
+    }
+    mapAurusEntryMethod(entryMethod) {
+        const entryMessage = logger.traceEntry("mapAurusEntryMethod", entryMethod);
+        let retVal = _1.EntryMethod.Unknown;
+        switch (entryMethod) {
+            case constants_1.EntryMode.INSERT:
+                retVal = _1.EntryMethod.Insert;
+                break;
+            case constants_1.EntryMode.SWIPE:
+                retVal = _1.EntryMethod.Swipe;
+                break;
+            case constants_1.EntryMode.MOBILE:
+                retVal = _1.EntryMethod.Mobile;
+                break;
+            case constants_1.EntryMode.TAP:
+                retVal = _1.EntryMethod.Tap;
+                break;
+            case constants_1.EntryMode.KEYED:
+                retVal = _1.EntryMethod.Keyed;
+                break;
+            case constants_1.EntryMode.FALLBACK:
+                retVal = _1.EntryMethod.Fallback;
+                break;
+            default:
+                retVal = _1.EntryMethod.Unknown;
+                break;
+        }
+        return logger.traceExit(entryMessage, retVal);
+    }
+    mapAurusSignatureRequired(signatureReceiptFlag) {
+        const entryMessage = logger.traceEntry("mapAurusSignatureRequired", signatureReceiptFlag);
+        let retVal = false;
+        switch (signatureReceiptFlag) {
+            case constants_1.SignatureReceiptFlag.PinCapSignatureNeeded:
+            case constants_1.SignatureReceiptFlag.SignatureNeeded:
+                retVal = true;
+                break;
+            default:
+                retVal = false;
+                break;
+        }
+        return logger.traceExit(entryMessage, retVal);
+    }
+    mapAurusPinCaptured(signatureReceiptFlag) {
+        const entryMessage = logger.traceEntry("mapAurusPinCaptured", signatureReceiptFlag);
+        let retVal = false;
+        switch (signatureReceiptFlag) {
+            case constants_1.SignatureReceiptFlag.PinCapSignatureNeeded:
+            case constants_1.SignatureReceiptFlag.PinCaptured:
+            case constants_1.SignatureReceiptFlag.PinSigCaptured:
+                retVal = true;
+                break;
+            default:
+                retVal = false;
+                break;
+        }
+        return logger.traceExit(entryMessage, retVal);
+    }
+    parseEMVData(data) {
+        const entryMessage = logger.traceEntry("parseEMVData", data);
+        let emvData = {};
+        try {
+            //we have data in emvData field - parse into response.emvData format "key1~value1[FS]key2~value2"
+            //split on [FS] for KVPs
+            let kvpEmv = data.split("[FS]");
+            let kvp;
+            for (kvp of kvpEmv) {
+                let field = kvp.split("~");
+                emvData[constants_1.emvDataMap[field[0].toString().toUpperCase()]] = field[1];
+            }
+        }
+        catch (e) {
+            logger.error(e);
+        }
+        return logger.traceExit(entryMessage, emvData);
+    }
+    /**
+     * This method handles events published by the native components. This is an adapter between the native and JavaScript
+     * components for asynchronous events from the native layer.
+     */
+    onNotificationReceived(...args) {
+        const entryMessage = logger.traceEntry("onNotificationReceived", args);
+        if (args.length >= 1 && args[0]) {
+            const userInfo = args[0];
+            logger.debug(`In onNotificationReceived, userInfo: ${JSON.stringify(userInfo)}`);
+            this.handleNotificationEvent(userInfo);
+        }
+        else {
+            throw logger.throwing(new Error("Empty event received. userInfo data is missing"), entryMessage);
+        }
+        logger.traceExit(entryMessage);
+    }
+    handleNotificationEvent(userInfo) {
+        if (userInfo && userInfo.CODE !== undefined) {
+            (({
+                [NotificationEvent.BarcodeInformation]: () => { this.handleBarcodeInformationEvent(userInfo.AE_BARCODE_INFO); },
+                [NotificationEvent.DeviceNotConnected]: () => { this.handleDeviceNotConnectedEvent(); },
+                [NotificationEvent.DeviceConnected]: () => { this.handleDeviceConnectedEvent(); },
+                [NotificationEvent.DeviceConfigurationStarted]: () => { this.handleDeviceConfigurationStartedEvent(); },
+                [NotificationEvent.DeviceConfigurationCompleted]: () => { this.handleDeviceConfigurationCompletedEvent(); },
+                [NotificationEvent.DeviceConfigurationFailed]: () => { this.handleDeviceConfigurationFailedEvent(); },
+                [NotificationEvent.DeviceAlreadyConfigured]: () => { this.handleDeviceAlreadyConfiguredEvent(); }
+            })[userInfo.CODE] || (() => { this.handleDefaultEvent(userInfo.CODE); }))();
+        }
+    }
+    handleBarcodeInformationEvent(xmlBarcodeInfo) {
+        const entryMessage = logger.traceEntry("handleBarcodeInformationEvent", xmlBarcodeInfo);
+        if (!this._scannerEnabled) {
+            logger.debug("Scanning is not enabled, not processing the scan.");
+            // todo: make a sound to indicate the scan failed due to not being enabled.
+        }
+        else {
+            let xmlResponse = this.convertXmlToJs(xmlBarcodeInfo);
+            if (!xmlResponse) {
+                logger.warn(`In handleBarcodeInformationEvent, unable to convert to JSON: ${xmlBarcodeInfo}`);
+            }
+            else if (constants_1.AesdkResponseTypes.Barcode in xmlResponse) {
+                this.processBarcodeData(xmlResponse[constants_1.AesdkResponseTypes.Barcode]);
+            }
+            else {
+                logger.warn(`In handleBarcodeInformationEvent, unexpected root element received, ignoring xml: ${xmlBarcodeInfo}`);
+            }
+        }
+        logger.traceExit(entryMessage);
+    }
+    processBarcodeData(barcode) {
+        const entryMessage = logger.traceEntry("processBarcodeData", barcode);
+        const scanDataNotification = {
+            data: barcode.Barcode.value,
+            encoding: sdk_interface_1.AurusSupport.getBarcodeType(barcode.BarcodeType.value)
+        };
+        logger.debug(`In processBarcodeData, publishing scanDataNotification: ${JSON.stringify(scanDataNotification)}`);
+        this._scannerEmitter.emit(_1.EventResponseTypes.Scan, scanDataNotification);
+        logger.traceExit(entryMessage);
+    }
+    handleDeviceNotConnectedEvent() {
+        const entryMessage = logger.traceEntry("handleDeviceNotConnectedEvent");
+        this.emitPaymentStatus(false, _1.StatusCode.DeviceDisconnected);
+        // FIXME: This is added as a workaround and will need to be removed in the future.
+        // If the device disconnects during a payment, we will never get a response and the app will hang.
+        if (sdk_interface_1.AurusSupport.requestType === constants_1.RequestTypes.GetCardBin || sdk_interface_1.AurusSupport.requestType === constants_1.RequestTypes.Transaction) {
+            this.emitAuthorizationResponse(_1.ResponseCodes.Error, "Device disconnected. Please try again."); // send to POS
+        }
+        logger.traceExit(entryMessage);
+    }
+    handleDeviceConnectedEvent() {
+        const entryMessage = logger.traceEntry("handleDeviceConnectedEvent");
+        if (this._waitingForDeviceConnected) {
+            this._waitingForDeviceConnected = false;
+            this.sendAESDKRegistration();
+        }
+        else {
+            // FIXME: This is added as a workaround and will need to be removed in the future.
+            // If the device disconnects during a payment, Aurus will always return AESDK is busy.
+            this.receiveResponse(); // pretend we received response
+            this.sendByPassScreen("Device disconnected"); // send request to clear any errors
+            if (this._registrationInProgress) {
+                this.sendAESDKRegistration();
+            }
+            else {
+                this.emitPaymentStatus(true, _1.StatusCode.DeviceReconnected);
+                //enable/disable scanner
+                this._scannerEnabled ? this.enableScannerDevice() : this.disableScannerDevice();
+            }
+        }
+        logger.traceExit(entryMessage);
+    }
+    handleDeviceConfigurationStartedEvent() {
+        const entryMessage = logger.traceEntry("handleDeviceConfigurationStartedEvent");
+        logger.traceExit(entryMessage);
+    }
+    handleDeviceConfigurationCompletedEvent() {
+        const entryMessage = logger.traceEntry("handleDeviceConfigurationCompletedEvent");
+        logger.traceExit(entryMessage);
+    }
+    handleDeviceConfigurationFailedEvent() {
+        const entryMessage = logger.traceEntry("handleDeviceConfigurationFailedEvent");
+        logger.traceExit(entryMessage);
+    }
+    handleDeviceAlreadyConfiguredEvent() {
+        const entryMessage = logger.traceEntry("handleDeviceAlreadyConfiguredEvent");
+        logger.traceExit(entryMessage);
+    }
+    handleDefaultEvent(userInfoCode) {
+        // Should we log this? If we do, we should convert the userInfoCode into readable text.
+    }
+    emitPaymentStatus(deviceAvailable, statusCode) {
+        const entryMessage = logger.traceEntry("emitPaymentStatus");
+        sdk_interface_1.AurusSupport.paymentStatus.deviceAvailable = deviceAvailable;
+        sdk_interface_1.AurusSupport.paymentStatus.statusCode = statusCode;
+        sdk_interface_1.AurusSupport.paymentStatus.paymentEnvironment = this._paymentEnvironment;
+        logger.debug(`In emitPaymentStatus, publishing paymentStatus: ${JSON.stringify(sdk_interface_1.AurusSupport.paymentStatus)}`);
+        this._paymentEmitter.emit(_1.EventResponseTypes.PaymentDeviceStatus, sdk_interface_1.AurusSupport.paymentStatus);
+        sdk_interface_1.AurusSupport.paymentStatus = { deviceAvailable: false };
+        logger.traceExit(entryMessage);
+    }
+    emitAuthorizationResponse(responseCode, status) {
+        const entryMessage = logger.traceEntry("emitAuthorizationResponse");
+        sdk_interface_1.AurusSupport.authResponse.responseCode = responseCode;
+        sdk_interface_1.AurusSupport.authResponse.status = status;
+        logger.debug(`In emitAuthorizationResponse, publishing authResponse: ${JSON.stringify(sdk_interface_1.AurusSupport.authResponse)}`);
+        this._paymentEmitter.emit(_1.EventResponseTypes.Authorization, sdk_interface_1.AurusSupport.authResponse);
+        sdk_interface_1.AurusSupport.requestType = "";
+        logger.traceExit(entryMessage);
+    }
+    onAESDKLogResponse(...args) {
+        if (args.length >= 1 && args[0]) {
+            logger.debug(`onAESDKLogResponse: ${args[0]}`);
+        }
+    }
+    sendRequest(xmlRequest) {
+        logger.debug(`sendRequest: _requestInProgress = ${this._requestInProgress}`);
+        if (this._requestInProgress) {
+            // Note: This is being used to maintain order for rapid requests.
+            // It safeguards against enable/disable scanner from POS at the same time as other requests.
+            // If additional use cases are added, this should be revisted as well to maintain additional data.
+            this._requestQueue.push(xmlRequest);
+        }
+        else {
+            this._requestInProgress = true;
+            this._devicePaymentTerminal.OnAESDKProcessRequest(xmlRequest);
+        }
+    }
+    receiveResponse() {
+        this._requestInProgress = false;
+        if (this._requestQueue.length > 0) {
+            this.sendRequest(this._requestQueue.shift());
+        }
+    }
+};
+AurusDevice = __decorate([
+    inversify_1.injectable(),
+    __metadata("design:paramtypes", [])
+], AurusDevice);
+exports.AurusDevice = AurusDevice;
+//# sourceMappingURL=AurusDevice.js.map