airbridge-react-native-sdk-restricted 2.5.2

package/src/Placement.js

@@ -0,0 +1,56 @@
+import { NativeModules } from 'react-native';
+import Log from './tool/Log';
+import _ from './tool/_';
+
+const { AirbridgePlacement } = NativeModules;
+
+/**
+ * class for use SDK's placement function (singleton)
+ */
+class Placement {
+    /**
+     * @hideconstructor
+     */
+    constructor() {}
+
+    /**
+     * 1. send +1 click statistics to server<br/>
+     * 2. get deeplink and fallback from server<br/>
+     * 3. open deeplink. when fail, open fallback<br/>
+     * 4. parameter's deeplink, fallback is spare for network-fail
+     *
+     * @param {string} trackingLink created on dashboard
+     */
+    click(trackingLink, deeplink, fallback) {
+        Log.info('click tracking link');
+
+        if (_.isString(trackingLink) === false) {
+            Log.unmatchType('trackingLink');
+            Log.fail('click tracking link');
+
+            return;
+        }
+
+        AirbridgePlacement.click(trackingLink);
+    }
+
+    /**
+     * send +1 impression statistics to server<br/>
+     *
+     * @param {string} trackingLink created on dashboard
+     */
+    impression(trackingLink) {
+        Log.info('impression tracking link');
+
+        if (_.isString(trackingLink) === false) {
+            Log.unmatchType('trackingLink');
+            Log.fail('impression tracking link');
+
+            return;
+        }
+
+        AirbridgePlacement.impression(trackingLink);
+    }
+}
+
+export default new Placement();

package/src/State.js

@@ -0,0 +1,167 @@
+import { NativeEventEmitter, NativeModules } from 'react-native';
+import Log from './tool/Log';
+import _ from './tool/_';
+
+import './typedef/User';
+
+const { AirbridgeState, AirbridgeAttribution } = NativeModules;
+
+/**
+ * @callback AttributionListener
+ * @param {object<string, string>} attribution URL of attribution
+ * @returns {void}
+ */
+
+/**
+ * class for manage SDK's state (singleton)
+ */
+class State {
+    /**
+     * @hideconstructor
+     */
+    constructor() {}
+
+    /**
+     * set current user<br/>
+     *
+     * user.property is null, if input.property is null
+     * @param {User} user user infomation
+     */
+    setUser(user) {
+        Log.info('set user');
+
+        if (_.isObject(user) === false) {
+            Log.unmatchType('user');
+            Log.fail('set user');
+
+            return;
+        }
+
+        if (_.isNullableString(user.ID) === false) {
+            user.ID = null;
+        }
+        if (_.isNullableString(user.email) === false) {
+            user.email = null;
+        }
+        if (_.isNullableString(user.phone) === false) {
+            user.phone = null;
+        }
+        if (_.isNullableObject(user.alias) === false) {
+            user.alias = null;
+        }
+        if (_.isNullableObject(user.attributes) === false) {
+            user.attributes = null;
+        }
+
+        AirbridgeState.setUser(user);
+    }
+
+    /**
+     * update current user<br/>
+     *
+     * user.property not be changed, if input.property is null
+     * @param {User} user user infomation
+     */
+    updateUser(user) {
+        Log.info('update user');
+
+        if (_.isObject(user) === false) {
+            Log.unmatchType('user');
+            Log.fail('update user');
+
+            return;
+        }
+
+        if (_.isNullableString(user.ID) === false) {
+            user.ID = null;
+        }
+        if (_.isNullableString(user.email) === false) {
+            user.email = null;
+        }
+        if (_.isNullableString(user.phone) === false) {
+            user.phone = null;
+        }
+        if (_.isNullableObject(user.alias) === false) {
+            user.alias = null;
+        }
+        if (_.isNullableObject(user.attributes) === false) {
+            user.attributes = null;
+        }
+
+        AirbridgeState.updateUser(user);
+    }
+
+    /**
+     * make airbridge start tracking
+     */
+    startTracking() {
+        Log.info('start tracking');
+
+        AirbridgeState.startTracking();
+    }
+
+    /**
+     * get deviceUUID of Airbridge SDK.
+     *
+     * @returns {Promise<string>}
+     */
+    deviceUUID() {
+        return AirbridgeState.deviceUUID();
+    }
+
+    /**
+     * Set AttributionListener (listen attribution)<br/>
+     * @param {AttributionListener} listener callback of attribution
+     */
+    setAttributionListener(listener) {
+        Log.info('set attribution listener');
+
+        if (this._attributionListener === undefined) {
+            this._attributionListener = listener;
+
+            this._attributionEmitter = new NativeEventEmitter(AirbridgeAttribution);
+            this._attributionEmitter.addListener('airbridge.attribution', attribution => {
+                Log.info(`[attribution] ${JSON.stringify(attribution)}`);
+                this._attributionListener(attribution);
+            });
+
+            AirbridgeAttribution.listen();
+        } else {
+            this._attributionListener = listener;
+        }
+    }
+
+    /**
+     * Set device alias
+     * @param {string} key - device alias key
+     * @param {string} value - device alias value
+     */
+    setDeviceAlias(key, value) {
+        AirbridgeState.setDeviceAlias(key, value);
+    }
+
+    /**
+     * Remove device alias
+     * @param {string} key - callback of attribution
+     */
+    removeDeviceAlias(key) {
+        AirbridgeState.removeDeviceAlias(key);
+    }
+
+    /**
+     * clear device alias
+     */
+    clearDeviceAlias() {
+        AirbridgeState.clearDeviceAlias();
+    }
+
+    /**
+     * register push token
+     * @param {string} token - push token
+     */
+    registerPushToken(token) {
+        AirbridgeState.registerPushToken(token);
+    }
+}
+
+export default new State();

