@como/como-client 0.1.292 → 0.1.991

package/src/como.js

@@ -6,8 +6,6 @@ const comoExternalUrlTranslator = require('./utils/comoExternalUrlTranslator');
 const resourceNames = require('./constants/resourceNames');
 const urlsUtils = require('./utils/urls');
 
-const como = {};
-let comoData;
 const INITIAL_COMO_DATA = {
     env: environmentConfig,
     token: null,
@@ -16,801 +14,927 @@ const INITIAL_COMO_DATA = {
     installationId: null,
     membership: null,
     assets: null,
-    archivedAssets: null,
-    redeemedAssets: null,
     mainResources: {},
 };
 
-const refreshTokenIfNeeded = async () => {
-    const { refresher, expiresIn } = comoData;
-    if (expiresIn && moment(expiresIn).subtract(10, 'seconds').isBefore(moment())) {
-        await refresher();
+class Como {
+    constructor() {
+        this.comoData = {};
     }
-};
 
-/**
- * Sign the user and returns guest token & refresh token.
- * Requires init.
- */
-como.signon = async () => {
-    const { api } = comoData;
-    try {
-        const data = await api.signOn(comoData.installationId, comoData.locationId);
-        return data;
-    } catch (error) {
-        if (error.response && error.response.data) {
-            const { code, message } = error.response.data;
-            throw new Error(code || message);
+    async refreshTokenIfNeeded() {
+        const { refresher, expiresIn } = this.comoData;
+        if(!refresher){
+            console.log('No refresh for %o', this.comoData);
+        }
+        else if (expiresIn && moment(expiresIn).subtract(10, 'seconds').isBefore(moment())) {
+            await refresher();
         }
-        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.
- */
-como.init = async (environment, credentials, refreshCallback, enableSignon = true) => {
-    const isExists = (x => !ramda.isNil(x) && !ramda.isEmpty(x));
-    const { id: environmentId, locationId, installationId } = environment;
-    if (!isExists(environmentId) || !isExists(locationId) || !isExists(installationId)) {
-        throw new Error('missing parameters');
-    }
-
-    comoData = {
-        ...INITIAL_COMO_DATA,
-        ...credentials,
-        installationId,
-        locationId,
-        env_params: {
-            ...INITIAL_COMO_DATA.env[environmentId],
-        },
-    };
-
-    const updateCredentials = (creds, isNew = false) => {
-        como.updateLocalCreds(creds);
-        if (refreshCallback && isNew) {
-            refreshCallback(creds);
+
+    /**
+     * Sign the user and returns guest token & refresh token.
+     * Requires init.
+     */
+    // async signon(source) {
+    //     const { InitApi: 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}`);
         }
-    };
 
-    const { gateway } = comoData.env_params;
-    const { service, refresher } = APIService
-        .getService(gateway, installationId, como.getCredentials, updateCredentials);
-    comoData.api = service;
-    comoData.refresher = refresher;
+        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, initService } = APIService
+            .getService(gateway, installationId, getCredentials, updateCredentials);
+        this.comoData.api = service;
+        this.comoData.initApi = initService;
+        this.comoData.refresher = refresher;
+
+        const { accessToken, refreshToken, expiresIn } = credentials;
+        let credExist = isExists(accessToken) && isExists(refreshToken);
+        let isExpired = credExist && expiresIn && moment(expiresIn).isBefore(moment());
+        let refreshFailed = false;
+        if(isExpired){
+            try{
+                const data = await this.comoData.initApi.refreshToken(installationId, refreshToken?  refreshToken: 'none', locationId, source);
+                updateCredentials(data, true);
+            }catch(e){
+                console.log(`Failed to refresh token, installationId:${installationId}, refreshToken:${this.comoData.refreshToken}, locationId:${locationId}, source:${source}`);
+                //refresh failed - need to revoke and signOn again
+                initService.logError({method: 'refreshToken', installationId, locationId, source, refreshToken});
+                refreshFailed = true;
+            }
+        }
+        let interval = 0;
+        if(refreshFailed || !credExist){
+            while(!credExist && interval < 3000){
+                try{
+                    const data = await this.comoData.initApi.signOn(installationId, locationId, refreshToken, source);
+                    updateCredentials(data, true);
+                    credExist = true;
+                }catch(e){
+                    console.log(`Failed to signOn, installationId:${installationId}, locationId:${locationId}, source:${source}`);
+                    initService.logError({method: 'signOn', installationId, locationId, source, refreshToken, interval});
+
+                    interval += 1000;
+                    setTimeout(() => {
+                        console.log(`waking for another try of signOn, interval: ${interval}, installationId:${installationId}, locationId:${locationId}, source:${source}`);
+                        initService.logError({method: 'signOn', installationId, locationId, source, refreshToken, interval});
+                    }, interval);
+                }
+            }
+        }
 
-    const { accessToken, refreshToken, expiresIn } = credentials;
-    const credsNotExist = !isExists(accessToken) || !isExists(refreshToken);
-    const isExpired = expiresIn && moment(expiresIn).isBefore(moment());
-    if (enableSignon && (credsNotExist || isExpired)) {
-        await como.signon();
+        return this.getCredentials();
     }
 
-    return como.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;
+    }
 
-/**
- * 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.
- */
-como.updateLocalCreds = (credentials = {}) => {
-    comoData.accessToken = credentials.accessToken;
-    comoData.token = credentials.accessToken;
-    comoData.refreshToken = credentials.refreshToken;
-    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;
+    }
 
-como.getExternalUrlByID = (itemID, gpsData, assetID, accessibilityData) => {
-    const locationData = 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 como.translateExternalUrl(url, gpsData, assetID, accessibilityData);
+    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);
     }
-    return null;
-};
 
-como.translateExternalUrl = async (url, gpsData, assetID, accessibilityData) => {
-    const legacyUrl = await como.getAppModulesLegacyBaseUrl();
-    let externalUrl = url;
-    if (externalUrl && externalUrl.startsWith(legacyUrl)) {
-        externalUrl = externalUrl.replace(legacyUrl, comoData.env_params.app_modules_root);
-    }
-    const {
-        api, locationId, token, env_params: env, membership, assets,
-    } = comoData;
-    const locationData = comoData.mainResources && 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);
+    }
 
-como.getFeedbackFormData = async () => {
-    const {
-        locationId, token, env_params: env, api,
-    } = comoData;
-    return api.getFeedbackFormData(env.zapp_root, locationId, token);
-};
+    /**
+     *
+     * @param {Object} form registration form values
+     * @param {Object} verification flow
+     * @param {string} 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 {Object} form registration form values
- */
-como.register = async form => {
-    const { api } = comoData;
-    try {
-        const data = await api.register(form);
-        return data;
-    } catch (error) {
-        if (error.response && error.response.data) {
-            const { code, message } = error.response.data;
-            throw new Error(code || message);
+    /**
+     *
+     * @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;
         }
-        throw error;
     }
-};
 
-/**
- *
- * @param {string} verificationCode code verification sent by 3rd party
- * @param {string} type verification type
- * @param {Object} form registration form values
- */
-como.registerVerify = async (verificationCode, type, form) => {
-    const { api } = comoData;
-    try {
-        const data = await api.registerVerify(verificationCode, type, form);
-        return data;
-    } catch (error) {
-        if (error.response && error.response.data) {
-            const { code, message } = error.response.data;
-            throw new Error(code || message);
+    /**
+     *
+     * @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;
         }
-        throw error;
     }
-};
 
-/**
- *
- * @param {Object} form update form values
- */
-como.updateProfile = async form => {
-    const { api } = comoData;
-    try {
-        const data = await api.updateProfile(form);
-        return data;
-    } catch (error) {
-        if (error.response && error.response.data) {
-            const { code, message } = error.response.data;
-            throw new Error(code || message);
+    /**
+     *
+     * @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;
         }
-        throw error;
     }
-};
 
-/**
- *
- * @param {string} verificationCode code verification sent by 3rd party
- * @param {string} type verification type
- * @param {Object} form update form values
- */
-como.updateProfileVerify = async (verificationCode, type, form) => {
-    const { api } = comoData;
-    try {
-        const data = await api.updateProfileVerify(verificationCode, type, form);
-        return data;
-    } catch (error) {
-        if (error.response && error.response.data) {
-            const { code, message } = error.response.data;
-            throw new Error(code || message);
+    /**
+     *
+     * @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;
         }
-        throw error;
     }
-};
 
-/**
- *
- * @param {Object} identifier an object which identifies the user by its credentials
- * @param {string} type login type i.e PhoneNumber/Email/etc
- */
-como.login = async (identifier, type) => {
-    const { api } = 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);
+    /**
+     *
+     * @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;
         }
-        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
- */
-como.loginVerify = async (identifier, type, code) => {
-    const { api } = comoData;
-    try {
-        const { consent } = await api.logInVerify(code, type, identifier);
-        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);
+    /**
+     *
+     * @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 new Error(errCode || message);
+            throw error;
         }
-        throw error;
+
+        return this.getCredentials();
     }
 
-    return como.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;
+    }
 
-/**
- * Reload and sets the internal membership state.
- * To get the reloaded membership make sure to call como.getMembership();
- * @param onlyAssetKeys - include assets list full data or only the asset keys
- * @returns {Promise<void>}
- */
-como.reloadMembership = async (onlyAssetKeys = false) => {
-    const {
-        env_params: env, locationId, api,
-    } = comoData;
-    const membership = await api.getUserAtLocation(env.zapp_root, locationId, onlyAssetKeys);
-    comoData.membership = membership;
-};
+    /**
+     * Send an Open app request to update server.
+     */
+    async openApp(data) {
+        const {
+            api, locationId, token, env_params: env,
+        } = this.comoData;
 
-/**
- * Send an Open app request to update server.
- */
-como.openApp = async data => {
-    const {
-        api, locationId, token, env_params: env,
-    } = comoData;
+        return api.openApp(env.zapp_root, token, locationId, data);
+    }
 
-    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);
+    }
 
-/**
- * Update membership status (permissions).
- * @param {boolean} pushEnable
- * @param {boolean} locationEnable
- */
-como.clientUpdateMembership = async (pushEnable, locationEnable) => {
-    const {
-        api, locationId, token, env_params: env,
-    } = 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
+     */
 
-/**
- * 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,
+        );
 
-como.downloadMainResource = async resourceId => {
-    const resource = comoData.mainResourcesMap[resourceId];
-    if (!resource) {
-        const err = `resource ${resourceId} not found!`;
-        throw new Error(err);
+        this.comoData.mainResources[resourceId] = responseJson;
     }
 
-    const { env_params: env, api } = comoData;
-    const responseJson = await api.getLoyaltyResource(
-        env.services_root_temp,
-        resource.id,
-        ('Namespace' in resource) ? resource.Namespace : `location_${comoData.locationId}`,
-        resource.Version,
-    );
 
-    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;
+    }
 
-/**
- * Reload and sets the internal location state.
- * To get the reloaded location state make sure to call como.getLocationState();
- */
-como.reloadLocationState = async () => {
-    const { api } = comoData;
-    const state = await api.getLocationState(comoData.env_params.zapp_root, comoData.locationId);
-    comoData.locationState = state;
-    const mainResources = state.MainResources.Resource;
-
-    comoData.mainResourcesMap = mainResources.reduce((total, obj) => {
-        total[obj.id] = obj; // eslint-disable-line no-param-reassign
-        return total;
-    }, {});
-};
+    /**
+     * 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;
+    }
 
-/**
- * Requests an app client id by the user's location id.
- */
-como.getAppClientID = async () => {
-    const {
-        env_params: env, locationId, api,
-    } = comoData;
-    const responseJson = await api.getShortUserId(env.zapp_root, locationId);
-    return responseJson.ID;
-};
+    /**
+     * 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;
+        }
+    }
 
-/**
- * Requests a generated payment code from the loyalty server
- */
-como.getPaymentCode = async () => {
-    const {
-        env_params: env, locationId, api,
-    } = comoData;
-    const responseJson = await api.getPaymentCode(env.zapp_root, locationId);
-    return responseJson.VerificationCode;
-};
+    /**
+     *
+     * @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;
+    }
 
-/**
- * Logout the user identified by its accessToken
- */
-como.logout = async () => {
-    const { api } = 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);
+    /**
+     * 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];
+            });
         }
-        throw error;
     }
-};
 
-/**
- *
- * @param {string} assetKey asset's id
- */
-como.redeemAsset = async assetKey => {
-    const {
-        env_params: env, locationId, api,
-    } = comoData;
-    const responseJson = await api.redeemAsset(env.zapp_root, locationId, assetKey);
-    return responseJson;
-};
+    /**
+     *
+     * @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} itemId item's id
- */
-como.purchaseAsset = async itemId => {
-    const {
-        env_params: env, token, locationId, api,
-    } = comoData;
-    const responseJson = await api.purchaseAsset(env.zapp_root, locationId, token, itemId);
-    return responseJson;
-};
+    /**
+     *
+     * @param {string} type form type
+     */
+    loadForm(type) {
+        const { api, locationId } = this.comoData;
 
-/**
- * Reload and sets the internal assets (expired and valid) state.
- * To get the reloaded assets make sure to call como.getAssets(); and como.getArchivedAssets();
- */
-como.reloadAssets = async () => {
-    const {
-        env_params: env, locationId, api,
-    } = comoData;
-    const responseJson = await api.memberAssets(env.services_root, locationId);
-
-    const assets = [];
-    const archivedAssets = [];
-    const dateNow = moment().utc();
-
-    responseJson.forEach(asset => {
-        const archived = ramda.pathOr(false, ['Archived'], asset);
-        const active = ramda.pathOr(true, ['Active'], asset);
-        const validUntil = ramda.pathOr(null, ['Data', 'ValidUntil'], asset);
-        const lastAssign = ramda.pathOr(null, ['LastAssignDate'], asset);
-        const secondsValid = ramda.pathOr(null, ['Data', 'SecondsValid'], asset);
-        const lastAssignDate = moment.utc(lastAssign, 'DD.MM.YYYY HH:mm:ss');
-        let validUntilDate = moment.utc(validUntil, 'DD/MM/YYYY HH:mm:ss');
-
-        if (!archived && active) {
-            if (secondsValid !== null) {
-                validUntilDate = lastAssignDate.clone().add(secondsValid, 'seconds');
-            }
+        return api.getForm(type, locationId);
+    }
 
-            if (validUntilDate.isBefore(dateNow)) {
-                archivedAssets.push(asset);
-            } else {
-                assets.push(asset);
-            }
-        } else {
-            archivedAssets.push(asset);
+    /**
+     *
+     * @param {string} type configuration type
+     */
+    getConfigration(type) {
+        const { api, locationId } = this.comoData;
+        const locationState = this.getLocationState();
+        let version = null;
+        if (locationState) {
+            version = locationState.PublishVersion;
         }
-    });
 
-    comoData.archivedAssets = archivedAssets;
-    comoData.assets = assets; // saperate assest from archivedAssets
-};
+        return api.getConfiguration(type, locationId, version);
+    }
 
-/**
- * Reload and sets the internal archived assets state
- * To get the reloaded assets make sure to call como.getArchivedAssets();
- */
-como.reloadArchivedAssets = async () => {
-    const {
-        env_params: env, locationId, api,
-    } = comoData;
-    const responseJson = await api.memberAssets(env.services_root, locationId, true);
-    comoData.redeemedAssets = responseJson;
-};
+    /**
+     *
+     * @param {string} type resource type
+     */
+    getResource(type) {
+        const { api, locationId } = this.comoData;
+        return api.getResource(type, locationId);
+    }
 
-/**
- * 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
- */
-como.mergeTexts = () => {
-    if (comoData.mainResources.AppTexts && comoData.mainResources.DefaultAppTexts) {
-        comoData.app_texts = comoData.mainResources.DefaultAppTexts;
-        Object.keys(comoData.mainResources.AppTexts).forEach(key => {
-            comoData.app_texts[key] = comoData.mainResources.AppTexts[key];
-        });
+    /**
+     *
+     * Get all legacy resources (Zapp)
+     */
+    getLegacyResources() {
+        const { api, locationId } = this.comoData;
+        return api.getZappResource(locationId);
     }
-};
 
-/**
- *
- * @param {string} key app text key
- */
-como.getTextForKey = key => comoData.app_texts[key];
-
-/**
- * Downloads the main resources:
- * - LocationData
- * - Menu
- * - Updates
- * - TCAlts
- * - AppTexts
- * - DefaultAppTexts
- */
-como.downloadMainResources = async () => {
-    const resources = [
-        'LocationData',
-        'Menu',
-        'Updates',
-        'TCAlts',
-        'AppTexts',
-        'DefaultAppTexts',
-    ];
-    const downloads = resources.map(como.downloadMainResource);
-    await Promise.all(downloads);
-    como.mergeTexts();
-};
+    /**
+     * Generates a new referral code for friend-referral
+     */
+    generateReferralCode() {
+        const {
+            api, locationId, token, env_params: env,
+        } = this.comoData;
 
-/**
- *
- * @param {string} type form type
- */
-como.loadForm = type => {
-    const { api, locationId } = comoData;
+        return api.generateReferralCode(env.services_root, token, locationId);
+    }
 
-    return api.getForm(type, locationId);
-};
+    /**
+     * Check that referral code is valid
+     */
+    verifyReferralCode(code) {
+        const {
+            api, locationId, token, env_params: env,
+        } = this.comoData;
 
-/**
- *
- * @param {string} type configuration type
- */
-como.getConfigration = type => {
-    const { api, locationId } = comoData;
-    const { PublishVersion: version } = como.getLocationState();
+        return api.verifyReferralCode(env.services_root, token, locationId, code);
+    }
 
-    return api.getConfiguration(type, locationId, version);
-};
+    /**
+     * 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, locationId
+        } = this.comoData;
+        return {
+            accessToken, refreshToken, expiresIn, consent, locationId
+        };
+    }
 
-/**
- *
- * @param {string} type resource type
- */
-como.getResource = type => {
-    const { api, locationId } = comoData;
-    return api.getResource(type, locationId);
-};
+    /**
+     * 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,
+            },
+        );
+    }
 
-/**
- * Generates a new referral code for friend-referral
- */
-como.generateReferralCode = () => {
-    const {
-        api, locationId, token, env_params: env,
-    } = comoData;
+    /**
+     * 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,
+            },
+        );
+    }
 
-    return api.generateReferralCode(env.services_root, token, locationId);
-};
+    /**
+     * 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 current accessToken and refreshToken
- * Caution: make sure to pass refresh callback to como.init to get the latest credentials
- */
-como.getCredentials = () => ({
-    accessToken: comoData.accessToken,
-    refreshToken: comoData.refreshToken,
-    expiresIn: comoData.expiresIn,
-    consent: comoData.consent,
-});
-
-/**
- * Returns the current accessToken
- * Caution: make sure to pass refresh callback to como.init to get the latest credentials
- */
-como.getToken = () => comoData.token;
-
-/**
- * Returns the como.js initialized installation id
- */
-como.getInstallationId = () => comoData.installationId;
-
-/**
- * Return the user membership object
- * Make sure to call reloadMembership() to reload the membership object.
- */
-como.getMembership = () => comoData.membership;
-
-/**
- * Return the user assets object
- * Make sure to call reloadAssets() to reload the assets object.
- */
-como.getAssets = () => comoData.assets;
-
-/**
- * Return the user archived and expired assets object
- * Make sure to call reloadAssets() and reloadArchivedAssets() to reload the archived assets object.
- */
-como.getArchivedAssets = () => (comoData.archivedAssets || []).concat(comoData.redeemedAssets);
-
-/**
- * Returns the location specific registration web url
- */
-como.getRegistrationUrl = async overrides => {
-    await refreshTokenIfNeeded();
-    const {
-        token, installationId, locationId, env_params: env,
-    } = comoData;
-
-    return urlsUtils.appendQuery(
-        `${env.app_modules_root}/register?token=${token}&locationid=${locationId}`,
-        {
-            ...como.getCredentials(),
+     /**
+     * Returns the location data Portability url
+     */
+    async getDataPortabilityUrl(url, overrides) {
+        await this.refreshTokenIfNeeded();
+        const {
             installationId,
-            disableSuccessScreen: 'true',
-            ...overrides,
-        },
-    );
-};
+        } = this.comoData;
+
+        return urlsUtils.appendQuery(
+            `${url}`,
+            {
+                installationId,
+                ...overrides,
+            },
+        );
+    }
 
-/**
- * Returns the location specific profile web url
- */
-como.getProfileUrl = async overrides => {
-    await refreshTokenIfNeeded();
-    const {
-        token, installationId, locationId, env_params: env,
-    } = comoData;
-
-    return urlsUtils.appendQuery(
-        `${env.app_modules_root}/profile?token=${token}&locationid=${locationId}`,
-        {
-            ...como.getCredentials(),
-            installationId,
-            disableSuccessScreen: 'true',
-            ...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 login web url
- */
-como.getLoginUrl = async () => {
-    await refreshTokenIfNeeded();
-    const { token, locationId, env_params: env } = comoData;
-    return `${env.app_modules_root}/login?token=${token}&locationid=${locationId}`;
-};
+    /**
+     * 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);
+    }
 
-/**
- * Returns app-modules legacy root url
- */
-como.getAppModulesLegacyBaseUrl = async () => {
-    await refreshTokenIfNeeded();
-    const { env_params: env } = comoData;
-    return `${env.app_modules_legacy_root}`;
-};
+    getCdnUrl() {
+        return this.comoData.env_params.services_root_cdn;
+    }
 
-/**
- * Returns the location specific friend referral web url
- */
-como.getFriendReferralInviteLink = referral =>
-    `${comoData.env_params.gateway}/ssr-modules/friend-referral/${comoData.locationId}?referral=${referral}`;
-
-/**
- * Return the location state
- * Make sure to call reloadLocationState() to reload the location state object.
- */
-como.getLocationState = () => comoData.locationState;
-
-/**
- * Returns the location point shop items
- */
-como.getPointShopItems = () => comoData.mainResources.menu.gifts_shop_item;
-
-/**
- *
- * @param {string} resourceName resource name
- */
-como.getMainResource = resourceName => comoData.mainResources[resourceName];
-
-/**
- *
- * @param {string} resourceId resource id
- * @param {string} namespace resource namespace
- * @param {string|number} version resource version
- */
-como.getResourceUrl = (resourceId, namespace, version) => {
-    const { api, env_params: env } = comoData;
-    return api.getResourceUrl(env.services_root_temp, resourceId, namespace, version);
-};
+    /**
+     * @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);
+    }
 
-/**
- * @param {string} identifier fcm token created by firebase
- */
-como.sendPushChannel = identifier => {
-    const {
-        api, locationId, token, env_params: env,
-    } = comoData;
-    return api.sendPushChannel(env.services_root, locationId, token, identifier);
-};
+    async getRegionConfig() {
+        const {
+            api, locationId, token, env_params: env,
+        } = this.comoData;
+        return api.getClientBusinessBackend(env.zapp_root, token, locationId);
+    }
 
-como.getRegionConfig = async () => {
-    const {
-        api, locationId, token, env_params: env,
-    } = 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);
+    }
 
-/**
- * @param {string} code coupon code entered by user on App
- */
-como.sendCouponCode = code => {
-    const {
-        api, locationId, token, env_params: env,
-    } = 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);
+    }
 
-como.addPaymentMethod = async cardToken => {
-    const {
-        api, locationId, token, env_params: env,
-    } = 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);
+    }
 
-como.getPaymentMethods = async () => {
-    const {
-        env_params: env, locationId, api,
-    } = comoData;
-    const responseJson = await api.getPaymentMethods(env.services_root, locationId);
-    return responseJson;
-};
+    async consentWithdraw(consentData) {
+        const {
+            api, locationId, token, env_params: env,
+        } = this.comoData;
+        return api.consentWithdraw(env.services_root, locationId, token, consentData);
+    }
 
-/**
- * @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
- */
-como.payInApp = async (amount, creditCardToken, itemName, itemNumber, membershipKey) => {
-    const {
-        env_params: env, token, locationId, api,
-    } = comoData;
-    const responseJson = await api.payInApp(env.services_root, locationId, token, amount, creditCardToken, itemName, itemNumber, membershipKey);
-    return responseJson;
-};
+    async getPaymentMethods() {
+        const {
+            env_params: env, locationId, api,
+        } = this.comoData;
+        const responseJson = await api.getPaymentMethods(env.services_root, locationId);
+        return responseJson;
+    }
 
-/**
- * @param {string} creditCardToken which card to delete
- */
-como.deletePayment = async creditCardToken => {
-    const {
-        env_params: env, token, locationId, api,
-    } = comoData;
-    const responseJson = await api.deletePayment(env.services_root, locationId, token, creditCardToken);
-    return responseJson;
-};
-/**
- * @param {string} tag for Pop-up Message Trigger (Optional param)
- */
-como.getMemberMessages = (tag, limit, offset) => {
-    const {
-        api, locationId, env_params: env,
-    } = comoData;
-    return api.getMemberMessages(env.services_root, locationId, tag, limit, offset);
-};
+    /**
+     * @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} keysList keys of the messages to mark as read
- */
-como.markAsReadMemberMessages = keysList => {
-    const {
-        api, locationId, env_params: env,
-    } = comoData;
-    return api.markAsReadMemberMessages(env.services_root, locationId, keysList);
-};
+    /**
+     * @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} receiver to share with
- * @param {String} sender name
- * @param {Integer} amount to share
- * @param {String} type of wallet
- */
-como.budgetTransfer = async (receiver, sender, amount, wallet) => {
-    const {
-        api, locationId, env_params: env,
-    } = comoData;
-    return api.budgetTransfer(env.services_root, locationId, receiver, sender, amount, wallet);
-};
+    /**
+     * @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} claimId key of the credit claim to read the data for
- */
-como.getCreditClaimData = claimId => {
-    const {
-        api, env_params: env,
-    } = comoData;
-    return api.getCreditClaimData(env.services_root, claimId);
-};
+    /**
+     * @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
- */
-como.budgetTransferClaim = async (claimCode) => {
-    const {
-        api, locationId, env_params: env,
-    } = 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
- */
-como.claim = (assetKey, itemId, tag) => {
-    const {
-        env_params: env, locationId, api, token,
-    } = comoData;
-    return api.claim(env.zapp_root, locationId, token, assetKey, itemId, tag);
-};
+    /**
+     * @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;
+module.exports = Como;