ouisys-engine 3.0.1 → 3.0.5

package/src/reducers/moFlow/MoTypes.ts

@@ -1,125 +0,0 @@
-import * as RDS from "../../common-types/RemoteDataState";
-import { AppThunk } from "../../common-types/AppThunk";
-
-export type IMoFlowCurrentState =
-| {
-  type: "MSISDNEntry";
-  result: RDS.RemoteDataState<MSISDNEntryFailure, MSISDNEntrySuccess>;
-}
-
-export type MSISDNEntryErrorTypes =
-  | "AlreadySubscribed"
-  | "UnknownError"
-  | "InvalidMSISDN"
-  | "UnexpectedState";
-export type MSISDNEntryFailure = {
-  errorType: MSISDNEntryErrorTypes;
-  error: any;
-  productUrl?:string;
-};
-export type MSISDNEntrySuccess = IKeywordShortcode
-type ACompType =
-  React.ComponentType<{ children: React.ReactNode } & React.HTMLAttributes<HTMLAnchorElement> & { keyword?: string, shortcode?: string }>
-
-export type IMsisnSubmitActionPayload = {
-  type:"MSISDNEntry";
-  result: RDS.RemoteDataState<MSISDNEntryFailure, MSISDNEntrySuccess>;
-}
-
-
-
-export interface IMoFlowReducerState {
-  currentState:IMoFlowCurrentState
-}
-
-
-export type IConfig = {
-  offer?: number,
-  slug?: string;
-  country?: string;
-  host?:string;
-  device?: "smart" | "feature";
-  operators?: string[];
-}
-
-export type IKeywordShortcode = {
-  keyword : string,
-  shortcode : string,
-}
-  
-export type IMSISDNSubmissionResult = {
-  success: true
-  rockman_id: string,
-  keyword: string,
-  shortcode: string,
-} | {
-  success: false,
-  rockman_id: string,
-  message: string,
-  product_url?:string,
-}
-
-export type ICheckSubscriptionResult = {
-  success: false;
-  rockman_id: string;
-  message: string;
-} | {
-  success: true;
-  msisdn: string;
-  product_url?: string;
-  rockman_id: string;
-}
-
-
-
-export type IBackToStartPayload = {
-  type: "MSISDNEntry";
-  result: RDS.RemoteDataState<MSISDNEntryFailure, MSISDNEntrySuccess>;
-}
-
-export type IMoActions =
-{
-  type: "MO_MSISDN_SUBMIT";
-  payload:IMsisnSubmitActionPayload;
-  
-}
-|
-{
-  type: "MO_MSISDN_SUBMIT_ERROR";
-  payload:IMsisdnSubmitErrorPayload;
-  
-}
-|
-{
-  type: "MO_BACK_TO_START";
-  payload:IBackToStartPayload;
-}
-|
-{
-  type:"MOCK_MO_FLOW_STATE";
-  payload:IMoFlowCurrentState;
-}
-
-export type IMsisdnSubmitErrorPayload = {
-  type:"MSISDNEntry";
-  result: RDS.RemoteDataState<MSISDNEntryFailure, MSISDNEntrySuccess>;
-}
-
-
-export type IMoFlowActionMaps = {
-  submitMSISDNAction:(msisdn:string)=>AppThunk;
-}
-
-export type IMockMoFlowStates = "msisdn-entry-success-state" | "msisdn-entry-failure-state"
-
-export type IGoogleReCaptcha  = {
-  site_key:   string;
-  secret_key: string;
-  domains:    string;
-  success:    true;
-} | {
-  message: string;
-  success: false;
-}
-
-

package/src/reducers/moFlow/index.ts

