@crmcom/self-service-sdk 2.1.2

package/contacts.js

@@ -0,0 +1,1109 @@
+import { httpUtil } from "./httpUtil";
+import { ErrorCodes, createResult, createCommonResult } from "./resultUtil";
+import { account } from "./account";
+import { logger } from './logger';
+
+export const contacts = {
+    getContact,
+    updateContact,
+    setMarketingPreferences,
+    submitReferralCode,
+    getContactAddresses,
+    addContactAddress,
+    updateContactAddress,
+    updateContactOnboardingCards,
+    deleteContactAddress,
+    reclaimPurchase,
+    referFriend,
+    redeemPass,
+    getContactPreferredOrganisation,
+    addContactPreferredOrganisation,
+    unregisterContact,
+    signOutContact,
+    getContactPurchases,
+    getPurchase,
+    requestOTPSpend,
+    getOTPSpend,
+    onChangePassword,
+    getNameDayRules,
+    addApplicationUsage,
+    requestContactToken,
+    getContactTokens,
+    addPNDeviceToken,
+	deleteDeviceToken,
+    uploadProfileImage,
+    deleteProfileImage,
+    verifyContactExist,
+    getAndroidWalletPass,
+    getApplePass,
+    getGooglePass,
+    exportStatements,
+    getContactDonationsOffer,
+    getDonationHistory,
+    donationActions,
+    updateDonation,
+    removeDonation,
+    getDonationOffers,
+    getDonationOrganisations
+};
+async function getContact() {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.get({
+            resourcePath: "/v2/contacts/" + id,
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception getContact:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function verifyContactExist({ email_address, phone } = {}) {
+    try {
+        let response = await httpUtil.get({
+            logOutIfSessionInvalid: false,
+            resourcePath: "/v2/contacts/",
+            queryParams: {
+                email_address,
+                phone
+            }
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception getContact:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function getContactAddresses() {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.get({
+            resourcePath: "/v2/contacts/" + id + "/addresses",
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception getContactAddresses:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function addContactAddress({
+    type,
+    name,
+    is_primary,
+    address_line_1,
+    address_line_2,
+    state_province_county,
+    town_city,
+    postal_code,
+    country_code,
+    lat,
+    lon,
+    google_place_id
+} = {}) {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.post({
+            resourcePath: "/v2/contacts/" + id + "/addresses",
+            body: {
+                type,
+                name,
+                is_primary,
+                address_line_1,
+                address_line_2,
+                state_province_county,
+                town_city,
+                postal_code,
+                country_code,
+                lat,
+                lon,
+                google_place_id
+            },
+            withAccessToken: true,
+        });
+        if (response.code == "OK")
+            return createResult(ErrorCodes.OK, response.data);
+        else {
+            if (
+                response.error && (
+                    response.error.error == "COM.CRM.EXCEPTIONS.ALREADYEXISTSEXCEPTION" || response.error.error == "CRM.EXCEPTIONS.ALREADYEXISTSEXCEPTION")
+            ) {
+                return createResult(
+                    ErrorCodes.ADD_ADDRESS_ALREADY_TYPE,
+                    response.error
+                );
+            } else return createResult(ErrorCodes.UNCLASSIFIED_ERROR, response.error);
+        }
+    } catch (e) {
+        logger.error("Exception addContactAddress:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function updateContactAddress({
+    type,
+    name,
+    is_primary,
+    address_line_1,
+    address_line_2,
+    state_province_county,
+    town_city,
+    postal_code,
+    country_code,
+    lat,
+    lon,
+    google_place_id
+} = {}, addId) {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.put({
+            resourcePath: "/v2/contacts/" + id + "/addresses/" + addId,
+            body: {
+                type,
+                name,
+                is_primary,
+                address_line_1,
+                address_line_2,
+                state_province_county,
+                town_city,
+                postal_code,
+                country_code,
+                lat,
+                lon,
+                google_place_id
+            },
+            withAccessToken: true,
+        });
+        if (response.code == "OK")
+            return createResult(ErrorCodes.OK, response.data);
+        else {
+            if (
+                response.error && (
+                    response.error.error == "COM.CRM.EXCEPTIONS.ALREADYEXISTSEXCEPTION" || response.error.error == "CRM.EXCEPTIONS.ALREADYEXISTSEXCEPTION")
+            ) {
+                return createResult(
+                    ErrorCodes.ADD_ADDRESS_ALREADY_TYPE,
+                    response.error
+                );
+            } else return createResult(ErrorCodes.UNCLASSIFIED_ERROR, response.error);
+        }
+    } catch (e) {
+        logger.error("Exception updateContactAddress:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function updateContactOnboardingCards({
+    viewed
+} = {}, addId) {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.put({
+            resourcePath: "/v2/contacts/" + id + "/onboarding" ,
+            body: {
+                viewed
+            },
+            withAccessToken: true,
+        });
+        if (response.code == "OK")
+            return createResult(ErrorCodes.OK, response.data);
+        else return createResult(ErrorCodes.UNCLASSIFIED_ERROR, response.error);
+    } catch (e) {
+        logger.error("Exception updateContactOnboardingCards:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+
+async function deleteContactAddress(addId) {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.sendDelete({
+            resourcePath: "/v2/contacts/" + id + "/addresses/" + addId,
+            withAccessToken: true,
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception deleteContactAddress:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function reclaimPurchase({
+    purchase_id,
+    merchant_tap_code,
+    venue_tap_code,
+    total_amount,
+    transaction_code
+}, { }) {
+    try {
+        let body = {}
+        if (transaction_code) {
+            body.transaction_code = transaction_code;
+        } else {
+            body.id = purchase_id
+            body.organisation = {
+                merchant_tap: {
+                    code: merchant_tap_code
+                },
+                venue_tap: {
+                    code: venue_tap_code
+                },
+            }
+            body.transaction_amounts = {
+                total: total_amount
+            }
+        }
+        let response = await httpUtil.post({
+            resourcePath: "/v2/purchases/reclaim",
+            body: body,
+            withAccessToken: true,
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception reclaimPurchase:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function referFriend({
+    recipients
+}, { }) {
+    try {
+        let response = await httpUtil.post({
+            resourcePath: "/v2/referrals/actions ",
+            body: {
+                action: "SEND",
+                recipients
+            },
+            withAccessToken: true,
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception referFriend:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function redeemPass({
+    code,
+    contact_id,
+    wallet_id,
+    pin
+}, { }) {
+    try {
+        let response = await httpUtil.post({
+            resourcePath: "/v2/passes/redeem ",
+            body: {
+                code,
+                contact_id,
+                wallet_id,
+                pin
+            },
+            withAccessToken: true,
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception redeemPass:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function getContactPreferredOrganisation() {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.get({
+            resourcePath: "/v2/contacts/" + id + "/preferences",
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception getContactPreferredOrganisation:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function addContactPreferredOrganisation({
+    organisation_id,
+    type = 'ORDERS'
+} = {}) {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.post({
+            resourcePath: "/v2/contacts/" + id + "/preferences",
+            body: {
+                organisation_id,
+                type
+            }
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception addContactPreferredOrganisation:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function updateContact({
+    first_name,
+    middle_name,
+    last_name,
+    language_code,
+    email,
+    phone,
+    gender,
+    date_of_birth,
+    name_day,
+    custom_fields,
+    statutory_number,
+    id_number,
+    id_issuing_country_code,
+    id_expiration_date,
+    passport_number,
+    passport_issuing_country_code,
+    passport_expiration_date,
+} = {}) {
+    try {
+        let body = {
+            first_name,
+            middle_name,
+            last_name,
+            language_code,
+            email,
+            phone,
+            custom_fields
+        }
+        let demographics = {};
+        let id_details = {};
+        let passport={};
+        if (gender) {
+            demographics.gender = gender;
+        }
+        if (date_of_birth) {
+            demographics.date_of_birth = date_of_birth;
+        }
+        if (name_day) {
+            demographics.name_day = name_day;
+        }
+        if (statutory_number) {
+            demographics.statutory_number = statutory_number;
+        }
+        if (id_number) {
+            id_details.number = id_number;
+        }
+        if (id_issuing_country_code) {
+            id_details.issuing_country_code = id_issuing_country_code;
+        }
+        if (id_expiration_date) {
+            id_details.expiration_date = id_expiration_date;
+        }
+        if (Object.keys(id_details).length > 0) {
+            demographics.id_details = id_details;
+        }
+        if (passport_number) {
+            passport.number = passport_number;
+        }
+        if (passport_issuing_country_code) {
+            passport.issuing_country_code = passport_issuing_country_code;
+        }
+        if (passport_expiration_date) {
+            passport.expiration_date = passport_expiration_date;
+        }
+        if (Object.keys(passport).length > 0) {
+            demographics.passport = passport;
+        }
+       
+        body.demographics = demographics;
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.put({
+            resourcePath: "/v2/contacts/" + id,
+            body: body
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception updateContact:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function setMarketingPreferences({
+    sms_opt_out,
+    email_opt_out,
+    contact_id,
+    access_token
+} = {}) {
+    try {
+        let id =  contact_id ? contact_id : httpUtil.getSession().sub;
+        let response = await httpUtil.put({
+            resourcePath: "/v2/contacts/" + id,
+            body: {
+                sms_opt_out,
+                email_opt_out
+            },
+            withAccessToken: true,
+            accessToken: access_token
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception setMarketingPreferences:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function submitReferralCode({
+    referral_code,
+} = {}) {
+    try {
+        let id =  httpUtil.getSession().sub;
+        let response = await httpUtil.post({
+            resourcePath: "/v2/contacts/" + id + "/referral_code",
+            body: {
+                referral_code,
+            },
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception submitReferralCode:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function unregisterContact() {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.sendDelete({
+            resourcePath: "/v2/contacts/" + id
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception unregisterContact:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function signOutContact({
+    redirect_url,
+} = {}) {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.post({
+            resourcePath: "/v2/contacts/" + id + "/sign_out",
+            body:{
+                redirect_url
+            }
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception signOutContact:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+
+async function getContactPurchases({
+    date,
+    date_gt,
+    date_gte,
+    date_lt,
+    date_lte,
+    include_total,
+    is_ad_hoc_returned,
+    page,
+    size = 20,
+    sort,
+    order,
+}={}) {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.get({
+            resourcePath: "/v2/contacts/" + id +"/purchases/",
+            queryParams:{
+                date,
+                "date[gt]": date_gt,
+                "date[gte]": date_gte,
+                "date[lt]": date_lt,
+                "date[lte]": date_lte,
+                include_total,
+                is_ad_hoc_returned,
+                page,
+                size,
+                sort,
+                order,
+            }
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception getContactPurchases:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function getPurchase(purchaseId) {
+    try {
+        let response = await httpUtil.get({
+            resourcePath: "/v2/purchases/" + purchaseId,
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception getPurchase:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function requestOTPSpend({
+    intent = 'SPEND',
+    spend_amount
+}={}) {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.post({
+            resourcePath: "/v2/contacts/" + id + "/token",
+            body:{
+                intent,
+                spend_amount
+            },
+            withAccessToken: true,
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception requestOTPSpend:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function getOTPSpend({
+    intent = 'SPEND',
+    community_id
+} = {}) {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.get({
+            resourcePath: "/v2/contacts/" + id + "/tokens",
+            queryParams: {
+                intent,
+                community_id
+            },
+            withAccessToken: true,
+        });
+        //check return code here instead of put as there would be different intepretation for different API
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception getOTPSpend:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function onChangePassword({
+    password
+}={}) {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.post({
+            resourcePath: "/v2/contacts/" + id + "/change_password",
+            body:{
+                password
+            },
+            withAccessToken: true,
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception onChangePassword:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function getNameDayRules({
+    first_name
+} = {}) {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.get({
+            resourcePath: "/v2/name_day_rules",
+            queryParams: {
+                first_name
+            },
+            withAccessToken: true,
+        });
+        //check return code here instead of put as there would be different intepretation for different API
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception getNameDayRules:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function addApplicationUsage(applicationID, platform) {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.post({
+            resourcePath: "/v1/contacts/" + id + "/applications",
+            body: {
+                application_id: applicationID,
+                platform: platform
+            },
+            withAccessToken: true,
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception addApplicationUsage:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function requestContactToken({
+    intent = 'SPEND',
+    spend_amount,
+    community_id
+}) {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.post({
+            resourcePath: "/v2/contacts/" + id + "/tokens",
+            body: {
+                intent,
+                spend_amount,
+                community_id
+            },
+            withAccessToken: true,
+        });
+        //check return code here instead of put as there would be different intepretation for different API
+        if (response.code == "OK")
+            return createResult(ErrorCodes.OK, response.data);
+        else {
+            return createCommonResult(response);
+        }
+    } catch (e) {
+        logger.error("Exception requestContactToken:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+
+async function getContactTokens({
+    intent = 'SPEND',
+    community_id
+} = {}) {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.get({
+            resourcePath: "/v2/contacts/" + id + "/tokens",
+            queryParams: {
+                intent,
+                community_id
+            },
+            withAccessToken: true,
+        });
+        //check return code here instead of put as there would be different intepretation for different API
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception getContactTokens:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function addPNDeviceToken({
+    serial_number,
+    registration_token,
+    mac_address,
+    platform="MOBILE",
+    product_id,
+    application_id,
+    electronic_id
+}={}) {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.post({
+            resourcePath: "/v2/contacts/" + id + "/devices",
+            body: {
+                serial_number,
+                platform,
+                registration_token,
+                mac_address,
+                product_id,
+                application_id,
+                electronic_id
+            },
+            withAccessToken: true,
+            logOutIfSessionInvalid: false
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception addDevice:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function deleteDeviceToken({
+    registration_token,
+}={}) {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.sendDelete({
+            resourcePath: "/v2/contacts/" + id + "/devices/"+registration_token,
+            withAccessToken: true,
+            logOutIfSessionInvalid: false
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception addDevice:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+
+async function uploadProfileImage({
+    file,
+    disalbedContentType = false,
+} = {}) {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.uploadFile({
+            resourcePath: "/v2/contacts/" + id + "/image",
+            fileData: file,
+            withAccessToken: true,
+            method:"PUT",
+            keyParam:'image',
+            disalbedContentType: disalbedContentType,
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception uploadProfileImage:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function deleteProfileImage() {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.sendDelete({
+            resourcePath: "/v2/contacts/" + id + "/image",
+            withAccessToken: true,
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception deleteProfileImage:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function getApplePass(org_id) {
+    try {
+        let id = httpUtil.getSession().sub;
+        if(!org_id){
+            org_id = httpUtil.getSession().current_organisation_id;
+        }
+        let url = httpUtil.getURI(false, "/v2/apple_pass/" + org_id + '/contacts/' + id);
+        return { code: 'OK', data: url }
+    } catch (e) {
+        logger.error("Exception getApplePass:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function getAndroidWalletPass(org_id) {
+    try {
+        let id = httpUtil.getSession().sub;
+        if(!org_id){
+            org_id = httpUtil.getSession().current_organisation_id;
+        }
+        let url = httpUtil.getURI(false, "/v2/android_wallet_pass/" + org_id + '/contacts/' + id);
+        return { code: 'OK', data: url }
+    } catch (e) {
+        logger.error("Exception getAndroidWalletPass:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function getGooglePass(org_id) {
+    try {
+        let id = httpUtil.getSession().sub;
+        if(!org_id){
+            org_id = httpUtil.getSession().current_organisation_id;
+        }
+        let url = httpUtil.getURI(false, "/v2/google_pass/" + org_id + '/contacts/' + id);
+        return { code: 'OK', data: url }
+    } catch (e) {
+        logger.error("Exception getGooglePass:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function exportStatements({
+    account_id,
+    from_month,
+    to_month,
+    from_year,
+    to_year,
+    format,
+}) {
+    try {
+        let id = httpUtil.getSession().sub;
+        if (!account_id) {
+            let primeAccRes = await account.getPrimaryAccount();
+            if (primeAccRes.code != ErrorCodes.OK)
+                return primeAccRes;
+            if (!primeAccRes.data.content && primeAccRes.data.content.size() == 0)
+                return createResult(ErrorCodes.ACCOUNT_NOT_FOUND, response.error);
+            account_id = primeAccRes.data.content[0].id;
+        }
+        let response = await httpUtil.post({
+            resourcePath: "/v2/contacts/" + id + "/export_statement",
+            body: {
+                account_id,
+                from_month,
+                to_month,
+                from_year,
+                to_year,
+                format,
+            },
+            withAccessToken: true,
+        });
+        //check return code here instead of put as there would be different intepretation for different API
+        if (response.code == "OK")
+            return createResult(ErrorCodes.OK, response.data);
+        else {
+            return createCommonResult(response);
+        }
+    } catch (e) {
+        logger.error("Exception exportStatements:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function getContactDonationsOffer({
+    contact_id,
+    page = 1,
+    size = 20,
+    include_opt_out,
+    include_total,
+    order,
+    sort,
+    donation_offer_id
+}) {
+    try {
+        let id = httpUtil.getSession().sub;
+        if (!contact_id) {
+            contact_id = id;
+        }
+        let response = await httpUtil.get({
+            resourcePath: "/v2/contacts/" + id + "/donations",
+            withAccessToken: true,
+            queryParams: {
+                page,
+                size,
+                include_opt_out,
+                include_total,
+                order,
+                sort,
+                donation_offer_id
+            }
+        });
+        //check return code here instead of put as there would be different intepretation for different API
+        if (response.code == "OK")
+            return createResult(ErrorCodes.OK, response.data);
+        else {
+            return createCommonResult(response);
+        }
+    } catch (e) {
+        logger.error("Exception getContactDonationsOffer:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function getDonationHistory({
+    contact_id,
+    include_total,
+    order,
+    organisation_id,
+    page = 1,
+    size = 20,
+    sort,
+}) {
+    try {
+        let id = httpUtil.getSession().sub;
+        if (!contact_id) {
+            contact_id = id;
+        }
+        let response = await httpUtil.get({
+            resourcePath: "/v2/contacts/" + id + "/donations/history",
+            withAccessToken: true,
+            queryParams: {
+                include_total,
+                order,
+                organisation_id,
+                page,
+                size,
+                sort,
+            }
+        });
+        //check return code here instead of put as there would be different intepretation for different API
+        if (response.code == "OK")
+            return createResult(ErrorCodes.OK, response.data);
+        else {
+            return createCommonResult(response);
+        }
+    } catch (e) {
+        logger.error("Exception getDonationHistory:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function donationActions({
+    contact_id,
+    donation_offer_id,
+    multiplier,
+    amount
+}) {
+    try {
+        let id = httpUtil.getSession().sub;
+        if (!contact_id) {
+            contact_id = id;
+        }
+        let response = await httpUtil.post({
+            resourcePath: "/v2/contacts/" + id + "/donations",
+            withAccessToken: true,
+            body: {
+                donation_offer_id,
+                multiplier,
+                amount
+            }
+        });
+        //check return code here instead of put as there would be different intepretation for different API
+        if (response.code == "OK")
+            return createResult(ErrorCodes.OK, response.data);
+        else {
+            return createCommonResult(response);
+        }
+    } catch (e) {
+        logger.error("Exception donationActions:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function updateDonation({
+    contact_id,
+    donation_id,
+    donation_offer_id,
+    multiplier,
+    amount
+}) {
+    try {
+        let id = httpUtil.getSession().sub;
+        if (!contact_id) {
+            contact_id = id;
+        }
+        let response = await httpUtil.put({
+            resourcePath: "/v2/contacts/" + id + "/donations/" + donation_id,
+            withAccessToken: true,
+            body: {
+                donation_offer_id,
+                multiplier,
+                amount
+            }
+        });
+        //check return code here instead of put as there would be different intepretation for different API
+        if (response.code == "OK")
+            return createResult(ErrorCodes.OK, response.data);
+        else {
+            return createCommonResult(response);
+        }
+    } catch (e) {
+        logger.error("Exception updateDonation:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function removeDonation({
+    contact_id,
+    donation_id,
+}) {
+    try {
+        let id = httpUtil.getSession().sub;
+        if (!contact_id) {
+            contact_id = id;
+        }
+        let response = await httpUtil.sendDelete({
+            resourcePath: "/v2/contacts/" + id + "/donations/" + donation_id,
+            withAccessToken: true,
+        });
+        //check return code here instead of put as there would be different intepretation for different API
+        if (response.code == "OK")
+            return createResult(ErrorCodes.OK, response.data);
+        else {
+            return createCommonResult(response);
+        }
+    } catch (e) {
+        logger.error("Exception removeDonation:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function getDonationOffers({
+    page = 1,
+    size = 20,
+    organisations,
+    order,
+    include_total,
+    owner,
+    search_value,
+    sort,
+    types,
+    donated_to,
+    donation_offer_id,
+    donation_types,
+}) {
+    try {
+        let response = await httpUtil.get({
+            resourcePath: "/v2/donation_offers",
+            withAccessToken: true,
+            queryParams: {
+                page,
+                size,
+                organisations,
+                order,
+                include_total,
+                owner,
+                search_value,
+                sort,
+                types,
+                donated_to,
+                donation_offer_id,
+                donation_types,
+            }
+        });
+        //check return code here instead of put as there would be different intepretation for different API
+        if (response.code == "OK")
+            return createResult(ErrorCodes.OK, response.data);
+        else {
+            return createCommonResult(response);
+        }
+    } catch (e) {
+        logger.error("Exception getDonationOffers:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function getDonationOrganisations({
+    include_creatives,
+    type,
+}) {
+    try {
+        let response = await httpUtil.get({
+            resourcePath: "/v2/donation_offers/organisations",
+            withAccessToken: true,
+            queryParams: {
+                include_creatives,
+                type,
+            }
+        });
+        //check return code here instead of put as there would be different intepretation for different API
+        if (response.code == "OK")
+            return createResult(ErrorCodes.OK, response.data);
+        else {
+            return createCommonResult(response);
+        }
+    } catch (e) {
+        logger.error("Exception getDonationOffers:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}