@crmcom/self-service-sdk 2.1.2

package/community.js

@@ -0,0 +1,327 @@
+import { httpUtil } from './httpUtil'
+import { ErrorCodes, createResult, createCommonResult } from './resultUtil'
+import { logger } from './logger';
+
+export const community = {
+    getListJoinedCommunities,
+    getListCommunityPeople,
+    getCommunityPeople,
+    addCommunityPeople,
+    updateCommunityPeople,
+    deleteCommunityPeople,
+    getCommunityRelations,
+    switchRole,
+    leaveCommunity,
+    getContactGroups,
+    updateContactGroups,
+    getCommunityMembers,
+    getCommunityMember,
+    acceptRejectCommunityInvitation,
+    deleteCommunityRelationship
+}
+
+async function getListJoinedCommunities({
+    include_total,
+    page,
+    size = 20,
+    sort,
+    order,
+}={},contactId) {
+    try {
+        let id = contactId ? contactId : httpUtil.getSession().sub;
+        let response = await httpUtil.get({
+            resourcePath: "/v2/contacts/" + id +"/communities",
+            queryParams:{
+                include_total,
+                page,
+                size,
+                sort,
+                order,
+            }
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception getListJoinedCommunities:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function getListCommunityPeople({
+    include_total,
+    page,
+    size = 20,
+    sort,
+    order,
+}={},contactId) {
+    try {
+        let id = contactId ? contactId : httpUtil.getSession().sub;
+        let response = await httpUtil.get({
+            resourcePath: "/v2/contacts/" + id +"/people",
+            queryParams:{
+                include_total,
+                page,
+                size,
+                sort,
+                order,
+            }
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception getListCommunityPeople:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function addCommunityPeople({
+    email,
+    phone_number,
+    country_code,
+    relation_id,
+    is_admin,
+    permissions,
+    group,
+    contact,
+}={},contactId) {
+    let body = {
+        email,
+        relation_id,
+        is_admin,
+        permissions,
+        group,
+        contact,
+    };
+    if(phone_number){
+        body.phone = {
+            country_code: country_code,
+            number: phone_number
+        }
+    }
+    if (contact) body.contact = contact;
+    try {
+        let id = contactId ? contactId : httpUtil.getSession().sub;
+        let response = await httpUtil.post({
+            resourcePath: "/v2/contacts/" + id +"/people",
+            body:body
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception addCommunityPeople:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function updateCommunityPeople({
+    relation_id,
+    is_admin,
+    permissions,
+    wallet_sharing,
+    termed_transfer,
+    usage_allowance,
+    group,
+    devices
+}={},peopleId) {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.put({
+            resourcePath: "/v2/contacts/" + id +"/people/" + peopleId,
+            body:{
+                relation_id,
+                is_admin,
+                permissions,
+                wallet_sharing,
+                termed_transfer,
+                usage_allowance,
+                group,
+                devices
+            }
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception updateCommunityPeople:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function deleteCommunityPeople(peopleId) {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.sendDelete({
+            resourcePath: "/v2/contacts/" + id +"/people/" + peopleId
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception deleteCommunityPeople:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function getCommunityPeople(peopleId) {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.get({
+            resourcePath: "/v2/contacts/" + id +"/people/" + peopleId
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception getCommunityPeople:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function getCommunityMember(ownerId, memberId) {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.get({
+            resourcePath: "/v2/contacts/" + ownerId +"/people/" + memberId
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception getCommunityPeople:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function getCommunityRelations({
+    include_total,
+    page,
+    size = 20,
+    sort,
+    order,
+    name
+}={}) {
+    try {
+        let response = await httpUtil.get({
+            resourcePath: "/v2/communities/relations",
+            queryParams:{
+                include_total,
+                page,
+                size,
+                sort,
+                order,
+                name
+            }
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception getCommunityRelations:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function switchRole(community_id,isMerchant) {
+    try {
+        let response = await httpUtil.post({
+            resourcePath: "/v2/contacts/" + community_id +"/switch",
+        });
+        if (response.code == "OK") {
+            httpUtil.switchSession(response.data,isMerchant);
+        }
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception switchRole:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+
+async function leaveCommunity(community_id) {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.sendDelete({
+            resourcePath: "/v2/contacts/" +id + "/communities/" + community_id,
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception leaveCommunity:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function getContactGroups() {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.get({
+            resourcePath: "/v2/contacts/" + id + "/groups",
+            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 getContactGroups:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function getCommunityMembers({
+    include_total,
+    page,
+    size = 20,
+    sort,
+    order,
+    owner_id,
+    group
+}={}) {
+    try {
+        let response = await httpUtil.get({
+            resourcePath: "/v2/contacts/community/members",
+            queryParams:{
+                include_total,
+                page,
+                size,
+                sort,
+                order,
+                owner_id,
+                group
+            }
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception getCommunityMembers:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+
+async function updateContactGroups(body, name) {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.put({
+            resourcePath: "/v2/contacts/" + id + "/groups/" + name,
+            body: body,
+            withAccessToken: true,
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception updateContactGroups:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function acceptRejectCommunityInvitation(body, ownerId, relationId) {
+    try {
+        let response = await httpUtil.post({
+            resourcePath: "/v2/contacts/" + ownerId + "/people/" + relationId + "/actions",
+            body: body,
+            withAccessToken: true,
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception acceptRejectCommunityInvitation:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function deleteCommunityRelationship(ownerId, relationId) {
+    try {
+        let response = await httpUtil.sendDelete({
+            resourcePath: "/v2/contacts/" + ownerId + "/people/" + relationId,
+            withAccessToken: true,
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception acceptRejectCommunityInvitation:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+

package/config.js

@@ -0,0 +1,302 @@
+import { httpUtil } from './httpUtil'
+import { ErrorCodes, createResult, createCommonResult } from './resultUtil'
+import { getData } from '../../utils/common';
+import { logger } from './logger';
+export const config = {
+	getAppCfg,
+	getApplicationTranslations,
+	getIndustries,
+	getIndustrySectors,
+	getTownCities,
+	getOrganisationTags,
+	getTags,
+	getLanguages,
+	findAddress,
+	getAddress,
+	findAddressV1,
+	getIntegrations,
+}
+
+async function getAppCfg({
+	app_id,
+	use_cname = false,
+	cname
+} = {}) {
+	try {
+		var appId = await getData("APP_ID");
+		if (!app_id) app_id = appId;
+
+		var queryParams = {}
+		if (use_cname) {
+			queryParams.cloud_name = cname;
+		} else {
+			queryParams.platform_app_id = app_id;
+		}
+		let response = await httpUtil.get({
+			resourcePath: '/v2/applications',
+			queryParams: queryParams,
+			logOutIfSessionInvalid: false
+		});
+		return createCommonResult(response);
+	} catch (e) {
+		logger.error('Exception getAppCfg:', e);
+		return createResult(ErrorCodes.UNKNOWN, e);
+	}
+}
+
+async function getApplicationTranslations({
+	application_id
+	} = {}) {	
+	try {
+		let response = await httpUtil.get({
+			resourcePath: "/v2/applications/" + application_id + "/translations",
+			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 getApplicationTranslations:", e);
+		return createResult(ErrorCodes.UNKNOWN, e);
+	}
+}
+
+async function getIndustries({
+	name,
+	page = 1,
+	size = 1000,
+	sort,
+	order,
+} = {}) {
+	try {
+		let response = await httpUtil.get({
+			resourcePath: '/v2/industries',
+			queryParams: {
+				name,
+				page,
+				size,
+				sort,
+				order,
+			}
+		});
+		return createCommonResult(response);
+	} catch (e) {
+		logger.error('Exception getIndustries:', e);
+		return createResult(ErrorCodes.UNKNOWN, e);
+	}
+}
+
+async function getIndustrySectors({
+	industry_name,
+	industry_sector_ids,
+	name,
+	page = 1,
+	size = 1000,
+	sort,
+	order
+} = {}) {
+	try {
+		let response = await httpUtil.get({
+			resourcePath: '/v2/industry_sectors',
+			queryParams: {
+				industry_name,
+				industry_sector_ids,
+				name,
+				page,
+				size,
+				sort,
+				order,
+			}
+		});
+		return createCommonResult(response);
+	} catch (e) {
+		logger.error('Exception getIndustries:', e);
+		return createResult(ErrorCodes.UNKNOWN, e);
+	}
+}
+
+async function getTownCities() {
+	try {
+		let response = await httpUtil.get({
+			resourcePath: '/v2/locations/towns',
+		});
+		return createCommonResult(response);
+	} catch (e) {
+		logger.error('Exception getTownCities:', e);
+		return createResult(ErrorCodes.UNKNOWN, e);
+	}
+}
+
+async function getOrganisationTags({
+	industry,
+	industry_sector,
+	page = 1,
+	size = 1000,
+	sort,
+	order
+} = {}) {
+	try {
+
+		//console.log('API: ', contact)
+		let response = await httpUtil.get({
+			resourcePath: '/v2/organisations/tags',
+			queryParams: {
+				page,
+				size,
+				sort,
+				order,
+				industry,
+				industry_sector
+			}
+		});
+		return createCommonResult(response);
+	} catch (e) {
+		logger.error('Exception getOrganisationTags:', e);
+		return createResult(ErrorCodes.UNKNOWN, e);
+	}
+}
+
+async function getTags({
+	entity,
+	search_value,
+	include_total,
+	page = 1,
+	size = 100,
+	sort,
+	order
+} = {}) {
+	try {
+
+		//console.log('API: ', contact)
+		let response = await httpUtil.get({
+			resourcePath: '/v2/tags',
+			queryParams: {
+				entity,
+				search_value,
+				include_total,
+				page,
+				size,
+				sort,
+				order
+			}
+		});
+		return createCommonResult(response);
+	} catch (e) {
+		logger.error('Exception getTags:', e);
+		return createResult(ErrorCodes.UNKNOWN, e);
+	}
+}
+
+async function getLanguages({ unauthorize = true }) {
+	try {
+		let response = await httpUtil.get({
+			resourcePath: '/v2/languages',
+			logOutIfSessionInvalid: false,
+		});
+		return createCommonResult(response);
+	} catch (e) {
+		logger.error('Exception getLanguages:', e);
+		return createResult(ErrorCodes.UNKNOWN, e);
+	}
+}
+async function findAddress({
+	integration = 'GOOGLE',
+	input,
+	session_id,
+} = {}) {
+	try {
+		let id = httpUtil.getSession().sub;
+		let response = await httpUtil.get({
+			resourcePath: "/v2/addresses",
+			queryParams: {
+				integration,
+				input,
+				session_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 findAddress:", e);
+		return createResult(ErrorCodes.UNKNOWN, e);
+	}
+}
+
+async function getAddress({
+	integration = 'GOOGLE',
+	google_place_id,
+	session_id,
+	latlng,
+} = {}) {
+	try {
+		let id = httpUtil.getSession().sub;
+		let response = await httpUtil.get({
+			resourcePath: "/v2/get_addresses",
+			queryParams: {
+				integration,
+				google_place_id,
+				session_id,
+				latlng,
+			},
+			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 getAddress:", e);
+		return createResult(ErrorCodes.UNKNOWN, e);
+	}
+}
+
+async function findAddressV1({
+	integration = 'GOOGLE',
+	address,
+	latlng
+} = {}) {
+	try {
+		let id = httpUtil.getSession().sub;
+		let response = await httpUtil.get({
+			resourcePath: "/v1/addresses",
+			queryParams: {
+				integration,
+				address,
+				latlng
+			},
+			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 findAddressV1:", e);
+		return createResult(ErrorCodes.UNKNOWN, e);
+	}
+}
+
+async function getIntegrations({
+	connector,
+	finance,
+	payment_method,
+	rewards,
+	transactions,
+	type,
+}, id) {
+	try {
+
+		//console.log('API: ', contact)
+		let response = await httpUtil.get({
+			resourcePath: '/v2/applications/' + id + '/integrations',
+			queryParams: {
+				connector,
+				finance,
+				payment_method,
+				rewards,
+				transactions,
+				type
+			}
+		});
+		return createCommonResult(response);
+	} catch (e) {
+		logger.error('Exception getIntegrations:', e);
+		return createResult(ErrorCodes.UNKNOWN, e);
+	}
+}

package/connectx.js

@@ -0,0 +1,92 @@
+import { httpUtil } from './httpUtil'
+import { ErrorCodes, createResult, createCommonResult } from './resultUtil'
+import { getData } from '../../utils/common';
+import { logger } from './logger';
+export const connectx = {
+    getBuckets,
+    simConfirmation,
+    simActivation,
+    simDownload,
+    portIn
+}
+
+async function getBuckets(serial_number) {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.get({
+            plugin: 'connectx',
+            resourcePath: "/" + id + "/buckets?serial_number=" + serial_number,
+            withAccessToken: true,
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception updateServices:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function simConfirmation({subscription_service_id}, serialNumber) {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.post({
+            plugin: 'connectx',
+            resourcePath: "/" + id + "/sim_confirmation/" + serialNumber,
+            body: {
+                subscription_service_id: subscription_service_id
+            },
+            withAccessToken: true,
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception updateServices:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function simActivation(body = {}, serialNumber) {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.post({
+            plugin: 'connectx',
+            resourcePath: "/" + id + "/sim_activation/" + serialNumber,
+            body: body,
+            withAccessToken: true,
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception updateServices:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function simDownload(body = {}) {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.post({
+            plugin: 'connectx',
+            resourcePath: "/" + id + "/sim_download",
+            body: body,
+            withAccessToken: true,
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception updateServices:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}
+
+async function portIn(body) {
+    try {
+        let id = httpUtil.getSession().sub;
+        let response = await httpUtil.post({
+            plugin: 'connectx',
+            resourcePath: "/" + id + "/port_in",
+            body: body,
+            withAccessToken: true,
+        });
+        return createCommonResult(response);
+    } catch (e) {
+        logger.error("Exception updateServices:", e);
+        return createResult(ErrorCodes.UNKNOWN, e);
+    }
+}