@@ -1,150 +0,0 @@
-// LIBRARIES
-import * as RDS from "../../common-types/RemoteDataState";
-
-import { MSISDNEntryFailure, MSISDNEntryErrorTypes, IMoFlowReducerState, MSISDNEntrySuccess, IMsisnSubmitActionPayload, IBackToStartPayload, IMsisdnSubmitErrorPayload, IMoActions, IMoFlowActionMaps, IMockMoFlowStates } from "./MoTypes";
-import { AppThunk } from "../../common-types/AppThunk";
-import submitMSISDN, { checkSubscription, mockedMSISDNEntrySuccess, mockedMSISDNEntryFailure } from "./utils";
-import { genericHandler, tracker } from "../strategy";
-
-//ACTION CREATORS
-export function submitMSISDNAction(msisdn:string, extraParams?:{[key: string]: string}):AppThunk{
-  return async (dispatch, store)=>{
-    const {currentState} = store().strategy
-    if(currentState.type === "MO"){
-      const config = currentState.result.config;
-
-      try {
-
-        dispatch({
-          type: "MO_MSISDN_SUBMIT",
-          payload:{
-            type:"MSISDNEntry",
-            result: RDS.Loading() 
-          }
-        })
-        tracker.advancedInFlow('tallyman.v1-mo', 'msisdn-submitted', { msisdn })
-
-        const keywordAndShortcode = await submitMSISDN(
-          window,
-          config,
-          msisdn,
-          extraParams
-        );
-        tracker.advancedInFlow('tallyman.v1-mo', 'msisdn-submission-success', { msisdn })
-
-        dispatch({
-          type: "MO_MSISDN_SUBMIT",
-          payload:{
-            type:"MSISDNEntry",
-            result: RDS.Success<MSISDNEntryFailure, MSISDNEntrySuccess>({...keywordAndShortcode})       
-          }
-        })
-
-        try{
-          checkSubscription(window, config)
-          .then((product_url)=>{
-
-            tracker.advancedInFlow('tallyman.v1-mo', 'sale', { msisdn });
-            setTimeout(() => {
-              window.location.href = product_url
-            }, 1000);
-          })
-        }catch(err){
-          throw err;  
-        }
-      } catch (ex) {
-        console.warn(ex)
-        const errorType: MSISDNEntryErrorTypes =
-          "AlreadySubscribed" === ex.type
-          ? "AlreadySubscribed"
-          : "InvalidMSISDN" == ex.type
-            ? "InvalidMSISDN"
-            : "UnknownError";
-       tracker.recedeInFlow('tallyman.v1-mo', 'msisdn-submission-failure', { msisdn, errorType: errorType || 'UnknownError' })
-
-        dispatch({
-          type: "MO_MSISDN_SUBMIT_ERROR",
-          payload:{
-            type:"MSISDNEntry",
-            result: RDS.Failure<MSISDNEntryFailure, MSISDNEntrySuccess>({
-              errorType: errorType,
-              error: ex,
-              productUrl: ex.productUrl
-            })
-          }
-        });
-      }
-    }else{
-      dispatch({
-        type: "MO_MSISDN_SUBMIT_ERROR",
-        payload:{
-          type:"MSISDNEntry",
-          result: RDS.Failure<MSISDNEntryFailure, MSISDNEntrySuccess>({
-            errorType: "UnexpectedState",
-            error: null
-          })
-        }
-      });
-      throw "Unexpected state"
-    }
-  }
-}
-
-
-export function backToStart(){
-  return {
-    type:"MO_BACK_TO_START",
-    payload:{
-      type: "MSISDNEntry",
-      result:  RDS.NothingYet<MSISDNEntryFailure, MSISDNEntrySuccess>()
-    }
-  };
-}
-
-
-export function mockMoFlow(mockState:IMockMoFlowStates):AppThunk {
-  return (dispatch)=>{
-    if(mockState !== undefined){
-      switch (mockState) {
-        case "msisdn-entry-failure-state":
-          return dispatch({
-            type:"MOCK_MO_FLOW_STATE",
-            payload:mockedMSISDNEntryFailure.currentState
-          })
-        case "msisdn-entry-success-state":
-          return dispatch({
-            type:"MOCK_MO_FLOW_STATE",
-            payload:mockedMSISDNEntrySuccess.currentState
-          })
-        default:
-          throw "Mock Flow not supported";
-      }
-    }
-  }
-}
-
-const initialState:IMoFlowReducerState = {
-  currentState:{
-    type: "MSISDNEntry",
-    result: RDS.NothingYet<MSISDNEntryFailure, MSISDNEntrySuccess>()
-  }
-};
-
-export const MoFlowActionMaps:IMoFlowActionMaps = {
-  submitMSISDNAction:submitMSISDNAction
-}
-
-export default function MoFlowReducer(state = initialState, action:IMoActions) {
-  switch (action.type) {
-    case "MO_MSISDN_SUBMIT":
-      return genericHandler<IMoFlowReducerState, IMsisnSubmitActionPayload>(state, action.payload)
-    case "MO_BACK_TO_START":
-      return genericHandler<IMoFlowReducerState, IBackToStartPayload>(state, action.payload)
-    case "MO_MSISDN_SUBMIT_ERROR":
-      return genericHandler<IMoFlowReducerState, IMsisdnSubmitErrorPayload>(state, action.payload)
-    case "MOCK_MO_FLOW_STATE":
-      return genericHandler<IMoFlowReducerState, any>(state, action.payload)
-    default:
-      return state;
-  }
-}