package/src/WebInterface.js

@@ -0,0 +1,135 @@
+import Log from './tool/Log';
+import _ from './tool/_';
+
+/**
+ * class for interface of webview
+ */
+class WebInterface {
+    /**
+     * @hideconstructor
+     */
+    constructor(webToken, postCommandFunction, stateInstance, eventInstance) {
+        if (_.isString(webToken) === false) {
+            Log.fail('webToken is not string');
+            return;
+        }
+        
+        if (_.isFunction(postCommandFunction) === false) {
+            Log.fail('postCommandFunction is not function');
+            return;
+        }
+
+        const postCommand = postCommandFunction('command');
+        
+        this._stateInstance = stateInstance;
+        this._eventInstance = eventInstance;
+
+        const getScript = function (webToken, postCommand) {
+            const jsonSchemaVersion = 4;
+            const sdkVersion = '2.5.2';
+    
+            return `
+                AirbridgeNative = {};
+                AirbridgeNative.postCommand = function (command) {
+                    ${postCommand};
+                };
+                AirbridgeNative.getWebToken = function () {
+                    return "${webToken}";
+                };
+                AirbridgeNative.getJsonSchemaVersion = function () {
+                    return ${jsonSchemaVersion};
+                };
+                AirbridgeNative.getSdkVersion = function () {
+                    return "${sdkVersion}";
+                };
+                AirbridgeNative.setUser = function (payload) {
+                    AirbridgeNative.postCommand(JSON.stringify({
+                        method: "setUser",
+                        payload: payload
+                    }));
+                };
+                AirbridgeNative.clearUser = function () {
+                    AirbridgeNative.postCommand(JSON.stringify({
+                        method: "clearUser",
+                        payload: {}
+                    }));
+                };
+                AirbridgeNative.trackEvent = function (payload) {
+                    AirbridgeNative.postCommand(JSON.stringify({
+                        method: "trackEvent",
+                        payload: payload
+                    }));
+                };
+            `;
+        };
+
+        this.script = getScript(webToken, postCommand);
+    }
+
+    /**
+     * handle command from webview
+     * @param {String} command command from webview
+     */
+    handle(command) {
+        const object = JSON.parse(command);
+        switch (object.method) {
+            case 'setUser': {
+                if (_.isObject(object) === false) {
+                    Log.unmatchType('user');
+                    Log.fail('set user');
+
+                    return;
+                }
+
+                const payload = JSON.parse(object.payload);
+                const user = {
+                    id: payload.id,
+                    email: payload.email,
+                    phone: payload.phone,
+                    alias: payload.alias,
+                    attributes: payload.attributes,
+                };
+
+                this._stateInstance.setUser(user);
+                break;
+            }
+            case 'clearUser': {
+                const user = {
+                    id: null,
+                    email: null,
+                    phone: null,
+                    alias: null,
+                    attributes: null,
+                };
+
+                this._stateInstance.setUser(user);
+                break;
+            }
+            case 'trackEvent': {
+                if (_.isObject(object) === false) {
+                    Log.unmatchType('event');
+                    Log.fail('track event');
+
+                    return;
+                }
+
+                const payload = JSON.parse(object.payload);
+                const option = {
+                    action: payload.action,
+                    label: payload.label,
+                    value: payload.value,
+                    customAttributes: payload.custom_attributes,
+                    semanticAttributes: payload.semantic_attributes,
+                };
+
+                this._eventInstance.trackEvent(payload.category, option);
+                break;
+            }
+            default:
+                Log.info('webinterface command is not handlable');
+                break;
+        }
+    }
+}
+
+export default WebInterface;

package/src/tool/Log.js

@@ -0,0 +1,40 @@
+/**
+ * class for log
+ * @private
+ */
+class Log {
+    /**
+     * @type {string}
+     * @private
+     */
+    static HEADER = '[Airbridge RN]';
+
+    /**
+     * warning unmatch type exist
+     * @param {string} name
+     * @returns {void}
+     */
+    static unmatchType(name) {
+        console.warn(`${this.HEADER} ${name} has unmatched type`);
+    }
+
+    /**
+     * log infomaton message
+     * @param {string} message
+     * @returns {void}
+     */
+    static info(message) {
+        console.info(`${this.HEADER} ${message}`);
+    }
+
+    /**
+     * warning fail to do task in method
+     * @param {string} name
+     * @returns {void}
+     */
+    static fail(name) {
+        console.warn(`${this.HEADER} fail to ${name}`);
+    }
+}
+
+export default Log;

