@como/como-client 0.1.8 → 0.1.9-1.1

package/src/como.js

@@ -0,0 +1,930 @@
+const moment = require('moment-timezone');
+const axios = require('axios');
+const ramda = require('ramda');
+const environmentConfig = require('./config/env');
+const APIService = require('./services');
+const comoExternalUrlTranslator = require('./utils/comoExternalUrlTranslator');
+const resourceNames = require('./constants/resourceNames');
+const urlsUtils = require('./utils/urls');
+
+const INITIAL_COMO_DATA = {
+    env: environmentConfig,
+    token: null,
+    locationId: null,
+    locationState: null,
+    installationId: null,
+    membership: null,
+    assets: null,
+    mainResources: {},
+};
+
+class Como {
+    constructor() {
+        this.comoData = {};
+    }
+
+    async refreshTokenIfNeeded() {
+        const { refresher, expiresIn } = this.comoData;
+        if(!refresher){
+            console.log('No refresh for %o', this.comoData);
+        }
+        if (refresher && expiresIn && moment(expiresIn).subtract(10, 'seconds').isBefore(moment())) {
+            await refresher();
+        }
+    }
+
+
+    /**
+     * Sign the user and returns guest token & refresh token.
+     * Requires init.
+     */
+    async signon(source) {
+        const { api } = this.comoData;
+        try {
+            const data = await api.signOn(this.comoData.installationId, this.comoData.locationId, this.comoData.refreshToken, source);
+            if (data && data.config && data.config.loyaltyCDN) {
+                this.comoData.env_params.services_root_cdn = data.config.loyaltyCDN;
+            }
+            return data;
+        } catch (error) {
+            if (error.response && error.response.data) {
+                const { code, message } = error.response.data;
+                throw new Error(code || message);
+            }
+            throw error;
+        }
+    }
+
+    /**
+     *
+     * @param {Object} environment Environemnt object
+     * @param {string} environment.id Environment Id
+     * @param {string} environment.locationId Location Id
+     * @param {string} environment.installationId Unique installation id
+     * @param {Object} credentials Member credentials (Optional)
+     * @param {string} accessToken session id string (Optional)
+     * @param {string} refreshToken refresh token string (Optional)
+     * @param {string} expiresIn access token expiration date formatted (Optional)
+     * @param {function} refreshCallback an event callback which fires each time user's tokens gets refreshed
+     * @param {boolean} enableSignon if disabled signOn api call will not be fired. Enabled by default.
+     */
+    async init(environment, credentials, refreshCallback, enableSignon = true) {
+        const isExists = (x => !ramda.isNil(x) && !ramda.isEmpty(x));
+        const { id: environmentId, locationId, installationId, source } = environment;
+        if (!isExists(environmentId) || !isExists(locationId) || !isExists(installationId)) {
+            throw new Error(`missing parameters: ${environment}`);
+        }
+        this.comoData = {
+            ...INITIAL_COMO_DATA,
+            ...credentials,
+            installationId,
+            locationId,
+            source,
+            env_params: {
+                ...INITIAL_COMO_DATA.env[environmentId],
+            },
+        };
+
+        const updateCredentials = (creds, isNew = false) => {
+            this.updateLocalCreds(creds);
+            if (refreshCallback && isNew) {
+                refreshCallback(creds);
+            }
+        };
+
+        const getCredentials = this.getCredentials.bind(this);
+        const { gateway } = this.comoData.env_params;
+        const { service, refresher } = APIService
+            .getService(gateway, installationId, getCredentials, updateCredentials, source, locationId);
+        this.comoData.api = service;
+        this.comoData.refresher = refresher;
+
+        const { accessToken, refreshToken, expiresIn } = credentials;
+        const credsNotExist = !isExists(accessToken) || !isExists(refreshToken);
+        let isExpired = !credsNotExist && expiresIn && moment(expiresIn).isBefore(moment());
+        if(credsNotExist){
+            try{
+                await this.signon(installationId, locationId, source);
+            }catch(e){
+                //TODO: need to parse error
+                console.log(`Failed to signOn, installationId:${installationId}, locationId:${locationId}, source:${source}`);
+                isExpired = true;// user uid exist - do refresh
+            }
+        }
+        let refreshFailed = false;
+        if(isExpired){
+            try{
+                await this.refreshTokenIfNeeded();
+            }catch(e){
+                console.log(`Failed to refresh token, installationId:${installationId}, locationId:${locationId}, source:${source}`);
+                //TODO: need to parse error
+                //refresh failed - need to revoke and signOn again
+                refreshFailed = true;
+            }
+        }
+        if(refreshFailed){
+            await this.signon(installationId, locationId, source);
+        }
+        return this.getCredentials();
+    }
+
+    /**
+     * Updates the como.js local credentials settings.
+     * Used when making api calls to janua.
+     *
+     * @param {Object} credentials credentials to update.
+     * @param {Object} accessToken access token to update.
+     * @param {Object} refreshToken refresh token to update.
+     * @param {Object} expiresIn access token expiry date to update.
+     */
+    updateLocalCreds(credentials = {}) {
+        this.comoData.accessToken = credentials.accessToken;
+        this.comoData.token = credentials.accessToken;
+        this.comoData.refreshToken = credentials.refreshToken;
+        this.comoData.expiresIn = credentials.expiresIn;
+    }
+
+    getExternalUrlByID(itemID, gpsData, assetID, accessibilityData) {
+        const locationData = this.comoData.mainResources[resourceNames.LOCATION_DATA];
+        if (locationData && locationData.WebViews && locationData.WebViews[0].item) {
+            const possibleWebViews = locationData.WebViews[0].item.filter(u => u.id === itemID);
+            const url = possibleWebViews && possibleWebViews[0] && possibleWebViews[0].url;
+            return this.translateExternalUrl(url, gpsData, assetID, accessibilityData);
+        }
+        return null;
+    }
+
+    async translateExternalUrl(url, gpsData, assetID, accessibilityData) {
+        const legacyUrl = await this.getAppModulesLegacyBaseUrl();
+        let externalUrl = url;
+        if (externalUrl && externalUrl.startsWith(legacyUrl)) {
+            externalUrl = externalUrl.replace(legacyUrl, this.comoData.env_params.app_modules_root);
+        }
+        const {
+            api, locationId, token, env_params: env, membership, assets,
+        } = this.comoData;
+        const locationData = this.comoData.mainResources && this.comoData.mainResources[resourceNames.LOCATION_DATA];
+        const apiObjects = { api, servicesRoot: env.services_root };
+        const dataToUse = {
+            locationId, token, membership, locationData, assets, gpsData, assetID, accessibilityData,
+        };
+        return comoExternalUrlTranslator.translateUrl(externalUrl, apiObjects, dataToUse);
+    }
+
+    async getFeedbackFormData() {
+        const {
+            locationId, token, env_params: env, api,
+        } = this.comoData;
+        return api.getFeedbackFormData(env.zapp_root, locationId, token);
+    }
+
+    /**
+     *
+     * @param {Object} form registration form values
+     * @param {Object} verification flow
+     * @param {strin} reCaptchaToken
+     * @param {Object} source(registration origin)
+     */
+    async register(form, verification, reCaptchaToken, source) {
+        const { api } = this.comoData;
+        try {
+            const data = await api.register(form, verification, reCaptchaToken, source);
+            return data;
+        } catch (error) {
+            if (error.response && error.response.data) {
+                const { code, message } = error.response.data;
+                throw new Error(code || message);
+            }
+            throw error;
+        }
+    }
+
+    /**
+     *
+     * @param {string} verification flow (code & verification step)
+     * @param {string} type verification type
+     * @param {Object} form registration form values
+     * @param {string} reCaptchaToken
+     */
+    async registerVerify(verification, type, form, reCaptchaToken) {
+        const { api } = this.comoData;
+        try {
+            const data = await api.registerVerify(verification, type, form, reCaptchaToken);
+            return data;
+        } catch (error) {
+            if (error.response && error.response.data) {
+                const { code, message } = error.response.data;
+                throw new Error(code || message);
+            }
+            throw error;
+        }
+    }
+
+    /**
+     *
+     * @param {Object} form update form values
+     * @param {string} reCaptchaToken
+     * @param {string} source request source
+     */
+    async updateProfile(form, reCaptchaToken, source) {
+        const { api } = this.comoData;
+        try {
+            const data = await api.updateProfile(form, reCaptchaToken, source);
+            return data;
+        } catch (error) {
+            if (error.response && error.response.data) {
+                const { code, message } = error.response.data;
+                throw new Error(code || message);
+            }
+            throw error;
+        }
+    }
+
+    /**
+     *
+     * @param {string} verificationCode code verification sent by 3rd party
+     * @param {string} type verification type
+     * @param {Object} form update form values
+     * @param {string} reCaptchaToken
+     * @param {string} source request source
+     */
+    async updateProfileVerify(verificationCode, type, form, reCaptchaToken, source) {
+        const { api } = this.comoData;
+        try {
+            const data = await api.updateProfileVerify(verificationCode, type, form, reCaptchaToken, source);
+            return data;
+        } catch (error) {
+            if (error.response && error.response.data) {
+                const { code, message } = error.response.data;
+                throw new Error(code || message);
+            }
+            throw error;
+        }
+    }
+
+    /**
+     *
+     * @param {string} unsubscribeSms unsubscribe user at location
+     * @param {string} PhoneNumber phone number to identify user
+     */
+    async unsubscribeSms(PhoneNumber) {
+        const { api, locationId } = this.comoData;
+        try {
+            const identifier = { PhoneNumber };
+            const data = await api.unsubscribeSms(locationId, identifier);
+            return data;
+        } catch (error) {
+            if (error.response && error.response.data) {
+                const { code, message } = error.response.data;
+                throw new Error(code || message);
+            }
+            throw error;
+        }
+    }
+
+    /**
+     *
+     * @param {Object} identifier an object which identifies the user by its credentials
+     * @param {string} type login type i.e PhoneNumber/Email/etc
+     */
+    async login(identifier, type) {
+        const { api } = this.comoData;
+        try {
+            const data = await api.logIn(type, identifier);
+            return data;
+        } catch (error) {
+            if (error.response && error.response.data) {
+                const { code, message } = error.response.data;
+                throw new Error(code || message);
+            }
+            throw error;
+        }
+    }
+
+    /**
+     *
+     * @param {Object} identifier key-value identifiers
+     * @param {*} type login type i.e PhoneNumber/Email/etc
+     * @param {*} code a 2-factor verification code sent to the client
+     */
+    async loginVerify(identifier, type, code) {
+        const { api } = this.comoData;
+        try {
+            const { consent } = await api.logInVerify(code, type, identifier);
+            this.comoData.consent = consent;
+        } catch (error) {
+            if (error.response && error.response.data) {
+                const { code: errCode, message } = error.response.data;
+                if (message && message === 'Invalid verification Code') {
+                    throw new Error(message);
+                }
+                throw new Error(errCode || message);
+            }
+            throw error;
+        }
+
+        return this.getCredentials();
+    }
+
+    /**
+     * Reload and sets the internal membership state.
+     * To get the reloaded membership make sure to call getMembership();
+     * @param onlyAssetKeys - include assets list full data or only the asset keys
+     * @returns {Promise<void>}
+     */
+    async reloadMembership(onlyAssetKeys = false) {
+        const {
+            env_params: env, locationId, api,
+        } = this.comoData;
+        const membership = await api.getUserAtLocation(env.zapp_root, locationId, onlyAssetKeys);
+        this.comoData.membership = membership;
+    }
+
+    /**
+     * Send an Open app request to update server.
+     */
+    async openApp(data) {
+        const {
+            api, locationId, token, env_params: env,
+        } = this.comoData;
+
+        return api.openApp(env.zapp_root, token, locationId, data);
+    }
+
+    /**
+     * Update membership status (permissions).
+     * @param {boolean} pushEnable
+     * @param {boolean} locationEnable
+     */
+    async clientUpdateMembership(pushEnable, locationEnable) {
+        const {
+            api, locationId, token, env_params: env,
+        } = this.comoData;
+
+        return api.clientUpdateMembership(env.services_root, token, locationId, pushEnable, locationEnable);
+    }
+
+    /**
+     * Downloads the main resource by its id and sets the resource in the main resource's map.
+     * @param {string} resourceId Main resource id
+     */
+
+    async downloadMainResource(resourceId) {
+        const resource = this.comoData.mainResourcesMap[resourceId];
+        if (!resource) {
+            const err = `resource ${resourceId} not found!`;
+            throw new Error(err);
+        }
+
+        const { env_params: env, api } = this.comoData;
+        const responseJson = await api.getLoyaltyResource(
+            env.services_root_cdn,
+            resource.id,
+            ('Namespace' in resource) ? resource.Namespace : `location_${this.comoData.locationId}`,
+            resource.Version,
+        );
+
+        this.comoData.mainResources[resourceId] = responseJson;
+    }
+
+
+    /**
+     * Reload and sets the internal location state.
+     * To get the reloaded location state make sure to call getLocationState();
+     */
+    async reloadLocationState() {
+        const { api } = this.comoData;
+        const state = await api.getLocationState(this.comoData.env_params.zapp_root, this.comoData.locationId);
+        this.comoData.locationState = state;
+        const mainResources = state.MainResources.Resource;
+
+        this.comoData.mainResourcesMap = mainResources.reduce((total, obj) => {
+            total[obj.id] = obj; // eslint-disable-line no-param-reassign
+            return total;
+        }, {});
+    }
+
+    /**
+     * Requests an app client id by the user's location id.
+     */
+    async getAppClientID() {
+        const {
+            env_params: env, locationId, api,
+        } = this.comoData;
+        const responseJson = await api.getShortUserId(env.zapp_root, locationId);
+        return responseJson.ID;
+    }
+
+    /**
+     * Requests a generated payment code from the loyalty server
+     */
+    async getPaymentCode() {
+        const {
+            env_params: env, locationId, api,
+        } = this.comoData;
+        const responseJson = await api.getPaymentCode(env.zapp_root, locationId);
+        return responseJson.VerificationCode;
+    }
+
+    /**
+     * Logout the user identified by its accessToken
+     */
+    async logout() {
+        const { api } = this.comoData;
+        try {
+            const response = await api.logOut();
+            return response;
+        } catch (error) {
+            if (error.response && error.response.data) {
+                const { code: errCode, message } = error.response.data;
+                throw new Error(errCode || message);
+            }
+            throw error;
+        }
+    }
+
+    /**
+     *
+     * @param {string} assetKey asset's id
+     */
+    async redeemAsset(assetKey) {
+        const {
+            env_params: env, locationId, api,
+        } = this.comoData;
+        const responseJson = await api.redeemAsset(env.zapp_root, locationId, assetKey);
+        return responseJson;
+    }
+
+    /**
+     *
+     * @param {string} itemId item's id
+     */
+    async purchaseAsset(itemId) {
+        const {
+            env_params: env, token, locationId, api,
+        } = this.comoData;
+        const responseJson = await api.purchaseAsset(env.zapp_root, locationId, token, itemId);
+        return responseJson;
+    }
+
+    async getUserPointShopDataAPI2() {
+        const {
+            env_params: env, locationId, api,
+        } = this.comoData;
+        const responseJson = await api.getUserPointShopDataAPI2(env.zapp_root, locationId);
+        return responseJson;
+    }
+
+
+    async purchaseAssetAPI2(assetID) {
+        const {
+            env_params: env, locationId, api,
+        } = this.comoData;
+        const responseJson = await api.purchaseAssetAPI2(env.zapp_root, locationId, assetID);
+        return responseJson;
+    }
+
+    /**
+     * Reload and sets the internal assets (expired and valid) state.
+     * To get the reloaded assets make sure to call como.getAssets();
+     */
+    async reloadAssets() {
+        const {
+            env_params: env, locationId, api,
+        } = this.comoData;
+        const responseJson = await api.memberAssets(env.services_root, locationId);
+        this.comoData.assets = responseJson;
+    }
+
+    /**
+     * Merge the default app text with the location specific app texts
+     * Both DefaultAppTexts and AppTexts are a MainResource that needs to be downloaded before merge
+     */
+    mergeTexts() {
+        if (this.comoData.mainResources.AppTexts && this.comoData.mainResources.DefaultAppTexts) {
+            this.comoData.app_texts = this.comoData.mainResources.DefaultAppTexts;
+            Object.keys(this.comoData.mainResources.AppTexts).forEach(key => {
+                this.comoData.app_texts[key] = this.comoData.mainResources.AppTexts[key];
+            });
+        }
+    }
+
+    /**
+     *
+     * @param {string} key app text key
+     */
+    getTextForKey(key) { return this.comoData.app_texts[key]; }
+
+    /**
+     * Downloads the main resources:
+     * - LocationData
+     * - Menu
+     * - Updates
+     * - TCAlts
+     * - AppTexts
+     * - DefaultAppTexts
+     */
+    async downloadMainResources() {
+        const resources = [
+            'LocationData',
+            'Menu',
+            'Updates',
+            'TCAlts',
+            'AppTexts',
+            'DefaultAppTexts',
+        ];
+        const downloadMainResource = this.downloadMainResource.bind(this);
+        const downloads = resources.map(downloadMainResource);
+        await Promise.all(downloads);
+        this.mergeTexts();
+    }
+
+    /**
+     *
+     * @param {string} type form type
+     */
+    loadForm(type) {
+        const { api, locationId } = this.comoData;
+
+        return api.getForm(type, locationId);
+    }
+
+    /**
+     *
+     * @param {string} type configuration type
+     */
+    getConfigration(type) {
+        const { api, locationId } = this.comoData;
+        const locationState = this.getLocationState();
+        let version = null;
+        if (locationState) {
+            version = locationState.PublishVersion;
+        }
+
+        return api.getConfiguration(type, locationId, version);
+    }
+
+    /**
+     *
+     * @param {string} type resource type
+     */
+    getResource(type) {
+        const { api, locationId } = this.comoData;
+        return api.getResource(type, locationId);
+    }
+
+    /**
+     *
+     * Get all legacy resources (Zapp)
+     */
+    getLegacyResources() {
+        const { api, locationId } = this.comoData;
+        return api.getZappResource(locationId);
+    }
+
+    /**
+     * Generates a new referral code for friend-referral
+     */
+    generateReferralCode() {
+        const {
+            api, locationId, token, env_params: env,
+        } = this.comoData;
+
+        return api.generateReferralCode(env.services_root, token, locationId);
+    }
+
+    /**
+     * Check that referral code is valid
+     */
+    verifyReferralCode(code) {
+        const {
+            api, locationId, token, env_params: env,
+        } = this.comoData;
+
+        return api.verifyReferralCode(env.services_root, token, locationId, code);
+    }
+
+    /**
+     * Returns current accessToken and refreshToken
+     * Caution: make sure to pass refresh callback to init to get the latest credentials
+     */
+    getCredentials() {
+        const {
+            accessToken, refreshToken, expiresIn, consent,
+        } = this.comoData;
+        return {
+            accessToken, refreshToken, expiresIn, consent,
+        };
+    }
+
+    /**
+     * Returns the current accessToken
+     * Caution: make sure to pass refresh callback to como.init to get the latest credentials
+     */
+    getToken() { return this.comoData.token; }
+
+    /**
+     * Returns the como.js initialized installation id
+     */
+    getInstallationId() { return this.comoData.installationId; }
+
+    /**
+     * Return the user membership object
+     * Make sure to call reloadMembership() to reload the membership object.
+     */
+    getMembership() { return this.comoData.membership; }
+
+    /**
+     * Return the user assets object
+     * Make sure to call reloadAssets() to reload the assets object.
+     */
+    getAssets() { return this.comoData.assets; }
+
+    /**
+     * Returns the location specific registration web url
+     */
+    async getRegistrationUrl(overrides) {
+        await this.refreshTokenIfNeeded();
+        const {
+            token, installationId, locationId, env_params: env,
+        } = this.comoData;
+
+        return urlsUtils.appendQuery(
+            `${env.app_modules_root}/register?token=${token}&locationid=${locationId}`,
+            {
+                ...this.getCredentials(),
+                installationId,
+                disableSuccessScreen: 'true',
+                ...overrides,
+            },
+        );
+    }
+
+    /**
+     * Returns the location specific profile web url
+     */
+    async getProfileUrl(overrides) {
+        await this.refreshTokenIfNeeded();
+        const {
+            token, installationId, locationId, env_params: env,
+        } = this.comoData;
+
+        return urlsUtils.appendQuery(
+            `${env.app_modules_root}/profile?token=${token}&locationid=${locationId}`,
+            {
+                ...this.getCredentials(),
+                installationId,
+                disableSuccessScreen: 'true',
+                ...overrides,
+            },
+        );
+    }
+
+    /**
+     * Returns the location specific login web url
+     */
+    async getLoginUrl() {
+        await this.refreshTokenIfNeeded();
+        const { token, locationId, env_params: env } = this.comoData;
+        return `${env.app_modules_root}/login?token=${token}&locationid=${locationId}`;
+    }
+
+     /**
+     * Returns the location data Portability url
+     */
+    async getDataPortabilityUrl(url, overrides) {
+        await this.refreshTokenIfNeeded();
+        const {
+            installationId,
+        } = this.comoData;
+
+        return urlsUtils.appendQuery(
+            `${url}`,
+            {
+                installationId,
+                ...overrides,
+            },
+        );
+    }
+
+    /**
+     * Returns app-modules legacy root url
+     */
+    async getAppModulesLegacyBaseUrl() {
+        await this.refreshTokenIfNeeded();
+        const { env_params: env } = this.comoData;
+        return `${env.app_modules_legacy_root}`;
+    }
+
+    /**
+     * Returns the location specific friend referral web url
+     */
+    getFriendReferralInviteLink(referral) { return `${this.comoData.env_params.gateway}/ssr-modules/friend-referral/${this.comoData.locationId}?referral=${referral}`; }
+
+    /**
+     * Return the location state
+     * Make sure to call reloadLocationState() to reload the location state object.
+     */
+    getLocationState() { return this.comoData.locationState; }
+
+    /**
+     * Returns the location point shop items
+     */
+    getPointShopItems() { return this.comoData.mainResources.menu.gifts_shop_item; }
+
+    /**
+     *
+     * @param {string} resourceName resource name
+     */
+    getMainResource(resourceName) { return this.comoData.mainResources[resourceName]; }
+
+    /**
+     *
+     * @param {string} resourceId resource id
+     * @param {string} namespace resource namespace
+     * @param {string|number} version resource version
+     */
+    getResourceUrl(resourceId, namespace, version) {
+        const { api, env_params: env } = this.comoData;
+        return api.getResourceUrl(env.services_root_cdn, resourceId, namespace, version);
+    }
+
+    getCdnUrl() {
+        return this.comoData.env_params.services_root_cdn;
+    }
+
+    /**
+     * @param {string} identifier fcm token created by firebase
+     * @param {boolean} isFirebaseProjectMigrated is migrated to new firebase project
+     */
+    sendPushChannel(identifier, isFirebaseProjectMigrated = false) {
+        const {
+            api, locationId, token, env_params: env,
+        } = this.comoData;
+        return api.sendPushChannel(env.services_root, locationId, token, identifier, isFirebaseProjectMigrated);
+    }
+
+    async getRegionConfig() {
+        const {
+            api, locationId, token, env_params: env,
+        } = this.comoData;
+        return api.getClientBusinessBackend(env.zapp_root, token, locationId);
+    }
+
+    /**
+     * @param {string} code coupon code entered by user on App
+     */
+    sendCouponCode(code) {
+        const {
+            api, locationId, token, env_params: env,
+        } = this.comoData;
+        return api.sendCouponCode(env.zapp_root, locationId, token, code);
+    }
+
+    async addPaymentMethod(cardToken) {
+        const {
+            api, locationId, token, env_params: env,
+        } = this.comoData;
+        return api.addPaymentMethod(env.services_root, locationId, token, cardToken);
+    }
+
+    async knowYourData(email) {
+        const {
+            api, locationId, token, env_params: env,
+        } = this.comoData;
+        return api.knowYourData(env.services_root, locationId, token, email);
+    }
+
+    async consentWithdraw(consentData) {
+        const {
+            api, locationId, token, env_params: env,
+        } = this.comoData;
+        return api.consentWithdraw(env.services_root, locationId, token, consentData);
+    }
+
+    async getPaymentMethods() {
+        const {
+            env_params: env, locationId, api,
+        } = this.comoData;
+        const responseJson = await api.getPaymentMethods(env.services_root, locationId);
+        return responseJson;
+    }
+
+    /**
+     * @param {Integer} amount to charge
+     * @param {String} creditCardToken to charge from
+     * @param {String} itemName for submit purchase
+     * @param {String} itemNumber for submit purchase
+     * @param {String} membershipKey for user identification
+     */
+    async payInApp(amount, creditCardToken, itemName, itemNumber, membershipKey) {
+        const {
+            env_params: env, token, locationId, api,
+        } = this.comoData;
+        const responseJson = await api.payInApp(env.services_root, locationId, token, amount, creditCardToken, itemName, itemNumber, membershipKey);
+        return responseJson;
+    }
+
+    /**
+     * @param {string} creditCardToken which card to delete
+     */
+    async deletePayment(creditCardToken) {
+        const {
+            env_params: env, token, locationId, api,
+        } = this.comoData;
+        const responseJson = await api.deletePayment(env.services_root, locationId, token, creditCardToken);
+        return responseJson;
+    }
+    /**
+     * @param {string} tag for Pop-up Message Trigger (Optional param)
+     */
+    getMemberMessages(tag, limit, offset) {
+        const {
+            api, locationId, env_params: env,
+        } = this.comoData;
+        return api.getMemberMessages(env.services_root, locationId, tag, limit, offset);
+    }
+
+    /**
+     * @param {string} keysList keys of the messages to mark as read
+     */
+    markAsReadMemberMessages(keysList) {
+        const {
+            api, locationId, env_params: env,
+        } = this.comoData;
+        return api.markAsReadMemberMessages(env.services_root, locationId, keysList);
+    }
+
+    /**
+     * @param {String} receiver to share with
+     * @param {String} sender name
+     * @param {Integer} amount to share
+     * @param {String} type of wallet
+     */
+    async budgetTransfer(receiver, sender, amount, wallet) {
+        const {
+            api, locationId, env_params: env,
+        } = this.comoData;
+        return api.budgetTransfer(env.services_root, locationId, receiver, sender, amount, wallet);
+    }
+
+    /**
+     * @param {string} claimId key of the credit claim to read the data for
+     */
+    getCreditClaimData(claimId) {
+        const {
+            api, env_params: env,
+        } = this.comoData;
+        return api.getCreditClaimData(env.services_root, claimId);
+    }
+
+
+    /**
+     * @param {String} claimCode to use for budget transfer claim
+     */
+    async budgetTransferClaim(claimCode) {
+        const {
+            api, locationId, env_params: env,
+        } = this.comoData;
+        return api.budgetTransferClaim(env.services_root, locationId, claimCode);
+    }
+
+    /**
+     * API call for claim generic action. To specify your trigger button, you need to associate it with a particular item, asset or tag.
+     * @param {string} assetKey - asset to claim
+     * @param {string} itemId - item id to claim
+     * @param {string} tag - claim all with tag
+     */
+    claim(assetKey, itemId, tag) {
+        const {
+            env_params: env, locationId, api, token,
+        } = this.comoData;
+        return api.claim(env.zapp_root, locationId, token, assetKey, itemId, tag);
+    }
+
+    /**
+     * Log user action
+     * @param {string} action
+     * @param {string} logData - log information
+     */
+    async logUserAction(action, logData) {
+        const {
+            env_params: env, locationId, api, token,
+        } = this.comoData;
+        return api.logUserAction(env.zapp_root, locationId, token, action, logData);
+    }
+
+    /**
+     * Member purchase history
+     * @param {string} limit - how manay items to return (if exists) -  default value is 25
+     * @param {string} offset - default value is 0(next offset would be 25)
+     */
+    async getPurchaseHistory(limit, offset) {
+        const {
+            locationId, api, membership
+        } = this.comoData;
+        return api.getPurchaseHistory(locationId, membership.Key, limit, offset);
+    }
+}
+
+module.exports = Como;