react-native-moengage-cards 1.0.0

package/src/internal/MoEngageCardHandler.ts

@@ -0,0 +1,265 @@
+import { NativeEventEmitter, Platform } from "react-native";
+import PlatformPayloadBuilder from "./utils/PlatformPayloadBuilder";
+import SyncCompleteData from "../model/SyncData";
+import MoEngageCardsCache from "./MoEngageCardsCache";
+import SyncType from "../model/enums/SyncType";
+import {
+    getAllCategoryStatusFromPayload,
+    getCardInfoFromPayload,
+    getCardsCategoriesFromPayload,
+    getCardsDataFromPayload,
+    getCardsDataFromPayloadWithDefaultCategory,
+    getNewCardCountFromPayload,
+    getUnclickedCountFromPayload
+} from "./utils/PayloadParser";
+import CardInfo from "../model/CardInfo";
+import Card from "../model/Card";
+import CardsData from "../model/CardsData";
+import {
+    MODULE_TAG,
+    keyData,
+    keyPayload,
+    keySyncCompleteData,
+    argumentAppOpenSync,
+    argumentInboxOpenSync,
+    argumentPullToRefreshSync
+} from "./Constants";
+import { MoEngageLogger } from "react-native-moengage";
+import { syncDataFromJson } from "./utils/JsonToModelMapper";
+
+
+const MoEngageCardsBridge = require("react-native").NativeModules.MoEngageCardsBridge;
+
+let MoEngageEventEmitter: { addListener: (arg0: any, arg1: (data: any) => void) => void; };
+
+/**
+ * Helper class to connect the Public Card APIs to Platform specific bridge
+ * 
+ * @since 1.0.0
+ * @author Abhishek Kumar
+ */
+class MoEngageCardHandler {
+
+    private TAG = `${MODULE_TAG}MoEngageCardHandler`;
+
+    private appId: string;
+    private platformPayloadBuilder: PlatformPayloadBuilder;
+
+    constructor(appId: string) {
+        this.appId = appId;
+        this.platformPayloadBuilder = new PlatformPayloadBuilder(Platform.OS, this.appId);
+    }
+
+    initialize(): void {
+        try {
+            if (MoEngageCardsBridge && MoEngageEventEmitter === undefined) {
+                MoEngageEventEmitter = new NativeEventEmitter(MoEngageCardsBridge);
+                this.addBridgeEventListener();
+                MoEngageLogger.debug(`${this.TAG} Card Bridge Listener Added`);
+            }
+            MoEngageCardsBridge.initialize(this.platformPayloadBuilder.getAccountMetaPayload());
+            MoEngageLogger.debug(`${this.TAG} Card Module Initialised with appId: `, this.appId);
+        } catch (error) {
+            MoEngageLogger.error(`${this.TAG} Error while initialising the Cards Plugin: `, error);
+        }
+    }
+
+    refreshCards(onSyncComplete: (data: SyncCompleteData | null) => void): void {
+        try {
+            MoEngageCardsCache.cacheEventListenerCallback(SyncType.PULL_TO_REFRESH, onSyncComplete);
+            MoEngageCardsBridge.refreshCards(this.platformPayloadBuilder.getAccountMetaPayload());
+            MoEngageLogger.verbose(`${this.TAG} Executed - refreshCards() `);
+        } catch (error) {
+            MoEngageLogger.error(`${this.TAG} refreshCards() `, error);
+        }
+    }
+
+    onCardSectionLoaded(onSyncComplete: (data: SyncCompleteData | null) => void): void {
+        try {
+            MoEngageCardsCache.cacheEventListenerCallback(SyncType.INBOX_OPEN, onSyncComplete);
+            MoEngageCardsBridge.onCardSectionLoaded(this.platformPayloadBuilder.getAccountMetaPayload());
+            MoEngageLogger.verbose(`${this.TAG} Executed - onCardSectionLoaded() `);
+        } catch (error) {
+            MoEngageLogger.error(`${this.TAG} onCardSectionLoaded() `, error);
+        }
+    }
+
+    onCardSectionUnLoaded(): void {
+        try {
+            MoEngageCardsCache.removeCacheForEvent(SyncType.INBOX_OPEN);
+            MoEngageCardsBridge.onCardSectionUnLoaded(this.platformPayloadBuilder.getAccountMetaPayload());
+            MoEngageLogger.verbose(`${this.TAG} Executed - onCardSectionUnLoaded() `);
+        } catch (error) {
+            MoEngageLogger.error(`${this.TAG} onCardSectionUnLoaded() `, error);
+        }
+    }
+
+    async getCardsCategories(): Promise<Array<string>> {
+        try {
+            const categoriesPayload = await MoEngageCardsBridge.getCardsCategories(
+                this.platformPayloadBuilder.getAccountMetaPayload()
+            );
+            const cardCategories = getCardsCategoriesFromPayload(categoriesPayload);
+            MoEngageLogger.verbose(`${this.TAG} Executed - getCardsCategories() `, cardCategories);
+            return cardCategories ?? [];
+        } catch (error) {
+            MoEngageLogger.error(`${this.TAG} getCardsCategories() `, error);
+            return [];
+        }
+    }
+
+    async getCardsInfo(): Promise<CardInfo> {
+        try {
+            const cardInfoPayload = await MoEngageCardsBridge.getCardsInfo(
+                this.platformPayloadBuilder.getAccountMetaPayload()
+            );
+            const cardInfo = getCardInfoFromPayload(cardInfoPayload);
+            MoEngageLogger.verbose(`${this.TAG} Executed - getCardsInfo() `, cardInfo);
+            return cardInfo;
+        } catch (error) {
+            MoEngageLogger.error(`${this.TAG} getCardsInfo() `, error);
+            return new CardInfo(false, [], []);
+        }
+    }
+
+    cardClicked(card: Card, widgetId: number): void {
+        try {
+            MoEngageCardsBridge.cardClicked(this.platformPayloadBuilder.getCardClickedPayload(card, widgetId));
+            MoEngageLogger.verbose(`${this.TAG} Executed - cardClicked() for widgetId`, widgetId);
+        } catch (error) {
+            MoEngageLogger.error(`${this.TAG} cardClicked() `, error);
+        }
+    }
+
+    cardDelivered(): void {
+        try {
+            MoEngageCardsBridge.cardDelivered(this.platformPayloadBuilder.getAccountMetaPayload());
+            MoEngageLogger.verbose(`${this.TAG} Executed - cardDelivered() `);
+        } catch (error) {
+            MoEngageLogger.error(`${this.TAG} cardDelivered() `, error);
+        }
+    }
+
+    cardShown(card: Card) {
+        try {
+            MoEngageCardsBridge.cardShown(this.platformPayloadBuilder.getCardShowPayload(card));
+            MoEngageLogger.verbose(`${this.TAG} Executed - cardShown() `);
+        } catch (error) {
+            MoEngageLogger.error(`${this.TAG} cardShown() `, error);
+        }
+    }
+
+    async getCardsForCategory(category: string): Promise<CardsData> {
+        try {
+            const cardsDataPayload = await MoEngageCardsBridge.getCardsForCategory(
+                this.platformPayloadBuilder.getCardsForCategoriesPayload(category)
+            );
+            const cardsData = getCardsDataFromPayload(cardsDataPayload);
+            MoEngageLogger.verbose(`${this.TAG} Executed - getCardsForCategory() `, cardsData);
+            return cardsData;
+        } catch (error) {
+            MoEngageLogger.error(`${this.TAG} getCardsForCategory() `, error);
+            return new CardsData(category, []);
+        }
+    }
+
+    async fetchCards(): Promise<CardsData> {
+        try {
+            const cardsDataPayload = await MoEngageCardsBridge.fetchCards(
+                this.platformPayloadBuilder.getAccountMetaPayload()
+            );
+            const cardsData = getCardsDataFromPayloadWithDefaultCategory(cardsDataPayload);
+            MoEngageLogger.verbose(`${this.TAG} Executed - fetchCards() `, cardsData);
+            return cardsData;
+        } catch (error) {
+            MoEngageLogger.error(`${this.TAG} fetchCards() `, error);
+            return new CardsData("", []);
+        }
+    }
+
+    deleteCards(cards: Array<Card>) {
+        try {
+            MoEngageCardsBridge.deleteCards(this.platformPayloadBuilder.getDeleteCardsPayload(cards));
+            MoEngageLogger.verbose(`${this.TAG} Executed - deleteCards() `);
+        } catch (error) {
+            MoEngageLogger.error(`${this.TAG} deleteCards() `, error);
+        }
+    }
+
+    async isAllCategoryEnabled(): Promise<boolean> {
+        try {
+            const categoryStatusPayload = await MoEngageCardsBridge.isAllCategoryEnabled(
+                this.platformPayloadBuilder.getAccountMetaPayload()
+            );
+            const isAllCategoryEnabled = getAllCategoryStatusFromPayload(categoryStatusPayload);
+            MoEngageLogger.verbose(`${this.TAG} Executed - isAllCategoryEnabled() `, isAllCategoryEnabled);
+            return isAllCategoryEnabled ?? false;
+        } catch (error) {
+            MoEngageLogger.error(`${this.TAG} isAllCategoryEnabled() `, error);
+            return false;
+        }
+    }
+
+    async getNewCardsCount(): Promise<number> {
+        try {
+            const newCardsCountPayload = await MoEngageCardsBridge.getNewCardsCount(
+                this.platformPayloadBuilder.getAccountMetaPayload()
+            );
+            const newCardCount = getNewCardCountFromPayload(newCardsCountPayload);
+            MoEngageLogger.verbose(`${this.TAG} Executed - getNewCardsCount() `, newCardCount);
+            return newCardCount ?? 0;
+        } catch (error) {
+            MoEngageLogger.error(`${this.TAG} getNewCardsCount() `, error);
+            return 0;
+        }
+    }
+
+    async getUnClickedCardsCount(): Promise<number> {
+        try {
+            const unClickedCardsCountPayload = await MoEngageCardsBridge.getUnClickedCardsCount(
+                this.platformPayloadBuilder.getAccountMetaPayload()
+            );
+            const unclickedCount = getUnclickedCountFromPayload(unClickedCardsCountPayload);
+            MoEngageLogger.verbose(`${this.TAG} Executed - getUnClickedCardsCount() `, unclickedCount);
+            return unclickedCount;
+        } catch (error) {
+            MoEngageLogger.error(`${this.TAG} getUnClickedCardsCount() `, error);
+            return 0;
+        }
+    }
+
+    private addBridgeEventListener(): void {
+        MoEngageEventEmitter.addListener(
+            argumentAppOpenSync,
+            (data) => this.handleCallbackForSyncEvent(SyncType.APP_OPEN, data)
+        );
+
+        MoEngageEventEmitter.addListener(
+            argumentPullToRefreshSync,
+            (data) => this.handleCallbackForSyncEvent(SyncType.PULL_TO_REFRESH, data)
+        );
+
+        MoEngageEventEmitter.addListener(
+            argumentInboxOpenSync,
+            (data) => this.handleCallbackForSyncEvent(SyncType.INBOX_OPEN, data)
+        );
+    }
+
+    private handleCallbackForSyncEvent(syncType: SyncType, data: { [k: string]: any }): void {
+        try {
+            const payload = data[keyPayload];
+            const dataJson = JSON.parse(payload)[keyData];
+            MoEngageLogger.verbose(`${this.TAG} handleCallbackForSyncEvent() `, dataJson);
+            if (dataJson !== undefined) {
+                const syncJson = dataJson[keySyncCompleteData];
+                const syncCompleteData = syncJson !== undefined && syncJson != null ? syncDataFromJson(syncJson) : null;
+                MoEngageLogger.debug(`${this.TAG} handleCallbackForSyncEvent(): Will try to emit callback for syncType = `, syncType);
+                MoEngageCardsCache.getCallbackForCachedEvent(syncType)?.(syncCompleteData);
+            }
+        } catch (error) {
+            MoEngageLogger.error(`handleCallbackForSyncEvent() SyncType: ${syncType} `, error);
+        }
+    }
+}
+
+export default MoEngageCardHandler;