package/src/reducers/moFlow/utils.ts

@@ -1,135 +0,0 @@
-import { IConfig, IMSISDNSubmissionResult, ICheckSubscriptionResult, IMoFlowReducerState, MSISDNEntryFailure, MSISDNEntrySuccess, IGoogleReCaptcha } from "./MoTypes";
-import IError from "../../common-types/IError";
-import { IKeywordShortcode } from "./MoTypes";
-import * as RDS from "../../common-types/RemoteDataState";
-import loadScriptInnerHtml from "../../utilities/loadScriptInnerHtml";
-import loadScriptSrc from "../../utilities/loadScriptSrc";
-
-
-const wait = (ms: number) =>
-//@ts-ignore
-  new Promise(resolve => setTimeout(() => resolve(), ms));
-
-const loop = async <I extends {}, R extends {}>(
-  f: () => Promise<R>,
-  max: number,
-  stop: (r: R) => boolean,
-  i: number
-): Promise<R> => {
-  const r = await f();
-  if (stop(r) || i >= max) {
-    return r;
-  } else {
-    await wait(1000);
-    return loop(f, max, stop, i + 1);
-  }
-};
-
-
-const getConfig = ():IConfig=>{
-  try {
-    const configs:IConfig = require("../../../../../config.json");
-    return configs;
-  } catch (ex) {
-    throw "config.json not found";
-  }
-};
-
-
-
-
-export default async function submitMSISDN(window: Window, maybeConfig: IConfig, internationalMSISDN: string, extraParams?: {[key: string]: string}): Promise<IKeywordShortcode> {
-  const config: IConfig = {offer:window.pac_analytics.visitor.offer, ...(maybeConfig||{})}
-  return submitMSISDNWithConfig(window, config, internationalMSISDN, extraParams)
-}
-
-export const getGoogleReCaptchaConfig = async ({ slug, country, device, host }:IConfig):Promise<IGoogleReCaptcha>=>{
-  const domain = window.location.hostname;
-  const result: IGoogleReCaptcha = await window.tallymanApi.getGoogleCaptcha(host, country, slug, device, domain);
-  if(result.success === true){
-    const srcUrl = `https://www.google.com/recaptcha/api.js?render=${result.site_key}`;
-    loadScriptSrc({url:srcUrl, key: result.site_key, isRecaptcha: true});
-  }
-  return result;
-}
-
-export async function submitMSISDNWithConfig(window: Window, config: IConfig, internationalMSISDN: string, extraParams?: { [key: string]: string }): Promise<IKeywordShortcode> {
-
-  const { slug, country, device, offer, host } = config
-  const search = window.location.search.substr(1) || ''
-  const extraParamsQs = !extraParams ? '' : '&' + Object.keys(extraParams).map(k => `${k}=${extraParams[k]}`).join('&')
-  const msisdn = internationalMSISDN.match(/\d+/gi).join('')
-  const rockmanId = window.pac_analytics.visitor.rockmanId;
-
-  const result: IMSISDNSubmissionResult = await window.tallymanApi.triggerMessage(host, slug, country, msisdn, device, offer, rockmanId, search, extraParamsQs)
-
-
-  if (false === result.success) {
-    const type = result.message == 'ALREADY SUBSCRIBED' ? "AlreadySubscribed" : "InvalidMSISDN";
-    const error = new Error(`${type}:\n${result.message}`) as IError & {type:string; productUrl:string;}
-    error['type'] = type;
-    error['productUrl'] = result.product_url ? result.product_url : "";
-
-    console.error(error)
-    throw error
-  } else {
-    return result
-  }
-}
-
-
-
-export async function checkSubscription(window: Window, maybeConfig: IConfig): Promise<string> {
-  const config: IConfig = {offer:window.pac_analytics.visitor.offer, ...(maybeConfig||{})}
-
-  const { host } = config
-
-  const rockmanId = window.pac_analytics.visitor.rockmanId
-  const check : () => Promise<ICheckSubscriptionResult> = () => window.tallymanApi.checkSubscriptionByRockmanIdOnly(host, rockmanId)
-
-  const checkResult: ICheckSubscriptionResult = await loop(
-    check,
-    60,
-    r => r.success,
-    0
-  )
-
-  if(true === checkResult.success) {
-    window.location.href = checkResult.product_url;
-    return checkResult.product_url || null
-  } else {
-    const error = new Error(`${"SubscriptionFailed"}:\n${checkResult.message}`) as IError & {type:string}
-    error['type'] = "SubscriptionFailed";
-    throw error
-  }
-}
-
-
-export const formatSMSLink = (keywordAndShortcode : IKeywordShortcode) =>
-//@ts-ignore
-  (!!window.pac_analytics.visitor["x-requested-with"] && window.pac_analytics.visitor["x-requested-with"] !== null && window.pac_analytics.visitor["x-requested-with"].indexOf("com.facebook") !== -1)
-  ?
-  `sms://${keywordAndShortcode.shortcode}?body=${keywordAndShortcode.keyword}`
-  :
-  (typeof navigator != "undefined" && (/iPhone/i.test(navigator.userAgent) || /Mac OS/i.test(navigator.userAgent)))
-  ? `sms:${keywordAndShortcode.shortcode}&body=${keywordAndShortcode.keyword}`
-  : `sms:${keywordAndShortcode.shortcode}?body=${keywordAndShortcode.keyword}`
-  
-
-export const mockedMSISDNEntrySuccess : IMoFlowReducerState = { 
-  currentState:{
-    type: "MSISDNEntry",
-    result: RDS.Success<MSISDNEntryFailure, MSISDNEntrySuccess>({
-      keyword: 'TEST OK',
-      shortcode: '666'
-    })
-  }
-}
-
-
-export const mockedMSISDNEntryFailure : IMoFlowReducerState = { 
-  currentState:{
-    type: "MSISDNEntry",
-    result: RDS.Failure<MSISDNEntryFailure, MSISDNEntrySuccess>({ errorType: "InvalidMSISDN", error: "Invalid Mobile Number" })
-  }
-}