package/src/tool/_.js

@@ -0,0 +1,56 @@
+import isFunction from 'lodash.isfunction';
+import isPlainObject from 'lodash.isplainobject';
+import isString from 'lodash.isstring';
+
+/**
+ * class for util method
+ * @private
+ */
+class _ {
+    /**
+     * return true if value is null or plain object
+     * @param {any} value
+     * @returns {boolean}
+     */
+    static isNullableObject(value) {
+        return value === null || isPlainObject(value);
+    }
+
+    /**
+     * return true if value is plain object
+     * @param {any} value
+     * @returns {boolean}
+     */
+    static isObject(value) {
+        return isPlainObject(value);
+    }
+
+    /**
+     * return true if value is null or string
+     * @param {any} value
+     * @returns {boolean}
+     */
+    static isNullableString(value) {
+        return value === null || isString(value);
+    }
+
+    /**
+     * return true if value is string
+     * @param {any} value
+     * @returns {boolean}
+     */
+    static isString(value) {
+        return isString(value);
+    }
+
+    /**
+     * return true if value is function
+     * @param {any} value
+     * @returns {boolean}
+     */
+    static isFunction(value) {
+        return isFunction(value);
+    }
+}
+
+export default _;

package/src/type/AirbridgeAttributes.js

@@ -0,0 +1,16 @@
+/** Common AirbridgeAttribute Keys  */
+var AirbridgeAttributes = {
+    QUERY: "query",
+    PRODUCT_LIST_ID: "productListID",
+    CART_ID: "cartID",
+    TRANSACTION_ID: "transactionID",
+    PRODUCTS: "products",
+    IN_APP_PURCHASED: "inAppPurchased",
+    CURRENCY: "currency",
+    TOTAL_VALUE: "totalValue",
+    TOTAL_QUANTITY: "totalQuantity",
+};
+
+export {
+    AirbridgeAttributes,
+}

package/src/type/AirbridgeCategory.js

@@ -0,0 +1,18 @@
+/** Common Airbridge category  */
+var AirbridgeCategory = {
+    SIGN_UP: "airbridge.user.signup",
+    SIGN_IN: "airbridge.user.signin",
+    SIGN_OUT:  "airbridge.user.signout",
+
+    HOME_VIEW: "airbridge.ecommerce.home.viewed",
+    SEARCH_RESULT_VIEW: "airbridge.ecommerce.searchResults.viewed",
+    PRODUCT_LIST_VIEW: "airbridge.ecommerce.productList.viewed",
+    PRODUCT_DETAILS_VIEW: "airbridge.ecommerce.product.viewed",
+
+    ADD_TO_CART: "airbridge.ecommerce.product.addedToCart",
+    ORDER_COMPLETED: "airbridge.ecommerce.order.completed"
+};
+
+export {
+    AirbridgeCategory,
+}

package/src/type/AirbridgeProduct.js

@@ -0,0 +1,13 @@
+/** Common AirbridgeProduct Keys  */
+var AirbridgeProduct = {
+    PRODUCT_ID: "productID",
+    NAME: "name",
+    CURRENCY: "currency",
+    PRICE: "price",
+    QUANTITY: "quantity",
+    POSITION: "position",
+};
+
+export {
+    AirbridgeProduct,
+}

package/src/typedef/EventOption.js

@@ -0,0 +1,9 @@
+/**
+ * @typedef {Object} EventOption
+ * 
+ * @property {string} [action] event group name 1
+ * @property {string} [label] event group name 2
+ * @property {number} [value] event custom value
+ * @property {Object.<string, string>} [customAttributes] event custom attributes
+ * @property {Object.<string, *>} [semanticAttributes] event semantic attributes
+ */

package/src/typedef/Product.js

@@ -0,0 +1,10 @@
+/**
+ * @typedef {Object} Product
+ *
+ * @property {string} [ID] Product's unique identifier
+ * @property {string} [name] Product's name
+ * @property {string} [currency] currency in <a href='https://en.wikipedia.org/wiki/ISO_4217'>ISO 4217<a/>
+ * @property {number} [price] Product's price
+ * @property {number} [quantity] Purchased quantity
+ * @property {number} [position] Product's index in list
+ */

package/src/typedef/User.js

@@ -0,0 +1,9 @@
+/**
+ * @typedef {Object} User
+ *
+ * @property {string} [ID] User's ID (not allow empty string)
+ * @property {string} [email] User's Email (not allow empty string)
+ * @property {string} [phone] User's Phone Number (not allow empty string)
+ * @property {object} [alias] User's Alias
+ * @property {object} [attributes] User's Attributes
+ */