@winible/winible-typed 1.0.0

package/src/pk-client.ts

@@ -0,0 +1,1650 @@
+import PKCustomerProfile, {
+  ProcessorId,
+} from "../typed-model/customer-profile";
+import PhoneUser from "../typed-model/phone-user";
+
+import {
+  APIContracts,
+  APIControllers,
+  Constants as PKConstants,
+} from "authorizenet";
+
+import { TransactionData, CreditCard, Address, PkSubStatus } from "./types";
+
+import moment = require("moment");
+import {
+  CustomerProfile,
+  Subscription,
+  SubscriptionPlan,
+} from "../typed-model";
+
+const mode = APIContracts.ValidationModeEnum.LIVEMODE;
+const DEFAULT_PROCESSOR = ProcessorId.KAJA;
+
+export type TransactionStatus =
+  | "authorizedPendingCapture"
+  | "capturedPendingSettlement"
+  | "communicationError"
+  | "refundSettledSuccessfully"
+  | "refundPendingSettlement"
+  | "approvedReview"
+  | "declined"
+  | "couldNotVoid"
+  | "expired"
+  | "generalError"
+  | "failedReview"
+  | "settledSuccessfully"
+  | "settlementError"
+  | "underReview"
+  | "voided"
+  | "FDSPendingReview"
+  | "FDSAuthorizedPendingReview"
+  | "returnedItem";
+
+const getCredentialsForProcessorId = (processorId: string) => {
+  let apiKey = process.env.PK_API_LOGIN_KEY!;
+  let transactionKey = process.env.PK_TRANSACTION_KEY!;
+
+  switch (processorId) {
+    case ProcessorId.HUMBOLDT:
+      apiKey = process.env.PK_API_LOGIN_KEY!;
+      transactionKey = process.env.PK_TRANSACTION_KEY!;
+      break;
+    case ProcessorId.KAJA:
+      apiKey = process.env.KAJA_API_LOGIN_KEY!;
+      transactionKey = process.env.KAJA_TRANSACTION_KEY!;
+      break;
+    case ProcessorId.KAJACOACHING:
+      apiKey = process.env.KAJACOACHING_API_LOGIN_KEY!;
+      transactionKey = process.env.KAJACOACHING_TRANSACTION_KEY!;
+      break;
+  }
+
+  return {
+    apiKey,
+    transactionKey,
+  };
+};
+
+const getMerchantAuthForCustomer = async (customerProfileId?: string) => {
+  let processorId = ProcessorId.HUMBOLDT;
+  let customerProfile = await CustomerProfile.findOne({
+    where: { customerProfileId },
+  });
+
+  if (customerProfile) {
+    processorId = customerProfile.processorId;
+  }
+  return getMerchantAuthForProcessor(processorId);
+};
+
+const getMerchantAuthForProcessor = (processorId: ProcessorId) => {
+  const response = getCredentialsForProcessorId(processorId);
+  const apiKey = response.apiKey;
+  const transactionKey = response.transactionKey;
+
+  const merchantAuthenticationType =
+    new APIContracts.MerchantAuthenticationType();
+  merchantAuthenticationType.setName(apiKey);
+  merchantAuthenticationType.setTransactionKey(transactionKey);
+  return {
+    merchantAuthenticationType,
+    processorId,
+  };
+};
+
+const buildCreditCard = (card: CreditCard) => {
+  let creditCard = new APIContracts.CreditCardType();
+  creditCard.setCardNumber(card.cardNumber);
+  creditCard.setExpirationDate(card.expirationDate);
+  creditCard.setCardCode(card.cardCode);
+  return creditCard;
+};
+
+const buildAddress = (address: Address) => {
+  let customerAddress = new APIContracts.CustomerAddressType();
+  customerAddress.setFirstName(address.firstName);
+  customerAddress.setLastName(address.lastName);
+  customerAddress.setAddress(address.address);
+  customerAddress.setCity(address.city);
+  customerAddress.setState(address.state);
+  customerAddress.setZip(address.zip);
+  customerAddress.setCountry(address.country);
+  return customerAddress;
+};
+
+export const createCustomerProfile = async (
+  user: PhoneUser,
+  data: TransactionData
+) => {
+  console.log("createCustomerProfile");
+  let { merchantAuthenticationType, processorId } =
+    await getMerchantAuthForProcessor(DEFAULT_PROCESSOR);
+
+  let creditCard = buildCreditCard(data.payment.creditCard);
+  let paymentType = new APIContracts.PaymentType();
+  paymentType.setCreditCard(creditCard);
+
+  let customerPaymentProfileType =
+    new APIContracts.CustomerPaymentProfileType();
+  customerPaymentProfileType.setCustomerType(
+    APIContracts.CustomerTypeEnum.INDIVIDUAL
+  );
+  customerPaymentProfileType.setPayment(paymentType);
+  customerPaymentProfileType.setDefaultPaymentProfile(true);
+
+  if (data.billTo) {
+    let customerAddress = buildAddress(data.billTo);
+    customerPaymentProfileType.setBillTo(customerAddress);
+  }
+
+  let paymentProfilesList = [customerPaymentProfileType];
+
+  let customerProfileType = new APIContracts.CustomerProfileType();
+  customerProfileType.setMerchantCustomerId(user.id);
+  customerProfileType.setEmail(user.email);
+  customerProfileType.setPaymentProfiles(paymentProfilesList);
+
+  let createRequest = new APIContracts.CreateCustomerProfileRequest();
+  createRequest.setProfile(customerProfileType);
+  createRequest.setValidationMode(mode);
+  createRequest.setMerchantAuthentication(merchantAuthenticationType);
+
+  //pretty print request
+  console.log(JSON.stringify(createRequest.getJSON(), null, 2));
+
+  let ctrl = new APIControllers.CreateCustomerProfileController(
+    createRequest.getJSON()
+  );
+  if (process.env.ENVIRONMENT === "production") {
+    ctrl.setEnvironment(PKConstants.endpoint.production);
+  }
+
+  return new Promise((resolve, reject) => {
+    ctrl.execute(function () {
+      let apiResponse = ctrl.getResponse();
+
+      let response = new APIContracts.CreateCustomerProfileResponse(
+        apiResponse
+      );
+
+      //pretty print response
+      console.log(JSON.stringify(response, null, 2));
+
+      if (response != null) {
+        if (
+          response.getMessages().getResultCode() ==
+          APIContracts.MessageTypeEnum.OK
+        ) {
+          PKCustomerProfile.create({
+            userId: user.id,
+            customerProfileId: response.getCustomerProfileId(),
+            processorId,
+          }).then(() =>
+            resolve([
+              response.getCustomerProfileId(),
+              response.getCustomerPaymentProfileIdList()[0],
+            ])
+          );
+        } else {
+          reject(response.getMessages().getMessage()[0].getText());
+        }
+      } else {
+        reject("Null response received");
+      }
+    });
+  });
+};
+
+export const getCustomerProfile = async (
+  customerProfileId?: string,
+  userId?: string
+): Promise<any> => {
+  let { merchantAuthenticationType, processorId } =
+    await getMerchantAuthForCustomer(customerProfileId);
+
+  let getRequest = new APIContracts.GetCustomerProfileRequest();
+  getRequest.setMerchantAuthentication(merchantAuthenticationType);
+  if (userId) {
+    getRequest.setMerchantCustomerId(userId);
+  } else {
+    getRequest.setCustomerProfileId(customerProfileId);
+  }
+
+  //pretty print request
+  //   console.log(JSON.stringify(getRequest.getJSON(), null, 2));
+
+  let ctrl = new APIControllers.GetCustomerProfileController(
+    getRequest.getJSON()
+  );
+  if (process.env.ENVIRONMENT === "production") {
+    ctrl.setEnvironment(PKConstants.endpoint.production);
+  }
+
+  return new Promise((resolve, reject) => {
+    ctrl.execute(function () {
+      let apiResponse = ctrl.getResponse();
+
+      let response = new APIContracts.GetCustomerProfileResponse(apiResponse);
+
+      //pretty print response
+
+      if (response != null) {
+        if (
+          response.getMessages().getResultCode() ==
+          APIContracts.MessageTypeEnum.OK
+        ) {
+          resolve(response.getProfile());
+        } else {
+          reject(response.getMessages().getMessage()[0].getText());
+        }
+      } else {
+        reject("Null response received");
+      }
+    });
+  });
+};
+
+export const getCustomerPaymentProfile = async (
+  customerProfileId: string,
+  customerPaymentProfileId: string
+): Promise<TransactionData> => {
+  let { merchantAuthenticationType, processorId } =
+    await getMerchantAuthForCustomer(customerProfileId);
+
+  let getRequest = new APIContracts.GetCustomerPaymentProfileRequest();
+  getRequest.setMerchantAuthentication(merchantAuthenticationType);
+  getRequest.setCustomerProfileId(customerProfileId);
+  getRequest.setCustomerPaymentProfileId(customerPaymentProfileId);
+
+  //pretty print request
+  //console.log(JSON.stringify(createRequest.getJSON(), null, 2));
+
+  let ctrl = new APIControllers.GetCustomerProfileController(
+    getRequest.getJSON()
+  );
+  if (process.env.ENVIRONMENT === "production") {
+    ctrl.setEnvironment(PKConstants.endpoint.production);
+  }
+  return new Promise((resolve, reject) => {
+    ctrl.execute(function () {
+      let apiResponse = ctrl.getResponse();
+
+      let response = new APIContracts.GetCustomerPaymentProfileResponse(
+        apiResponse
+      );
+
+      //pretty print response
+      //console.log(JSON.stringify(response, null, 2));
+
+      if (response != null) {
+        if (
+          response.getMessages().getResultCode() ==
+          APIContracts.MessageTypeEnum.OK
+        ) {
+          resolve(response.getPaymentProfile());
+        } else {
+          reject(response.getMessages().getMessage()[0].getText());
+        }
+      } else {
+        reject("Get payment profile Null response received");
+      }
+    });
+  });
+};
+
+export const addPaymentProfile = async (
+  customerProfileId: string,
+  data: TransactionData
+): Promise<string> => {
+  let { merchantAuthenticationType, processorId } =
+    await getMerchantAuthForCustomer(customerProfileId);
+
+  let creditCard = buildCreditCard(data.payment.creditCard);
+
+  let paymentType = new APIContracts.PaymentType();
+  paymentType.setCreditCard(creditCard);
+
+  let customerAddress = buildAddress(data.billTo);
+
+  let profile = new APIContracts.CustomerPaymentProfileType();
+  profile.setBillTo(customerAddress);
+  profile.setPayment(paymentType);
+  profile.setDefaultPaymentProfile(data.defaultPaymentProfile || false);
+
+  let createRequest = new APIContracts.CreateCustomerPaymentProfileRequest();
+
+  createRequest.setMerchantAuthentication(merchantAuthenticationType);
+  createRequest.setCustomerProfileId(customerProfileId);
+  createRequest.setPaymentProfile(profile);
+
+  //pretty print request
+  // console.log(JSON.stringify(createRequest.getJSON(), null, 2));
+
+  let ctrl = new APIControllers.CreateCustomerPaymentProfileController(
+    createRequest.getJSON()
+  );
+
+  if (process.env.ENVIRONMENT === "production") {
+    ctrl.setEnvironment(PKConstants.endpoint.production);
+  }
+
+  return new Promise((resolve, reject) => {
+    ctrl.execute(function () {
+      let apiResponse = ctrl.getResponse();
+
+      let response = new APIContracts.CreateCustomerPaymentProfileResponse(
+        apiResponse
+      );
+
+      //pretty print response
+      console.log(JSON.stringify(response, null, 2));
+
+      if (response != null) {
+        if (
+          response.getMessages().getResultCode() ==
+          APIContracts.MessageTypeEnum.OK
+        ) {
+          resolve(response.getCustomerPaymentProfileId());
+        } else {
+          reject(response.getMessages().getMessage()[0].getText());
+        }
+      } else {
+        reject("Null response received");
+      }
+    });
+  });
+};
+
+export const deleteCustomerProfile = async (
+  customerProfileId: string,
+  customerPaymentProfileId: string
+) => {
+  let { merchantAuthenticationType, processorId } =
+    await getMerchantAuthForCustomer(customerProfileId);
+
+  let deleteRequest = new APIContracts.DeleteCustomerPaymentProfileRequest();
+  deleteRequest.setMerchantAuthentication(merchantAuthenticationType);
+  deleteRequest.setCustomerProfileId(customerProfileId);
+  deleteRequest.setCustomerPaymentProfileId(customerPaymentProfileId);
+
+  //pretty print request
+  //console.log(JSON.stringify(createRequest.getJSON(), null, 2));
+
+  let ctrl = new APIControllers.DeleteCustomerPaymentProfileController(
+    deleteRequest.getJSON()
+  );
+  if (process.env.ENVIRONMENT === "production") {
+    ctrl.setEnvironment(PKConstants.endpoint.production);
+  }
+
+  return new Promise((resolve, reject) => {
+    ctrl.execute(function () {
+      let apiResponse = ctrl.getResponse();
+
+      let response = new APIContracts.DeleteCustomerPaymentProfileResponse(
+        apiResponse
+      );
+      if (response != null) {
+        if (
+          response.getMessages().getResultCode() ==
+          APIContracts.MessageTypeEnum.OK
+        ) {
+          resolve(customerPaymentProfileId);
+        } else {
+          reject(response.getMessages().getMessage()[0].getText());
+        }
+      } else {
+        reject("Null response received");
+      }
+    });
+  });
+};
+
+export const updateCustomerProfile = async (
+  customerProfileId: string,
+  customerPaymentProfileId: string,
+  data: TransactionData
+): Promise<{ customerPaymentProfileId: string; processorId: ProcessorId }> => {
+  let { merchantAuthenticationType, processorId } =
+    await getMerchantAuthForCustomer(customerProfileId);
+
+  let oldProfile: TransactionData = await getCustomerPaymentProfile(
+    customerProfileId,
+    customerPaymentProfileId
+  );
+  console.log(oldProfile);
+  if (!oldProfile) {
+    throw Error("No payment profile found");
+  }
+
+  let creditCardForUpdate = buildCreditCard(
+    (data.payment && data.payment.creditCard) || oldProfile.payment.creditCard
+  );
+
+  let paymentType = new APIContracts.PaymentType();
+  paymentType.setCreditCard(creditCardForUpdate);
+
+  let customerAddressType = buildAddress(data.billTo || oldProfile.billTo);
+
+  let customerForUpdate = new APIContracts.CustomerPaymentProfileExType();
+  customerForUpdate.setPayment(paymentType);
+  //customerForUpdate.setDefaultPaymentProfile(true);
+  customerForUpdate.setDefaultPaymentProfile(
+    data.defaultPaymentProfile || false
+  );
+
+  customerForUpdate.setCustomerPaymentProfileId(customerPaymentProfileId);
+  customerForUpdate.setBillTo(customerAddressType);
+
+  let updateRequest = new APIContracts.UpdateCustomerPaymentProfileRequest();
+  updateRequest.setMerchantAuthentication(merchantAuthenticationType);
+  updateRequest.setCustomerProfileId(customerProfileId);
+  updateRequest.setPaymentProfile(customerForUpdate);
+  updateRequest.setValidationMode(mode);
+
+  let ctrl = new APIControllers.UpdateCustomerPaymentProfileController(
+    updateRequest.getJSON()
+  );
+  if (process.env.ENVIRONMENT === "production") {
+    ctrl.setEnvironment(PKConstants.endpoint.production);
+  }
+
+  return new Promise((resolve, reject) => {
+    ctrl.execute(function () {
+      let apiResponse = ctrl.getResponse();
+
+      let response = new APIContracts.UpdateCustomerPaymentProfileResponse(
+        apiResponse
+      );
+
+      if (response != null) {
+        if (
+          response.getMessages().getResultCode() ==
+          APIContracts.MessageTypeEnum.OK
+        ) {
+          console.log(
+            "Successfully updated a customer payment profile with id: " +
+              customerPaymentProfileId
+          );
+          resolve({ customerPaymentProfileId, processorId });
+        } else {
+          reject(response.getMessages().getMessage()[0].getText());
+        }
+      } else {
+        reject("Null response received");
+      }
+    });
+  });
+};
+
+export const chargeCreditCardAndCreateProfile = async (
+  user: PhoneUser,
+  data: TransactionData,
+  amountInCents: number,
+  description: string,
+  skipProfileCreation?: boolean,
+  useCoachingMid?: boolean
+): Promise<{
+  amountInCents: number;
+  transactionId: string;
+  pkCustomerProfileId?: string;
+  pkCustomerPaymentProfileId?: string;
+  processorId: ProcessorId;
+}> => {
+  let { merchantAuthenticationType, processorId } =
+    await getMerchantAuthForProcessor(
+      useCoachingMid ? DEFAULT_PROCESSOR : DEFAULT_PROCESSOR
+    );
+
+  let creditCard = buildCreditCard(data.payment.creditCard);
+  let paymentType = new APIContracts.PaymentType();
+  paymentType.setCreditCard(creditCard);
+
+  let customerAddress = buildAddress(data.billTo);
+
+  var userField = new APIContracts.UserField();
+  userField.setName("userId");
+  userField.setValue(user.id);
+
+  var userFields = new APIContracts.TransactionRequestType.UserFields();
+  var ufArray: any = [userField];
+  userFields.setUserField(ufArray);
+
+  var transactionSetting1 = new APIContracts.SettingType();
+  transactionSetting1.setSettingName("duplicateWindow");
+  transactionSetting1.setSettingValue("5");
+
+  var transactionSetting2 = new APIContracts.SettingType();
+  transactionSetting2.setSettingName("recurringBilling");
+  transactionSetting2.setSettingValue("false");
+
+  var transactionSettingList = [transactionSetting1, transactionSetting2];
+
+  var transactionSettings = new APIContracts.ArrayOfSetting();
+  transactionSettings.setSetting(transactionSettingList);
+
+  var profile = new APIContracts.CustomerProfilePaymentType();
+  profile.setCreateProfile(skipProfileCreation ? false : true);
+
+  let customerProfileType = new APIContracts.CustomerType();
+  customerProfileType.setId(user.id);
+  customerProfileType.setEmail(user.email);
+  customerProfileType.setType(APIContracts.CustomerTypeEnum.INDIVIDUAL);
+
+  // let customerBaseType = new APIContracts.CustomerPaymentProfileBaseType();
+  // customerBaseType.setCustomerType(customerProfileType);
+  // customerBaseType.setBillTo(customerAddress);
+
+  var orderDetails = new APIContracts.OrderType();
+  orderDetails.setDescription(description);
+
+  var transactionRequestType = new APIContracts.TransactionRequestType();
+  transactionRequestType.setTransactionType(
+    APIContracts.TransactionTypeEnum.AUTHCAPTURETRANSACTION
+  );
+  transactionRequestType.setPayment(paymentType);
+  transactionRequestType.setAmount(amountInCents / 100.0);
+  transactionRequestType.setUserFields(userFields);
+  transactionRequestType.setOrder(orderDetails);
+  transactionRequestType.setBillTo(customerAddress);
+  transactionRequestType.setTransactionSettings(transactionSettings);
+  transactionRequestType.setProfile(profile);
+  transactionRequestType.setCustomer(customerProfileType);
+
+  var createRequest = new APIContracts.CreateTransactionRequest();
+  createRequest.setMerchantAuthentication(merchantAuthenticationType);
+  createRequest.setTransactionRequest(transactionRequestType);
+
+  var ctrl = new APIControllers.CreateTransactionController(
+    createRequest.getJSON()
+  );
+
+  if (process.env.ENVIRONMENT === "production") {
+    ctrl.setEnvironment(PKConstants.endpoint.production);
+  }
+
+  return new Promise((resolve, reject) => {
+    ctrl.execute(function () {
+      let apiResponse = ctrl.getResponse();
+
+      let response = new APIContracts.CreateTransactionResponse(apiResponse);
+
+      //pretty print response
+      console.log(JSON.stringify(response, null, 2));
+
+      if (response != null) {
+        let transactionResponse = response.getTransactionResponse();
+        let profileResponse = response.getProfileResponse();
+        if (
+          response.getMessages().getResultCode() ==
+          APIContracts.MessageTypeEnum.OK
+        ) {
+          if (transactionResponse.getMessages() != null) {
+            return resolve({
+              amountInCents,
+              transactionId: transactionResponse.getTransId(),
+              pkCustomerProfileId:
+                profileResponse && profileResponse.getCustomerProfileId(),
+              pkCustomerPaymentProfileId:
+                profileResponse &&
+                profileResponse.getCustomerPaymentProfileIdList() &&
+                profileResponse
+                  .getCustomerPaymentProfileIdList()
+                  .getNumericString()[0]
+                  .toString(),
+              processorId,
+            });
+          } else {
+            if (transactionResponse.getErrors() != null) {
+              return reject(
+                transactionResponse.getErrors().getError()[0].getErrorText()
+              );
+            }
+          }
+        } else {
+          console.log("Failed Transaction. ");
+          if (
+            transactionResponse != null &&
+            transactionResponse.getErrors() != null
+          ) {
+            return reject(
+              transactionResponse.getErrors().getError()[0].getErrorText()
+            );
+          } else {
+            return reject(response.getMessages().getMessage()[0].getText());
+          }
+        }
+      } else {
+        reject("Null response received");
+      }
+    });
+  });
+};
+
+export const purchaseCreditsWithCreditCardAndCreatorProfile = async (
+  user: PhoneUser,
+  data: TransactionData,
+  amountInCents: number
+): Promise<{
+  amountInCents: number;
+  transactionId: string;
+  processorId: ProcessorId;
+}> => {
+  let chargeResponse = await chargeCreditCardAndCreateProfile(
+    user,
+    data,
+    amountInCents,
+    "CLIQ Credits"
+  );
+
+  if (
+    chargeResponse.pkCustomerProfileId &&
+    chargeResponse.pkCustomerPaymentProfileId
+  ) {
+    await updateUserPaymentProfile(
+      user.id,
+      chargeResponse.pkCustomerProfileId,
+      chargeResponse.processorId,
+      chargeResponse.pkCustomerPaymentProfileId
+    );
+  }
+  return {
+    amountInCents: chargeResponse.amountInCents,
+    transactionId: chargeResponse.transactionId,
+    processorId: chargeResponse.processorId,
+  };
+};
+
+export const purchaseCreditsWithCustomerProfile = async (
+  customerProfileId: string,
+  customerPaymentProfileId: string,
+  amountInCents: number
+) => {
+  return await chargeCustomerByPaymentProfile(
+    customerProfileId,
+    customerPaymentProfileId,
+    amountInCents,
+    "CLIQ Credits"
+  );
+};
+
+export const chargeCustomerByPaymentProfile = async (
+  customerProfileId: string,
+  customerPaymentProfileId: string,
+  amountInCents: number,
+  description: string
+): Promise<{
+  amountInCents: number;
+  transactionId: string;
+  processorId: ProcessorId;
+}> => {
+  let { merchantAuthenticationType, processorId } =
+    await getMerchantAuthForCustomer(customerProfileId);
+
+  var profileToCharge = new APIContracts.CustomerProfilePaymentType();
+  profileToCharge.setCustomerProfileId(customerProfileId);
+
+  var paymentProfile = new APIContracts.PaymentProfile();
+  paymentProfile.setPaymentProfileId(customerPaymentProfileId);
+  profileToCharge.setPaymentProfile(paymentProfile);
+
+  var orderDetails = new APIContracts.OrderType();
+  orderDetails.setDescription(description);
+
+  var duplicateWindow: any = new APIContracts.SettingType();
+  duplicateWindow.setSettingName("duplicateWindow");
+  duplicateWindow.setSettingValue("5");
+
+  var transactionSettingList: any[] = [];
+  transactionSettingList.push(duplicateWindow);
+
+  var transactionSettings = new APIContracts.ArrayOfSetting();
+  transactionSettings.setSetting(transactionSettingList);
+
+  var transactionRequestType = new APIContracts.TransactionRequestType();
+  transactionRequestType.setTransactionType(
+    APIContracts.TransactionTypeEnum.AUTHCAPTURETRANSACTION
+  );
+  transactionRequestType.setProfile(profileToCharge);
+  transactionRequestType.setAmount(amountInCents / 100.0);
+  transactionRequestType.setTransactionSettings(transactionSettings);
+  transactionRequestType.setOrder(orderDetails);
+
+  var createRequest = new APIContracts.CreateTransactionRequest();
+  createRequest.setMerchantAuthentication(merchantAuthenticationType);
+  createRequest.setTransactionRequest(transactionRequestType);
+
+  var ctrl = new APIControllers.CreateTransactionController(
+    createRequest.getJSON()
+  );
+  if (process.env.ENVIRONMENT === "production") {
+    ctrl.setEnvironment(PKConstants.endpoint.production);
+  }
+
+  return new Promise((resolve, reject) => {
+    ctrl.execute(function () {
+      var apiResponse = ctrl.getResponse();
+
+      var response = new APIContracts.CreateTransactionResponse(apiResponse);
+
+      //pretty print response
+      console.log(JSON.stringify(response, null, 2));
+
+      if (response != null) {
+        if (
+          response.getMessages().getResultCode() ==
+          APIContracts.MessageTypeEnum.OK
+        ) {
+          if (response.getTransactionResponse().getMessages() != null) {
+            // Success
+            console.log("Successful transaction");
+            resolve({
+              transactionId: response.getTransactionResponse().getTransId(),
+              amountInCents,
+              processorId,
+            });
+          } else {
+            console.log("Failed Transaction.");
+            if (response.getTransactionResponse().getErrors() != null) {
+              reject(
+                response
+                  .getTransactionResponse()
+                  .getErrors()
+                  .getError()[0]
+                  .getErrorText()
+              );
+            } else {
+              reject("Failed Transaction.");
+            }
+          }
+        } else {
+          if (
+            response.getTransactionResponse() != null &&
+            response.getTransactionResponse().getErrors() != null
+          ) {
+            reject(
+              response
+                .getTransactionResponse()
+                .getErrors()
+                .getError()[0]
+                .getErrorText()
+            );
+          } else {
+            reject(response.getMessages().getMessage()[0].getText());
+          }
+        }
+      } else {
+        reject("Null Response.");
+      }
+    });
+  });
+};
+
+export async function createSubscription({
+  intervalCount,
+  intervalUnit,
+  trialLength,
+  amountInCents,
+  trialAmountInCents,
+  customerProfileId,
+  customerPaymentProfileId,
+  creatorName,
+  processorId,
+  startDate,
+}: {
+  intervalCount: number;
+  intervalUnit: "months" | "days";
+  trialAmountInCents: number;
+  trialLength: number;
+  amountInCents: number;
+  customerProfileId: string;
+  customerPaymentProfileId: string;
+  creatorName: string;
+  processorId: ProcessorId;
+  startDate?: Date;
+}): Promise<{ pkSubId: string }> {
+  try {
+    let { merchantAuthenticationType } = await getMerchantAuthForProcessor(
+      processorId
+    );
+
+    return new Promise(async (resolve, reject) => {
+      var interval = new APIContracts.PaymentScheduleType.Interval();
+      interval.setLength(intervalCount);
+      interval.setUnit(intervalUnit);
+
+      var paymentScheduleType = new APIContracts.PaymentScheduleType();
+      paymentScheduleType.setInterval(interval);
+
+      paymentScheduleType.setStartDate(
+        moment(startDate)
+          .add(intervalCount, intervalUnit)
+          .add(1, "day")
+          .toISOString()
+          .substring(0, 10)
+      );
+      paymentScheduleType.setTotalOccurrences(9999);
+      paymentScheduleType.setTrialOccurrences(trialLength);
+
+      var customerProfileIdType = new APIContracts.CustomerProfileIdType();
+      customerProfileIdType.setCustomerProfileId(customerProfileId);
+      customerProfileIdType.setCustomerPaymentProfileId(
+        customerPaymentProfileId
+      );
+
+      var arbSubscription = new APIContracts.ARBSubscriptionType();
+      arbSubscription.setName(
+        `${creatorName} ${
+          intervalUnit == "days" ? "weekly" : "monthly"
+        } subscription`
+      );
+      arbSubscription.setPaymentSchedule(paymentScheduleType);
+      arbSubscription.setAmount(amountInCents / 100.0);
+      arbSubscription.setTrialAmount((trialAmountInCents || 0) / 100.0);
+      arbSubscription.setProfile(customerProfileIdType);
+
+      var createRequest = new APIContracts.ARBCreateSubscriptionRequest();
+      createRequest.setMerchantAuthentication(merchantAuthenticationType);
+      createRequest.setSubscription(arbSubscription);
+
+      var ctrl = new APIControllers.ARBCreateSubscriptionController(
+        createRequest.getJSON()
+      );
+      if (process.env.ENVIRONMENT === "production") {
+        ctrl.setEnvironment(PKConstants.endpoint.production);
+      }
+
+      ctrl.execute(function () {
+        var apiResponse = ctrl.getResponse();
+
+        var response = new APIContracts.ARBCreateSubscriptionResponse(
+          apiResponse
+        );
+
+        console.log(JSON.stringify(response, null, 2));
+
+        if (response != null) {
+          if (
+            response.getMessages().getResultCode() ==
+            APIContracts.MessageTypeEnum.OK
+          ) {
+            resolve({ pkSubId: response.getSubscriptionId() });
+          } else {
+            reject(response.getMessages().getMessage()[0].getText());
+          }
+        } else {
+          reject("Null Response.");
+        }
+      });
+    });
+  } catch (err) {
+    console.log(err);
+    throw new Error("Subscription failed to create");
+  }
+}
+
+export async function createSubscriptionWithCreditCard({
+  intervalCount,
+  intervalUnit,
+  trialLength,
+  amountInCents,
+  trialAmountInCents,
+  data,
+  creatorName,
+  processorId: processorId,
+}: {
+  intervalCount: number;
+  intervalUnit: "months" | "days";
+  trialAmountInCents: number;
+  trialLength: number;
+  amountInCents: number;
+  data: TransactionData;
+  creatorName: string;
+  processorId: ProcessorId;
+}): Promise<{
+  pkSubId: string;
+  paymentProfile: {
+    pkCustomerProfileId?: string;
+    pkCustomerPaymentProfileId?: string;
+    processorId: ProcessorId;
+  };
+}> {
+  try {
+    let { merchantAuthenticationType } = await getMerchantAuthForProcessor(
+      processorId
+    );
+
+    return new Promise(async (resolve, reject) => {
+      var interval = new APIContracts.PaymentScheduleType.Interval();
+      interval.setLength(intervalCount);
+      interval.setUnit(intervalUnit);
+
+      var paymentScheduleType = new APIContracts.PaymentScheduleType();
+      paymentScheduleType.setInterval(interval);
+
+      paymentScheduleType.setStartDate(
+        moment()
+          .add(intervalCount, intervalUnit)
+          .add(1, "day")
+          .toISOString()
+          .substring(0, 10)
+      );
+      paymentScheduleType.setTotalOccurrences(9999);
+      paymentScheduleType.setTrialOccurrences(trialLength);
+
+      let creditCard = buildCreditCard(data.payment.creditCard);
+      let paymentType = new APIContracts.PaymentType();
+      paymentType.setCreditCard(creditCard);
+
+      let customerAddress = buildAddress(data.billTo);
+
+      var arbSubscription = new APIContracts.ARBSubscriptionType();
+      arbSubscription.setName(
+        `${creatorName} ${
+          intervalUnit == "days" ? "weekly" : "monthly"
+        } subscription`
+      );
+      arbSubscription.setPaymentSchedule(paymentScheduleType);
+      arbSubscription.setAmount(amountInCents / 100.0);
+      arbSubscription.setTrialAmount((trialAmountInCents || 0) / 100.0);
+      arbSubscription.setBillTo(customerAddress);
+      arbSubscription.setPayment(paymentType);
+
+      var createRequest = new APIContracts.ARBCreateSubscriptionRequest();
+      createRequest.setMerchantAuthentication(merchantAuthenticationType);
+      createRequest.setSubscription(arbSubscription);
+
+      var ctrl = new APIControllers.ARBCreateSubscriptionController(
+        createRequest.getJSON()
+      );
+      if (process.env.ENVIRONMENT === "production") {
+        ctrl.setEnvironment(PKConstants.endpoint.production);
+      }
+
+      ctrl.execute(function () {
+        var apiResponse = ctrl.getResponse();
+
+        var response = new APIContracts.ARBCreateSubscriptionResponse(
+          apiResponse
+        );
+
+        console.log(JSON.stringify(response, null, 2));
+
+        if (response != null) {
+          if (
+            response.getMessages().getResultCode() ==
+            APIContracts.MessageTypeEnum.OK
+          ) {
+            let profileResponse = response.getProfile();
+            let pkCustomerProfileId =
+              profileResponse && profileResponse.getCustomerProfileId();
+            let pkCustomerPaymentProfileId =
+              profileResponse &&
+              profileResponse.getCustomerPaymentProfileId &&
+              profileResponse.getCustomerPaymentProfileId() &&
+              profileResponse.getCustomerPaymentProfileId().getNumericString &&
+              profileResponse
+                .getCustomerPaymentProfileId()
+                .getNumericString()
+                .toString();
+            resolve({
+              pkSubId: response.getSubscriptionId(),
+              paymentProfile: {
+                pkCustomerProfileId,
+                pkCustomerPaymentProfileId,
+                processorId,
+              },
+            });
+          } else {
+            reject(response.getMessages().getMessage()[0].getText());
+          }
+        } else {
+          reject("Null Response.");
+        }
+      });
+    });
+  } catch (err) {
+    console.log(err);
+    throw new Error("Subscription failed to create");
+  }
+}
+
+export async function cancelSubscription(
+  subscription: Subscription,
+  processorId: ProcessorId
+) {
+  let { merchantAuthenticationType } = await getMerchantAuthForProcessor(
+    processorId
+  );
+
+  var cancelRequest = new APIContracts.ARBCancelSubscriptionRequest();
+  cancelRequest.setMerchantAuthentication(merchantAuthenticationType);
+  cancelRequest.setSubscriptionId(subscription.pkSubscriptionId);
+
+  var ctrl = new APIControllers.ARBCancelSubscriptionController(
+    cancelRequest.getJSON()
+  );
+  if (process.env.ENVIRONMENT === "production") {
+    ctrl.setEnvironment(PKConstants.endpoint.production);
+  }
+
+  return new Promise((resolve, reject) => {
+    ctrl.execute(function () {
+      var apiResponse = ctrl.getResponse();
+
+      var response = new APIContracts.ARBCancelSubscriptionResponse(
+        apiResponse
+      );
+
+      console.log(JSON.stringify(response, null, 2));
+
+      if (response != null) {
+        if (
+          response.getMessages().getResultCode() ==
+          APIContracts.MessageTypeEnum.OK
+        ) {
+          resolve(true);
+        } else {
+          reject(response.getMessages().getMessage()[0].getText());
+        }
+      } else {
+        reject("Null Response.");
+      }
+    });
+  });
+}
+
+export async function updateSubscription({
+  authSubscriptionId,
+  intervalCount,
+  intervalUnit,
+  processorId: processorId,
+}: {
+  authSubscriptionId: number;
+  intervalCount: number;
+  intervalUnit: "months" | "days";
+  processorId: ProcessorId;
+}) {
+  let { merchantAuthenticationType } = await getMerchantAuthForProcessor(
+    processorId
+  );
+
+  var paymentScheduleType = new APIContracts.PaymentScheduleType();
+
+  paymentScheduleType.setStartDate(
+    moment()
+      .add(intervalCount, intervalUnit)
+      .add(1, "day")
+      .toISOString()
+      .substring(0, 10)
+  );
+
+  var arbSubscription = new APIContracts.ARBSubscriptionType();
+  arbSubscription.setPaymentSchedule(paymentScheduleType);
+
+  var updateRequest = new APIContracts.ARBUpdateSubscriptionRequest();
+  updateRequest.setMerchantAuthentication(merchantAuthenticationType);
+  updateRequest.setSubscriptionId(authSubscriptionId);
+  updateRequest.setSubscription(arbSubscription);
+
+  console.log(JSON.stringify(updateRequest.getJSON(), null, 2));
+
+  var ctrl = new APIControllers.ARBUpdateSubscriptionController(
+    updateRequest.getJSON()
+  );
+  if (process.env.ENVIRONMENT === "production") {
+    ctrl.setEnvironment(PKConstants.endpoint.production);
+  }
+
+  return new Promise((resolve, reject) => {
+    ctrl.execute(function () {
+      var apiResponse = ctrl.getResponse();
+
+      var response = new APIContracts.ARBUpdateSubscriptionResponse(
+        apiResponse
+      );
+
+      console.log(JSON.stringify(response, null, 2));
+
+      if (response != null) {
+        if (
+          response.getMessages().getResultCode() ==
+          APIContracts.MessageTypeEnum.OK
+        ) {
+          resolve(true);
+        } else {
+          reject(response.getMessages().getMessage()[0].getText());
+        }
+      } else {
+        reject("Null Response.");
+      }
+    });
+  });
+}
+
+export async function getSubscription(
+  subscriptionId: string,
+  processorId: ProcessorId
+) {
+  let { merchantAuthenticationType } = await getMerchantAuthForProcessor(
+    processorId
+  );
+
+  var getRequest = new APIContracts.ARBGetSubscriptionRequest();
+  getRequest.setMerchantAuthentication(merchantAuthenticationType);
+  getRequest.setSubscriptionId(subscriptionId);
+  getRequest.setIncludeTransactions(true);
+
+  var ctrl = new APIControllers.ARBGetSubscriptionController(
+    getRequest.getJSON()
+  );
+
+  if (process.env.ENVIRONMENT === "production") {
+    ctrl.setEnvironment(PKConstants.endpoint.production);
+  }
+
+  return new Promise((resolve, reject) => {
+    ctrl.execute(function () {
+      var apiResponse = ctrl.getResponse();
+
+      var response = new APIContracts.ARBGetSubscriptionResponse(apiResponse);
+
+      if (response != null) {
+        if (
+          response.getMessages().getResultCode() ==
+          APIContracts.MessageTypeEnum.OK
+        ) {
+          resolve(response.getSubscription());
+        } else {
+          reject(response.getMessages().getMessage()[0].getText());
+        }
+      } else {
+        reject("Null Response.");
+      }
+    });
+  });
+}
+
+export async function getSubscriptionStatus(
+  subscriptionId: string,
+  processorId: ProcessorId
+): Promise<PkSubStatus> {
+  let { merchantAuthenticationType } = await getMerchantAuthForProcessor(
+    processorId
+  );
+
+  var getRequest = new APIContracts.ARBGetSubscriptionStatusRequest();
+  getRequest.setMerchantAuthentication(merchantAuthenticationType);
+  getRequest.setSubscriptionId(subscriptionId);
+
+  var ctrl = new APIControllers.ARBGetSubscriptionStatusController(
+    getRequest.getJSON()
+  );
+
+  if (process.env.ENVIRONMENT === "production") {
+    ctrl.setEnvironment(PKConstants.endpoint.production);
+  }
+
+  return new Promise((resolve, reject) => {
+    ctrl.execute(function () {
+      var apiResponse = ctrl.getResponse();
+
+      var response = new APIContracts.ARBGetSubscriptionStatusResponse(
+        apiResponse
+      );
+
+      if (response != null) {
+        if (
+          response.getMessages().getResultCode() ==
+          APIContracts.MessageTypeEnum.OK
+        ) {
+          resolve(response.getStatus());
+        } else {
+          reject(response.getMessages().getMessage()[0].getText());
+        }
+      } else {
+        reject("Null Response.");
+      }
+    });
+  });
+}
+
+export async function getSubscriptionList(
+  processorId: ProcessorId,
+  inactive?: boolean
+): Promise<APIContracts.SubscriptionDetail[]> {
+  let { merchantAuthenticationType } = await getMerchantAuthForProcessor(
+    processorId
+  );
+
+  var sorting = new APIContracts.ARBGetSubscriptionListSorting();
+  sorting.setOrderDescending(true);
+  sorting.setOrderBy(
+    APIContracts.ARBGetSubscriptionListOrderFieldEnum.CREATETIMESTAMPUTC
+  );
+
+  var listRequest = new APIContracts.ARBGetSubscriptionListRequest();
+
+  listRequest.setMerchantAuthentication(merchantAuthenticationType);
+
+  listRequest.setSearchType(
+    inactive
+      ? APIContracts.ARBGetSubscriptionListSearchTypeEnum.SUBSCRIPTIONINACTIVE
+      : APIContracts.ARBGetSubscriptionListSearchTypeEnum.SUBSCRIPTIONACTIVE
+  );
+
+  listRequest.setSorting(sorting);
+
+  console.log(JSON.stringify(listRequest.getJSON(), null, 2));
+
+  var ctrl = new APIControllers.ARBGetSubscriptionListController(
+    listRequest.getJSON()
+  );
+
+  if (process.env.ENVIRONMENT === "production") {
+    ctrl.setEnvironment(PKConstants.endpoint.production);
+  }
+
+  return new Promise((resolve, reject) => {
+    ctrl.execute(function () {
+      var apiResponse = ctrl.getResponse();
+
+      var response = new APIContracts.ARBGetSubscriptionListResponse(
+        apiResponse
+      );
+
+      if (response != null) {
+        if (
+          response.getMessages().getResultCode() ==
+          APIContracts.MessageTypeEnum.OK
+        ) {
+          console.log("Total Results: " + response.getTotalNumInResultSet());
+          var subscriptions = response
+            .getSubscriptionDetails()
+            .getSubscriptionDetail();
+          resolve(subscriptions);
+        } else {
+          console.log("Result Code: " + response.getMessages().getResultCode());
+          console.log(
+            "Error Code: " + response.getMessages().getMessage()[0].getCode()
+          );
+          console.log(
+            "Error message: " + response.getMessages().getMessage()[0].getText()
+          );
+          reject();
+        }
+      } else {
+        reject();
+      }
+    });
+  });
+}
+
+export async function voidTransaction(
+  transactionId: string,
+  processorId: ProcessorId
+) {
+  let { merchantAuthenticationType } = await getMerchantAuthForProcessor(
+    processorId
+  );
+
+  var transactionRequestType = new APIContracts.TransactionRequestType();
+  transactionRequestType.setTransactionType(
+    APIContracts.TransactionTypeEnum.VOIDTRANSACTION
+  );
+  transactionRequestType.setRefTransId(transactionId);
+
+  var createRequest = new APIContracts.CreateTransactionRequest();
+  createRequest.setMerchantAuthentication(merchantAuthenticationType);
+  createRequest.setTransactionRequest(transactionRequestType);
+
+  var ctrl = new APIControllers.CreateTransactionController(
+    createRequest.getJSON()
+  );
+
+  if (process.env.ENVIRONMENT === "production") {
+    ctrl.setEnvironment(PKConstants.endpoint.production);
+  }
+
+  return new Promise((resolve, reject) => {
+    ctrl.execute(function () {
+      var apiResponse = ctrl.getResponse();
+
+      var response = new APIContracts.CreateTransactionResponse(apiResponse);
+
+      if (response != null) {
+        if (
+          response.getMessages().getResultCode() ==
+          APIContracts.MessageTypeEnum.OK
+        ) {
+          if (response.getTransactionResponse().getMessages() != null) {
+            resolve(true);
+          } else {
+            if (response.getTransactionResponse().getErrors() != null) {
+              reject(
+                response
+                  .getTransactionResponse()
+                  .getErrors()
+                  .getError()[0]
+                  .getErrorText()
+              );
+            }
+          }
+        } else {
+          console.log("Failed Transaction. ");
+          if (
+            response.getTransactionResponse() != null &&
+            response.getTransactionResponse().getErrors() != null
+          ) {
+            reject(
+              response
+                .getTransactionResponse()
+                .getErrors()
+                .getError()[0]
+                .getErrorText()
+            );
+          } else {
+            reject(response.getMessages().getMessage()[0].getText());
+          }
+        }
+      } else {
+        console.log("Null Response.");
+      }
+    });
+  });
+}
+
+export const updateUserPaymentProfile = async (
+  userId: string,
+  customerProfileId: string,
+  processorId: ProcessorId,
+  pkCustomerPaymentProfileId?: string
+): Promise<PKCustomerProfile> => {
+  console.log("Update payment profile");
+  let profile = await PKCustomerProfile.findOne({
+    where: { userId: userId },
+  });
+  if (!profile) {
+    console.log("Create new payment profile");
+    profile = await PKCustomerProfile.create({
+      userId: userId,
+      customerProfileId: customerProfileId,
+      defaultPaymentProfileId: pkCustomerPaymentProfileId,
+      processorId,
+    });
+  } else {
+    profile.customerProfileId = customerProfileId;
+    profile.defaultPaymentProfileId = pkCustomerPaymentProfileId;
+    profile.processorId = processorId;
+    await profile.save();
+  }
+  return profile;
+};
+
+export async function getTransactionsForCustomerProfile({
+  customerProfileId,
+  processorId,
+}: {
+  customerProfileId: string;
+  processorId: ProcessorId;
+}): Promise<
+  {
+    transId: string;
+    amountInCents: number;
+    status: string;
+  }[]
+> {
+  let { merchantAuthenticationType } = await getMerchantAuthForProcessor(
+    processorId
+  );
+
+  var paging = new APIContracts.Paging();
+  paging.setLimit(10);
+  paging.setOffset(1);
+
+  var sorting = new APIContracts.TransactionListSorting();
+  sorting.setOrderBy(APIContracts.TransactionListOrderFieldEnum.ID);
+  sorting.setOrderDescending(true);
+
+  var getRequest = new APIContracts.GetTransactionListForCustomerRequest();
+  getRequest.setMerchantAuthentication(merchantAuthenticationType);
+  getRequest.setCustomerProfileId(customerProfileId);
+  getRequest.setPaging(paging);
+  getRequest.setSorting(sorting);
+
+  console.log(JSON.stringify(getRequest.getJSON(), null, 2));
+
+  var ctrl = new APIControllers.GetTransactionListForCustomerController(
+    getRequest.getJSON()
+  );
+
+  if (process.env.ENVIRONMENT === "production") {
+    ctrl.setEnvironment(PKConstants.endpoint.production);
+  }
+
+  return new Promise((resolve, reject) => {
+    ctrl.execute(function () {
+      var apiResponse = ctrl.getResponse();
+
+      console.log(apiResponse);
+
+      var response = new APIContracts.GetTransactionListResponse(apiResponse);
+
+      console.log(response.getTransactions());
+
+      if (response != null) {
+        if (
+          response.getMessages().getResultCode() ==
+          APIContracts.MessageTypeEnum.OK
+        ) {
+          if (response.getTransactions() != null) {
+            var transactions = response.getTransactions().getTransaction();
+            resolve(
+              transactions.map((t) => {
+                return {
+                  transId: t.getTransId(),
+                  amountInCents: t.getSettleAmount() * 100,
+                  status: t.getTransactionStatus(),
+                };
+              })
+            );
+          } else {
+            reject(response.getMessages().getMessage()[0].getText());
+          }
+        } else {
+          console.log("Failed Transaction. ");
+          reject(response.getMessages().getMessage()[0].getText());
+        }
+      } else {
+        console.log("Null Response.");
+      }
+    });
+  });
+}
+
+export async function refundTransaction({
+  transId,
+  creditCard,
+  customerProfile,
+  amountInCents,
+  processorId,
+}: {
+  transId: number;
+  creditCard?: APIContracts.CreditCardMaskedType;
+  customerProfile?: APIContracts.CustomerProfileIdType;
+  amountInCents: number;
+  processorId: ProcessorId;
+}): Promise<{ refundTransactionId: string }> {
+  let { merchantAuthenticationType } = await getMerchantAuthForProcessor(
+    processorId
+  );
+
+  let cc = new APIContracts.CreditCardType();
+  cc.cardNumber = creditCard?.cardNumber;
+  cc.expirationDate = creditCard?.expirationDate;
+
+  var paymentType = new APIContracts.PaymentType();
+  paymentType.setCreditCard(cc);
+
+  var transactionRequestType = new APIContracts.TransactionRequestType();
+  transactionRequestType.setTransactionType(
+    APIContracts.TransactionTypeEnum.REFUNDTRANSACTION
+  );
+  transactionRequestType.setAmount(amountInCents / 100.0);
+  transactionRequestType.setRefTransId(transId);
+  // transactionRequestType.setCustomer(customerProfile);
+  transactionRequestType.setPayment(paymentType);
+
+  var createRequest = new APIContracts.CreateTransactionRequest();
+  createRequest.setMerchantAuthentication(merchantAuthenticationType);
+  createRequest.setTransactionRequest(transactionRequestType);
+
+  //pretty print request
+  console.log(JSON.stringify(createRequest.getJSON(), null, 2));
+
+  var ctrl = new APIControllers.CreateTransactionController(
+    createRequest.getJSON()
+  );
+
+  if (process.env.ENVIRONMENT === "production") {
+    ctrl.setEnvironment(PKConstants.endpoint.production);
+  }
+
+  return new Promise((resolve, reject) => {
+    ctrl.execute(function () {
+      var apiResponse = ctrl.getResponse();
+
+      var response = new APIContracts.CreateTransactionResponse(apiResponse);
+
+      if (response != null) {
+        if (
+          response.getMessages().getResultCode() ==
+          APIContracts.MessageTypeEnum.OK
+        ) {
+          if (response.getTransactionResponse().getMessages() != null) {
+            resolve({
+              refundTransactionId: response
+                .getTransactionResponse()
+                .getTransId(),
+            });
+          } else {
+            reject(
+              response
+                .getTransactionResponse()
+                .getErrors()
+                .getError()[0]
+                .getErrorText()
+            );
+          }
+        } else {
+          if (
+            response.getTransactionResponse() != null &&
+            response.getTransactionResponse().getErrors() != null
+          ) {
+            reject(
+              response
+                .getTransactionResponse()
+                .getErrors()
+                .getError()[0]
+                .getErrorText()
+            );
+          } else {
+            reject(response.getMessages().getMessage()[0].getText());
+          }
+        }
+      } else {
+        reject("Null Response.");
+      }
+    });
+  });
+}
+
+export async function getTransactionStatus({
+  transId,
+  processorId,
+}: {
+  transId: number;
+  processorId: ProcessorId;
+}): Promise<{
+  status: TransactionStatus;
+  transId: number;
+  code: "1" | "2" | "3" | "4";
+  settleAmountInCents: number;
+  creditCard?: APIContracts.CreditCardMaskedType;
+  customerProfile?: APIContracts.CustomerProfileIdType;
+}> {
+  let { merchantAuthenticationType } = await getMerchantAuthForProcessor(
+    processorId
+  );
+
+  var getRequest = new APIContracts.GetTransactionDetailsRequest();
+  getRequest.setMerchantAuthentication(merchantAuthenticationType);
+  getRequest.setTransId(transId);
+
+  console.log(JSON.stringify(getRequest.getJSON(), null, 2));
+
+  var ctrl = new APIControllers.GetTransactionDetailsController(
+    getRequest.getJSON()
+  );
+
+  if (process.env.ENVIRONMENT === "production") {
+    ctrl.setEnvironment(PKConstants.endpoint.production);
+  }
+
+  return new Promise((resolve, reject) => {
+    ctrl.execute(function () {
+      var apiResponse = ctrl.getResponse();
+
+      var response = new APIContracts.GetTransactionDetailsResponse(
+        apiResponse
+      );
+
+      if (response != null) {
+        if (
+          response.getMessages().getResultCode() ==
+          APIContracts.MessageTypeEnum.OK
+        ) {
+          let payment = response.getTransaction().getPayment();
+          let customer = response.getTransaction().getCustomer();
+
+          resolve({
+            status: response.getTransaction().getTransactionStatus(),
+            transId: response.getTransaction().getTransId(),
+            code: response.getTransaction().getResponseCode(),
+            settleAmountInCents:
+              response.getTransaction().getSettleAmount() * 100,
+            creditCard: payment && payment.getCreditCard(),
+            customerProfile: customer,
+          });
+        } else {
+          reject(response.getMessages().getMessage()[0].getText());
+        }
+      } else {
+        reject("Null Response.");
+      }
+    });
+  });
+}
+
+export default {
+  createCustomerProfile,
+  getCustomerProfile,
+  addPaymentProfile,
+  deleteCustomerProfile,
+  updateCustomerProfile,
+  purchaseCreditsWithCustomerProfile,
+  purchaseCreditsWithCreditCardAndCreatorProfile,
+  createSubscription,
+  cancelSubscription,
+  getSubscription,
+  getSubscriptionStatus,
+  chargeCustomerByPaymentProfile,
+  getSubscriptionList,
+  updateUserPaymentProfile,
+  voidTransaction,
+  chargeCreditCardAndCreateProfile,
+  getTransactionsForCustomerProfile,
+  getTransactionStatus,
+  refundTransaction,
+};