package/src/internal/MoEngageCardsCache.ts

@@ -0,0 +1,31 @@
+import SyncCompleteData from "../model/SyncData";
+import SyncType from "../model/enums/SyncType";
+
+/**
+ * Global Cache to store the cache for Cards Plugin
+ * 
+ * @since 1.0.0
+ * @author Abhishek Kumar
+ */
+namespace MoEngageCardsCache {
+
+    /**
+     * Sync Event Listener Cache
+     * @since 1.0.0
+     */
+    let eventListenerCache: Map<SyncType, (data: SyncCompleteData | null) => void> = new Map();
+
+    export function cacheEventListenerCallback(syncType: SyncType, onTrigger: (data: SyncCompleteData | null) => void): void {
+        eventListenerCache.set(syncType, onTrigger);
+    }
+
+    export function getCallbackForCachedEvent(syncType: SyncType): ((data: SyncCompleteData | null) => void) | undefined {
+        return eventListenerCache.get(syncType);
+    }
+
+    export function removeCacheForEvent(syncType: SyncType): void {
+        eventListenerCache.delete(syncType);
+    }
+}
+
+export default MoEngageCardsCache;

package/src/internal/utils/JsonToModelMapper.ts

@@ -0,0 +1,267 @@
+/**
+ * @file contains the function to get the model from json
+ * @author Abhishek Kumar
+ * @since 1.0.0
+ */
+
+import CampaignState from "../../model/CampaignState";
+import Card from "../../model/Card";
+import CardInfo from "../../model/CardInfo";
+import CardsData from "../../model/CardsData";
+import Container from "../../model/Container";
+import DisplayControl from "../../model/DisplayControl";
+import MetaData from "../../model/MetaData";
+import ShowTime from "../../model/ShowTime";
+import SyncCompleteData from "../../model/SyncData";
+import Template from "../../model/Template";
+import Widget from "../../model/Widget";
+import Action from "../../model/action/Action";
+import NavigationAction from "../../model/action/NavigationAction";
+import ActionType from "../../model/enums/ActionType";
+import NavigationType from "../../model/enums/NavigationType";
+import SyncType from "../../model/enums/SyncType";
+import TemplateType from "../../model/enums/TemplateType";
+import WidgetType from "../../model/enums/WidgetType";
+import ButtonStyle from "../../model/styles/ButtonStyle";
+import ContainerStyle from "../../model/styles/ContainerStyle";
+import ImageStyle from "../../model/styles/ImageStyle";
+import TextStyle from "../../model/styles/TextStyle";
+import WidgetStyle from "../../model/styles/WidgetStyle";
+import {
+    defaultContainerBgColor,
+    defaultFontSize,
+    defaultTextBgColor,
+    keyActionType,
+    keyActionValue,
+    keyActions,
+    keyAdditionalMetaData,
+    keyBackgroundColor,
+    keyCampaignPayload,
+    keyCampaignState,
+    keyCardId,
+    keyCards,
+    keyCategories,
+    keyCategory,
+    keyContainerId,
+    keyContainerStyle,
+    keyContainerType,
+    keyContainers,
+    keyCreatedAt,
+    keyDeletionTime,
+    keyDisplayControl,
+    keyEndTime,
+    keyExpireAfterDelivered,
+    keyExpireAfterSeen,
+    keyExpireAt,
+    keyFirstReceived,
+    keyFirstSeen,
+    keyFontSize,
+    keyHasUpdates,
+    keyId,
+    keyIsClicked,
+    keyIsNewCard,
+    keyIsPinned,
+    keyKVPairs,
+    keyLocalShowCount,
+    keyMaxCount,
+    keyMetaData,
+    keyNavigationType,
+    keyShouldShowAllTab,
+    keyShowTime,
+    keyStartTime,
+    keySyncType,
+    keyTemplateData,
+    keyTemplateType,
+    keyTotalShowCount,
+    keyUpdatedAt,
+    keyWidgetContent,
+    keyWidgetId,
+    keyWidgetStyle,
+    keyWidgetType,
+    keyWidgets
+} from "../Constants";
+import { assertUnsupportedError, getEnumByName } from "../utils/Util";
+
+export function actionFromJson(json: { [k: string]: any }): Action {
+    const navigationType: ActionType = getEnumByName(ActionType, json[keyActionType] ?? "");
+    switch (navigationType) {
+        case ActionType.NAVIGATE:
+            return navigationActionFromJson(json);
+        default:
+            assertUnsupportedError("Action Type Not Supported");
+    }
+}
+
+export function navigationActionFromJson(json: { [k: string]: any }): NavigationAction {
+    return new NavigationAction(
+        ActionType.NAVIGATE,
+        getEnumByName<NavigationType>(NavigationType, json[keyNavigationType]),
+        json[keyActionValue],
+        json[keyKVPairs]
+    );
+}
+
+export function widgetStyleFromJson(json: { [k: string]: any }, widgetType: WidgetType): WidgetStyle | undefined {
+    switch (widgetType) {
+        case WidgetType.TEXT:
+            return textStyleFromJson(json);
+        case WidgetType.BUTTON:
+            return buttonStyleFromJson(json);
+        case WidgetType.IMAGE:
+            return imageStyleFromJson(json);
+        default:
+            assertUnsupportedError("Widget Type Not Supported");
+    }
+}
+
+export function buttonStyleFromJson(json: { [k: string]: any }): ButtonStyle | undefined {
+    if (json === undefined || json === null) return undefined;
+    return new ButtonStyle(
+        json[keyBackgroundColor] ?? defaultTextBgColor,
+        json[keyFontSize] ?? defaultFontSize
+    );
+}
+
+export function containerStyleFromJson(json: { [k: string]: any }): ContainerStyle | undefined {
+    if (json === undefined || json === null) return undefined;
+    return new ContainerStyle(
+        json[keyBackgroundColor] ?? defaultContainerBgColor
+    );
+}
+
+export function imageStyleFromJson(json: { [k: string]: any }): ImageStyle | undefined {
+    if (json === undefined || json === null) return undefined;
+    return new ImageStyle(
+        json[keyBackgroundColor] ?? defaultTextBgColor
+    );
+}
+
+export function textStyleFromJson(json: { [k: string]: any }): TextStyle | undefined {
+    if (json === undefined || json === null) return undefined;
+    return new TextStyle(
+        json[keyBackgroundColor] ?? defaultTextBgColor,
+        json[keyFontSize] ?? defaultFontSize
+    );
+}
+
+export function campaignStateFromJson(json: { [k: string]: any }): CampaignState {
+    return new CampaignState(
+        json[keyLocalShowCount] ?? 0,
+        json[keyIsClicked] ?? false,
+        json[keyFirstReceived] ?? -1,
+        json[keyFirstSeen] ?? -1,
+        json[keyTotalShowCount] ?? 0
+    );
+}
+
+export function cardFromJson(json: { [k: string]: any }): Card {
+    return new Card(
+        json[keyId] ?? -1,
+        json[keyCardId],
+        json[keyCategory] ?? "",
+        templateFromJson(json[keyTemplateData]),
+        metaDataFromJson(json[keyMetaData])
+    );
+}
+
+export function cardInfoFromJson(json: { [k: string]: any }): CardInfo {
+    return new CardInfo(
+        json[keyShouldShowAllTab] ?? false,
+        json[keyCategories] ?? [],
+        Array.from((json[keyCards] ?? []) as Iterable<{ [k: string]: any }>)
+            .map((cardJson) => {
+                return cardFromJson(cardJson);
+            })
+    );
+}
+
+export function cardsDataFromJson(json: { [k: string]: any }): CardsData {
+    return new CardsData(
+        json[keyCategory],
+        Array.from((json[keyCards] ?? []) as Iterable<{ [k: string]: any }>)
+            .map((cardObject) => {
+                return cardFromJson(cardObject);
+            })
+    );
+}
+
+export function containerFromJson(json: { [k: string]: any }): Container {
+    return new Container(
+        json[keyContainerId],
+        getEnumByName<TemplateType>(TemplateType, json[keyContainerType]),
+        containerStyleFromJson(json[keyContainerStyle]),
+        Array.from((json[keyWidgets] ?? []) as Array<{ [k: string]: any }>)
+            .map((widget) => {
+                return widgetFromJson(widget);
+            }),
+        Array.from((json[keyActions] ?? []) as Array<{ [k: string]: any }>)
+            .map((action) => {
+                return actionFromJson(action);
+            })
+    );
+}
+
+export function displayControlFromJson(json: { [k: string]: any }): DisplayControl {
+    return new DisplayControl(
+        json[keyExpireAt] ?? -1,
+        json[keyExpireAfterSeen] ?? -1,
+        json[keyExpireAfterDelivered] ?? -1,
+        json[keyMaxCount] ?? 0,
+        json[keyIsPinned] ?? false,
+        showTimeFromJson(json[keyShowTime] ?? {})
+    );
+}
+
+export function metaDataFromJson(json: { [k: string]: any }): MetaData {
+    const displayControl = displayControlFromJson(json[keyDisplayControl] ?? {});
+    return new MetaData(
+        displayControl.isPinned,
+        json[keyIsNewCard] ?? false,
+        campaignStateFromJson(json[keyCampaignState] ?? {}),
+        json[keyDeletionTime],
+        displayControl,
+        json[keyAdditionalMetaData] ?? {},
+        json[keyCreatedAt] ?? -1,
+        json[keyUpdatedAt] ?? -1,
+        json[keyCampaignPayload] ?? {},
+    );
+}
+
+export function showTimeFromJson(json: { [k: string]: any }): ShowTime {
+    return new ShowTime(
+        json[keyStartTime],
+        json[keyEndTime]
+    );
+}
+
+export function syncDataFromJson(json: { [k: string]: any }): SyncCompleteData {
+    return new SyncCompleteData(
+        json[keyHasUpdates] ?? false,
+        getEnumByName<SyncType>(SyncType, json[keySyncType])
+    );
+}
+
+export function templateFromJson(json: { [k: string]: any }): Template {
+    return new Template(
+        getEnumByName<TemplateType>(TemplateType, json[keyTemplateType]),
+        Array.from((json[keyContainers] ?? []) as Array<{ [k: string]: any }>)
+            .map((container) => {
+                return containerFromJson(container);
+            }),
+        json[keyKVPairs]
+    );
+}
+
+export function widgetFromJson(json: { [k: string]: any }): Widget {
+    const widgetType = getEnumByName<WidgetType>(WidgetType, json[keyWidgetType]);
+    return new Widget(
+        json[keyWidgetId],
+        widgetType,
+        json[keyWidgetContent],
+        widgetStyleFromJson(json[keyWidgetStyle], widgetType),
+        Array.from((json[keyActions] ?? []) as Iterable<{ [k: string]: any }>)
+            .map((action) => {
+                return actionFromJson(action);
+            })
+    );
+}