package/src/reducers/moRedirFlow/IMoRedirConstants.ts

@@ -1,7 +0,0 @@
-type IMoRedirConstants =  
-"MO_REDIR_MSISDN_SUBMIT"
-| "MO_REDIR_MSISDN_SUBMIT_ERROR"
-| "MO_REDIR_BACK_TO_START"
-| "MOCK_MO_REDIR_FLOW_STATE"
-
-export default IMoRedirConstants

package/src/reducers/moRedirFlow/MoRedirTypes.ts

@@ -1,99 +0,0 @@
-import * as RDS from "../../common-types/RemoteDataState";
-import { AppThunk } from "../../common-types/AppThunk";
-
-export type IMoRedirFlowCurrentState =
-| {
-  type: "MSISDNEntry";
-  result: RDS.RemoteDataState<MSISDNEntryFailure, MSISDNEntrySuccess>;
-}
-
-export type MSISDNEntryErrorTypes =
-  | "AlreadySubscribed"
-  | "UnknownError"
-  | "InvalidMSISDN"
-  | "UnexpectedState";
-export type MSISDNEntryFailure = {
-  errorType: MSISDNEntryErrorTypes;
-  error: any;
-  productUrl?:string;
-};
-export type MSISDNEntrySuccess = {href: string}
-type ACompType =
-  React.ComponentType<{ children: React.ReactNode } & React.HTMLAttributes<HTMLAnchorElement> & { keyword?: string, shortcode?: string }>
-
-export type IMsisnSubmitActionPayload = {
-  type:"MSISDNEntry";
-  result: RDS.RemoteDataState<MSISDNEntryFailure, MSISDNEntrySuccess>;
-}
-
-
-
-export interface IMoRedirFlowReducerState {
-  currentState:IMoRedirFlowCurrentState
-}
-
-//import { getConfig, ConfigDetails} from "./config"
-
-export type IConfig = {
-  offer?: number,
-  slug?: string;
-  country?: string;
-  host?:string;
-  device?: "smart" | "feature";
-  operators?: string[];
-}
-
-  
-export type IMSISDNSubmissionResult = {
-  success: true;
-  rockman_id: string;
-  redirect_url: string;
-} | {
-  success: false;
-  rockman_id: string;
-  message: string;
-}
-
-
-
-
-export type IBackToStartPayload = {
-  type: "MSISDNEntry";
-  result: RDS.RemoteDataState<MSISDNEntryFailure, MSISDNEntrySuccess>;
-}
-
-export type IMoRedirActions = {
-  type: "MO_REDIR_MSISDN_SUBMIT";
-  payload:IMsisnSubmitActionPayload;
-  
-}
-|
-{
-  type: "MO_REDIR_MSISDN_SUBMIT_ERROR";
-  payload:IMsisdnSubmitErrorPayload;
-  
-}
-|
-{
-  type: "MO_REDIR_BACK_TO_START";
-  payload:IBackToStartPayload;
-}
-|
-{
-  type:"MOCK_MO_REDIR_FLOW_STATE";
-  payload:IMoRedirFlowCurrentState;
-}
-
-
-export type IMsisdnSubmitErrorPayload = {
-  type:"MSISDNEntry",
-  result: RDS.RemoteDataState<MSISDNEntryFailure, MSISDNEntrySuccess>;
-}
-
-
-export type IMoRedirFlowActionMaps = {
-  submitMSISDNAction:(internationalMSISDN:string,bupperMSISDN?:string, rockman_id?:string)=>AppThunk;
-}
-
-
-export type IMockMoRedirFlowStates = "msisdn-entry-success-state" | "msisdn-entry-failure-state"

