@sikka/hawa 0.0.1 → 0.0.4

package/src/blocks/Payment/Form/Card.js

@@ -0,0 +1,242 @@
+import React, { useState, useEffect, useCallback, useMemo } from "react";
+import {
+  CSSTransition,
+  TransitionGroup,
+  SwitchTransition
+} from "react-transition-group";
+
+const CARDS = {
+  visa: "^4",
+  amex: "^(34|37)",
+  mastercard: "^5[1-5]",
+  discover: "^6011",
+  unionpay: "^62",
+  troy: "^9792",
+  diners: "^(30[0-5]|36)"
+};
+
+const cardBackgroundName = () => {
+  let random = Math.floor(Math.random() * 25 + 1);
+  return `${random}.jpeg`;
+};
+
+const BACKGROUND_IMG = cardBackgroundName();
+
+const Card = ({
+  cardHolder,
+  cardNumber,
+  cardMonth,
+  cardYear,
+  cardCvv,
+  isCardFlipped,
+  currentFocusedElm,
+  onCardElementClick,
+  cardNumberRef,
+  cardHolderRef,
+  cardDateRef
+}) => {
+  const [style, setStyle] = useState(null);
+
+  const cardType = (cardNumber) => {
+    const number = cardNumber;
+    let re;
+    for (const [card, pattern] of Object.entries(CARDS)) {
+      re = new RegExp(pattern);
+      if (number.match(re) != null) {
+        return card;
+      }
+    }
+
+    return "visa"; // default type
+  };
+
+  const useCardType = useMemo(() => {
+    return cardType(cardNumber);
+  }, [cardNumber]);
+
+  const outlineElementStyle = (element) => {
+    return element
+      ? {
+          width: `${element.offsetWidth}px`,
+          height: `${element.offsetHeight}px`,
+          transform: `translateX(${element.offsetLeft}px) translateY(${element.offsetTop}px)`
+        }
+      : null;
+  };
+
+  useEffect(() => {
+    if (currentFocusedElm) {
+      const style = outlineElementStyle(currentFocusedElm.current);
+      setStyle(style);
+    }
+  }, [currentFocusedElm]);
+
+  const maskCardNumber = (cardNumber) => {
+    let cardNumberArr = cardNumber.split("");
+    cardNumberArr.forEach((val, index) => {
+      if (index > 4 && index < 14) {
+        if (cardNumberArr[index] !== " ") {
+          cardNumberArr[index] = "*";
+        }
+      }
+    });
+
+    return cardNumberArr;
+  };
+
+  return (
+    <div className={"card-item " + (isCardFlipped ? "-active" : "")}>
+      <div className="card-item__side -front">
+        <div
+          className={`card-item__focus ${currentFocusedElm ? `-active` : ``}`}
+          style={style}
+        />
+        <div className="card-item__cover">
+          <img
+            alt=""
+            src={`/card-background/${BACKGROUND_IMG}`}
+            className="card-item__bg"
+          />
+        </div>
+
+        <div className="card-item__wrapper">
+          <div className="card-item__top">
+            <img src={"/chip.png"} alt="" className="card-item__chip" />
+            <div className="card-item__type">
+              <img
+                alt={useCardType}
+                src={`/card-type/${useCardType}.png`}
+                className="card-item__typeImg"
+              />
+            </div>
+          </div>
+
+          <label
+            className="card-item__number"
+            ref={cardNumberRef}
+            onClick={() => onCardElementClick("cardNumber")}
+          >
+            <TransitionGroup className="slide-fade-up" component="div">
+              {cardNumber ? (
+                maskCardNumber(cardNumber).map((val, index) => (
+                  <CSSTransition
+                    classNames="slide-fade-up"
+                    timeout={250}
+                    key={index}
+                  >
+                    <div className="card-item__numberItem">{val}</div>
+                  </CSSTransition>
+                ))
+              ) : (
+                <CSSTransition classNames="slide-fade-up" timeout={250}>
+                  <div className="card-item__numberItem">#</div>
+                </CSSTransition>
+              )}
+            </TransitionGroup>
+          </label>
+          <div className="card-item__content">
+            <label
+              className="card-item__info"
+              onClick={() => onCardElementClick("cardHolder")}
+              ref={cardHolderRef}
+            >
+              <div className="card-item__holder">Card Holder</div>
+              <div className="card-item__name">
+                <TransitionGroup component="div" className="slide-fade-up">
+                  {cardHolder === "FULL NAME" ? (
+                    <CSSTransition classNames="slide-fade-up" timeout={250}>
+                      <div>FULL NAME</div>
+                    </CSSTransition>
+                  ) : (
+                    cardHolder.split("").map((val, index) => (
+                      <CSSTransition
+                        timeout={250}
+                        classNames="slide-fade-right"
+                        key={index}
+                      >
+                        <span className="card-item__nameItem">{val}</span>
+                      </CSSTransition>
+                    ))
+                  )}
+                </TransitionGroup>
+              </div>
+            </label>
+            <div
+              className="card-item__date"
+              onClick={() => onCardElementClick("cardDate")}
+              ref={cardDateRef}
+            >
+              <label className="card-item__dateTitle">Expires</label>
+              <label className="card-item__dateItem">
+                <SwitchTransition in-out>
+                  <CSSTransition
+                    classNames="slide-fade-up"
+                    timeout={200}
+                    key={cardMonth}
+                  >
+                    <span>{!cardMonth ? "MM" : cardMonth} </span>
+                  </CSSTransition>
+                </SwitchTransition>
+              </label>
+              /
+              <label htmlFor="cardYear" className="card-item__dateItem">
+                <SwitchTransition out-in>
+                  <CSSTransition
+                    classNames="slide-fade-up"
+                    timeout={250}
+                    key={cardYear}
+                  >
+                    <span>
+                      {!cardYear ? "YY" : cardYear.toString().substr(-2)}
+                    </span>
+                  </CSSTransition>
+                </SwitchTransition>
+              </label>
+            </div>
+            <div
+              className="card-item__date"
+              onClick={() => onCardElementClick("cardDate")}
+              ref={cardDateRef}
+            ></div>
+          </div>
+        </div>
+      </div>
+
+      <div className="card-item__side -back">
+        <div className="card-item__cover">
+          <img
+            alt=""
+            src={`/card-background/${BACKGROUND_IMG}`}
+            className="card-item__bg"
+          />
+        </div>
+        <div className="card-item__band" />
+        <div className="card-item__cvv">
+          <div className="card-item__cvvTitle">CVV</div>
+          <div className="card-item__cvvBand">
+            <TransitionGroup>
+              {cardCvv.split("").map((val, index) => (
+                <CSSTransition
+                  classNames="zoom-in-out"
+                  key={index}
+                  timeout={250}
+                >
+                  <span>*</span>
+                </CSSTransition>
+              ))}
+            </TransitionGroup>
+          </div>
+          <div className="card-item__type">
+            <img
+              alt="card-type"
+              src={"/card-type/visa.png"}
+              className="card-item__typeImg"
+            />
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+};
+
+export default Card;

package/src/blocks/Payment/Gateway/GooglePay.js

@@ -0,0 +1,251 @@
+import axios from "axios";
+import qs from "qs";
+import { useRouter } from "next/router";
+import { useState, useEffect } from "react";
+import useTranslation from "next-translate/useTranslation";
+import Script from "next/script";
+
+const GooglePay = (props) => {
+  const transaction = props.currenttransactiongpay;
+  const router = useRouter();
+  console.log("transaction=", transaction);
+  const { t, lang } = useTranslation("common");
+  const [googlepayloaded, setGooglePayLoaded] = useState(false);
+  const [googlepay, setGooglePay] = useState(false);
+  const [braintreegatewayclient, setBraintreeGatewayClient] = useState(false);
+  const [braintreegatewaygooglepayment, setBraintreeGatewayGooglePayment] =
+    useState(false);
+  const [braintreegatewaydatacollector, setBraintreeGatewayDataCollector] =
+    useState(false);
+
+    let paymentsClient;
+
+  useEffect(() => {
+    if (
+      !googlepayloaded &&
+      googlepay &&
+      braintreegatewaydatacollector &&
+      braintreegatewayclient &&
+      braintreegatewaygooglepayment
+    ) {
+      console.log("okkkk");
+      onGooglePayLoaded();
+    }
+  }, [
+    googlepay,
+    braintreegatewayclient,
+    braintreegatewaygooglepayment,
+    braintreegatewaydatacollector,
+    googlepayloaded
+  ]);
+
+  /**
+   * Add a Google Pay purchase button alongside an existing checkout button
+   *
+   * @see {@link https://developers.google.com/pay/api/web/reference/request-objects#ButtonOptions|Button options}
+   * @see {@link https://developers.google.com/pay/api/web/guides/brand-guidelines|Google Pay brand guidelines}
+   */
+  const addGooglePayButton = (googlePaymentInstance, clientInstance) => {
+    //ok
+    const button = paymentsClient.createButton({
+      onClick: (event) =>
+        onGooglePaymentButtonClicked(
+          event,
+          googlePaymentInstance,
+          clientInstance
+        ),
+      buttonLocale: lang
+    });
+    document.getElementById("qawaim-googlepay").appendChild(button);
+  };
+
+  /**
+   * Show Google Pay payment sheet when Google Pay payment button is clicked
+   */
+  const onGooglePaymentButtonClicked = (
+    event,
+    googlePaymentInstance,
+    clientInstance
+  ) => {
+    let paymentDataRequest = googlePaymentInstance.createPaymentDataRequest({
+      merchantInfo: {
+        // @todo a merchant ID is available for a production environment after approval by Google
+        // See {@link https://developers.google.com/pay/api/web/guides/test-and-deploy/integration-checklist|Integration checklist}
+        merchantId: `${process.env.NEXT_PUBLIC_QAWAIM_GOOGLE_MERCHANT_ID}`,
+        merchantName: `${process.env.NEXT_PUBLIC_QAWAIM_GOOGLEPAY_MERCHANT_NAME}`
+      },
+      transactionInfo: {
+        displayItems: [
+          {
+            label: "Subtotal",
+            type: "SUBTOTAL",
+            price: `${transaction.amount}`
+          }
+        ],
+        currencyCode: `${transaction.currency}`,
+        totalPriceStatus: "FINAL",
+        totalPrice: `${transaction.amount}`,
+        totalPriceLabel: "Total"
+      }
+    });
+
+    // We recommend collecting billing address information, at minimum
+    // billing postal code, and passing that billing postal code with all
+    // Google Pay card transactions as a best practice.
+    // See all available options at https://developers.google.com/pay/api/web/reference/object
+    let cardPaymentMethod = paymentDataRequest.allowedPaymentMethods[0];
+    cardPaymentMethod.parameters.billingAddressRequired = true;
+    cardPaymentMethod.parameters.billingAddressParameters = {
+      format: "FULL",
+      phoneNumberRequired: true
+    };
+
+    paymentsClient
+      .loadPaymentData(paymentDataRequest)
+      .then(function (paymentData) {
+        googlePaymentInstance.parseResponse(
+          paymentData,
+          function (err, result) {
+            if (err) {
+              console.log(err);
+              // Handle parsing error
+              router.push("/payment/error");
+            }
+
+            // Send result.nonce to your server
+            // result.type may be either "AndroidPayCard" or "PayPalAccount", and
+            // paymentData will contain the billingAddress for card payments
+            braintree.dataCollector.create(
+              {
+                client: clientInstance
+              },
+              async function (err, dataCollectorInstance) {
+                if (err) {
+                  // Handle error in creation of data collector
+                  return;
+                }
+                // At this point, you should access the dataCollectorInstance.deviceData value and provide it
+                // to your server, e.g. by injecting it into your form as a hidden input.
+                let deviceData = dataCollectorInstance.deviceData;
+                const data = {
+                  deviceDataClient: deviceData,
+                  nonce: result.nonce,
+                  billing_address: transaction.billing_address,
+                  amount: `${transaction.amount}`,
+                  currency: token.SelectedCurrency?.toUpperCase(),
+                  transaction_id: `${transaction._id}`
+                };
+                let checkoutgpay = await axios.post(
+                  `${process.env.NEXT_PUBLIC_QAWAIM_API_URL}/braintreegateway/googlepay`,
+                  qs.stringify(data)
+                );
+                if (checkoutgpay.data.ok === true) {
+                  router.push(`/confirmation/${transaction._id}`);
+                  //setCurrentTransaction(checkoutInfo.data.data.transaction);
+                  router.push(
+                    `/confirmation/${checkoutgpay.data.data.transaction._id}`
+                  );
+                } else {
+                  router.push("/payment/error");
+                }
+              }
+            );
+          }
+        );
+      })
+      .catch(function (err) {
+        console.log(err);
+        router.push("/payment/error");
+        // Handle errors
+      });
+  };
+
+  const onGooglePayLoaded = () => {
+    // Make sure to have https://pay.google.com/gp/p/js/pay.js loaded on your page
+    // You will need a button element on your page styled according to Google's brand guidelines
+    // https://developers.google.com/pay/api/web/guides/brand-guidelines
+    paymentsClient = new google.payments.api.PaymentsClient({
+      environment: process.env.NEXT_PUBLIC_QAWAIM_GOOGLEPAY_ENVIRONMENT // 'TEST' Or 'PRODUCTION'
+    });
+
+    setGooglePayLoaded(true);
+
+    braintree.client.create(
+      {
+        authorization: `${process.env.NEXT_PUBLIC_QAWAIM_BRAINTREE_TOKENIZATION_KEY}`
+      },
+      function (clientErr, clientInstance) {
+        console.log("clientErr=", clientErr);
+        console.log("clientInstance=", clientInstance);
+        braintree.googlePayment.create(
+          {
+            client: clientInstance,
+            googlePayVersion: 2,
+            googleMerchantId: `${process.env.NEXT_PUBLIC_QAWAIM_GOOGLE_MERCHANT_ID}` // Optional in sandbox; if set in sandbox, this value must be a valid production Google Merchant ID
+          },
+          function (googlePaymentErr, googlePaymentInstance) {
+            console.log("googlePaymentErr=", googlePaymentErr);
+            console.log("googlePaymentInstance=", googlePaymentInstance);
+            paymentsClient
+              .isReadyToPay({
+                // see https://developers.google.com/pay/api/web/reference/object#IsReadyToPayRequest
+                apiVersion: 2,
+                apiVersionMinor: 0,
+                allowedPaymentMethods:
+                  googlePaymentInstance.createPaymentDataRequest()
+                    .allowedPaymentMethods,
+                existingPaymentMethodRequired: true // Optional
+              })
+              .then(function (response) {
+                if (response.result) {
+                  addGooglePayButton(googlePaymentInstance, clientInstance);
+                }
+              })
+              .catch(function (err) {
+                console.log(err);
+                router.push("/payment/error");
+                // Handle errors
+              });
+          }
+        );
+
+        // Set up other Braintree components
+      }
+    );
+  };
+  return (
+    <>
+      <Script
+        id="googlepay"
+        src="https://pay.google.com/gp/p/js/pay.js"
+        onLoad={() => {
+          setGooglePay(true);
+        }}
+      />
+      <Script
+        id="braintreegateway-client"
+        src="https://js.braintreegateway.com/web/3.82.0/js/client.min.js"
+        onLoad={() => {
+          setBraintreeGatewayClient(true);
+        }}
+      />
+      <Script
+        id="braintreegateway-data-collector"
+        src="https://js.braintreegateway.com/web/3.82.0/js/data-collector.min.js"
+        onLoad={() => {
+          setBraintreeGatewayDataCollector(true);
+        }}
+      />
+      <Script
+        id="braintreegateway-google-payment"
+        src="https://js.braintreegateway.com/web/3.82.0/js/google-payment.min.js"
+        onLoad={() => {
+          setBraintreeGatewayGooglePayment(true);
+        }}
+      />
+      <div id="qawaim-googlepay"></div>
+    </>
+  );
+};
+
+export default GooglePay;

package/src/blocks/Payment/Gateway/Payfort.js

@@ -0,0 +1,90 @@
+import { useState, useEffect, memo, useCallback, useRef } from "react";
+import CForm from "../Form/CForm";
+import Card from "../Form/Card";
+
+const initialState = {
+  cardNumber: "#### #### #### ####",
+  cardHolder: "FULL NAME",
+  cardMonth: "",
+  cardYear: "",
+  cardCvv: "",
+  isCardFlipped: false
+};
+
+const Payfort = (props) => {
+  const [state, setState] = useState(initialState);
+  const [currentFocusedElm, setCurrentFocusedElm] = useState(null);
+
+  const updateStateValues = useCallback(
+    (keyName, value) => {
+      setState({
+        ...state,
+        [keyName]: value || initialState[keyName]
+      });
+    },
+    [state]
+  );
+  // References for the Form Inputs used to focus corresponding inputs.
+  let formFieldsRefObj = {
+    cardNumber: useRef(),
+    cardHolder: useRef(),
+    cardDate: useRef(),
+    cardCvv: useRef()
+  };
+
+  let focusFormFieldByKey = useCallback((key) => {
+    formFieldsRefObj[key].current.focus();
+  });
+
+  // This are the references for the Card DIV elements.
+  let cardElementsRef = {
+    cardNumber: useRef(),
+    cardHolder: useRef(),
+    cardDate: useRef()
+  };
+
+  let onCardFormInputFocus = (_event, inputName) => {
+    const refByName = cardElementsRef[inputName];
+    setCurrentFocusedElm(refByName);
+  };
+
+  let onCardInputBlur = useCallback(() => {
+    setCurrentFocusedElm(null);
+  }, []);
+
+  return (
+    <CForm
+      cardNumber={state.cardNumber}
+      cardHolder={state.cardHolder}
+      cardMonth={state.cardMonth}
+      cardYear={state.cardYear}
+      cardCvv={state.cardCvv}
+      onUpdateState={updateStateValues}
+      cardNumberRef={formFieldsRefObj.cardNumber}
+      cardHolderRef={formFieldsRefObj.cardHolder}
+      cardDateRef={formFieldsRefObj.cardDate}
+      cardCvvRef={formFieldsRefObj.cardCvv}
+      onCardInputFocus={onCardFormInputFocus}
+      onCardInputBlur={onCardInputBlur}
+      handlePaymentPayfort={props.handlePaymentPayfort}
+      paymentMethod={props.paymentMethod}
+      register={props.register}
+    >
+      <Card
+        cardNumber={state.cardNumber}
+        cardHolder={state.cardHolder}
+        cardMonth={state.cardMonth}
+        cardYear={state.cardYear}
+        cardCvv={state.cardCvv}
+        isCardFlipped={state.isCardFlipped}
+        currentFocusedElm={currentFocusedElm}
+        onCardElementClick={focusFormFieldByKey}
+        cardNumberRef={cardElementsRef.cardNumber}
+        cardHolderRef={cardElementsRef.cardHolder}
+        cardDateRef={cardElementsRef.cardDate}
+      ></Card>
+    </CForm>
+  );
+};
+
+export default Payfort;