package/src/reducers/moRedirFlow/index.ts

@@ -1,137 +0,0 @@
-// LIBRARIES
-import * as RDS from "../../common-types/RemoteDataState";
-
-import { MSISDNEntryFailure, MSISDNEntryErrorTypes, IMoRedirFlowReducerState, MSISDNEntrySuccess, IMsisnSubmitActionPayload, IBackToStartPayload, IMsisdnSubmitErrorPayload, IMoRedirActions, IMoRedirFlowActionMaps, IMockMoRedirFlowStates } from "./MoRedirTypes";
-import { AppThunk } from "../../common-types/AppThunk";
-import submitMSISDN, { mockedMSISDNEntryFailure, mockedMSISDNEntrySuccess } from "./utils";
-import { genericHandler, tracker } from "../strategy";
-
-//ACTION CREATORS
-export function submitMSISDNAction(msisdn:string):AppThunk{
-  return async (dispatch, store)=>{
-    const {currentState} = store().strategy
-    if(currentState.type === "MO_REDIR"){
-
-      const config = currentState.result.config;
-
-
-      try {
-        dispatch({
-          type: "MO_REDIR_MSISDN_SUBMIT",
-          payload:{
-            type:"MSISDNEntry",
-            result: RDS.Loading() 
-          }
-        })
-        tracker.advancedInFlow('tallyman.v1-mo-redir', 'msisdn-submitted', { msisdn })
-
-        const href = await submitMSISDN(
-          window,
-          config,
-          msisdn
-        );
-        tracker.advancedInFlow('tallyman.v1-mo-redir', 'msisdn-submission-success', { msisdn })
-        dispatch({
-          type: "MO_REDIR_MSISDN_SUBMIT",
-          payload:{
-            type:"MSISDNEntry",
-            result: RDS.Success<MSISDNEntryFailure, MSISDNEntrySuccess>({href})       
-          }
-        })
-      } catch (ex) {
-        console.warn(ex)
-        const errorType: MSISDNEntryErrorTypes =
-          "SEAlreadySubscribed" === ex.type
-          ? "AlreadySubscribed"
-          : "SEInvalidMSISDN" == ex.type
-            ? "InvalidMSISDN"
-            : "UnknownError";
-            tracker.recedeInFlow('tallyman.v1-mo-redir', 'msisdn-submission-failure', { msisdn, errorType: errorType || 'UnknownError' })
-
-        dispatch({
-          type: "MO_REDIR_MSISDN_SUBMIT_ERROR",
-          payload:{
-            type:"MSISDNEntry",
-            result: RDS.Failure<MSISDNEntryFailure, MSISDNEntrySuccess>({
-              errorType: errorType,
-              error: ex,
-              productUrl: ex.productUrl
-            })
-          }
-        });
-
-      }
-    }else{
-      tracker.recedeInFlow('tallyman.v1-mo-redir', 'msisdn-submission-failure', { msisdn, errorType: 'UnknownError' })
-      dispatch({
-        type: "MO_REDIR_MSISDN_SUBMIT_ERROR",
-        payload:{
-          type:"MSISDNEntry",
-          result: RDS.Failure<MSISDNEntryFailure, MSISDNEntrySuccess>({
-            errorType: "UnexpectedState",
-            error:null
-          })
-        }
-      });
-      throw "Unexpected state"
-    }
-  }
-}
-
-
-export function backToStart(){
-  return {
-    type:"MO_REDIR_BACK_TO_START",
-    payload:{
-      type: "MSISDNEntry",
-      result:  RDS.NothingYet<MSISDNEntryFailure, MSISDNEntrySuccess>()
-    }
-  };
-}
-
-export function mockMoRedirFlow(mockState:IMockMoRedirFlowStates):AppThunk {
-  return (dispatch)=>{
-    if(mockState !== undefined){
-      switch (mockState) {
-        case "msisdn-entry-failure-state":
-          return dispatch({
-            type:"MOCK_MO_REDIR_FLOW_STATE",
-            payload:mockedMSISDNEntryFailure.currentState
-          })
-        case "msisdn-entry-success-state":
-          return dispatch({
-            type:"MOCK_MO_REDIR_FLOW_STATE",
-            payload:mockedMSISDNEntrySuccess.currentState
-          })
-        default:
-          throw "Mock Flow not supported";
-      }
-    }
-  }
-}
-
-const initialState:IMoRedirFlowReducerState = {
-  currentState:{
-    type: "MSISDNEntry",
-    result: RDS.NothingYet<MSISDNEntryFailure, MSISDNEntrySuccess>()
-  }
-};
-
-export const MoRedirFlowActionMaps:IMoRedirFlowActionMaps = {
-  submitMSISDNAction:submitMSISDNAction
-}
-
-export default function MoRedirFlowReducer(state = initialState, action:IMoRedirActions) {
-  switch (action.type) {
-    case "MO_REDIR_MSISDN_SUBMIT":
-      return genericHandler<IMoRedirFlowReducerState, IMsisnSubmitActionPayload>(state, action.payload)
-    case "MO_REDIR_BACK_TO_START":
-      return genericHandler<IMoRedirFlowReducerState, IBackToStartPayload>(state, action.payload)
-    case "MO_REDIR_MSISDN_SUBMIT_ERROR":
-      return genericHandler<IMoRedirFlowReducerState, IMsisdnSubmitErrorPayload>(state, action.payload)
-    case "MOCK_MO_REDIR_FLOW_STATE":
-      return genericHandler<IMoRedirFlowReducerState, any>(state, action.payload)
-    default:
-      return state;
-  }
-}