Customer sync from NetSuite to multiple TrackTrace. It is to be done based on subsidiaries included in the subsidiary sublist.
define(['N/record', 'N/search', 'N/ui/serverWidget', '../../Common Library/jj_tracktracerx_ns_utility.js', '../../Config Module/jj_cm_tracktracerx_api_config.js'],
/**
* @param{record} record
* @param{search} search
* @param{serverWidget}
* @param{jjUtil} jjUtil
* @param{TrackTrace} TrackTrace
*/
(record, search, serverWidget, jjUtil, trackTraceAPI) => {
let configurationSearch = [];
let subsidiaryMap = {
29: 'custentity_jj_brightline_tracktrace_uuid',
17: 'custentity_jj_nakorn_tracktrace_uuid',
26: 'custentity_jj_galaxy_tracktrace_uuid',
12: 'custentity_jj_drugpalce_tracktrace_uuid'
}
let addressMap = {
29: 'custrecord_jj_brightline_address_uuid',
17: 'custrecord_jj_nakorn_address_uuid',
26: 'custrecord_jj_galaxy_address_uuid',
12: 'custrecord_jj_drugplace_address_uuid'
}
const SAVEDSEARCH = {
/**
* @description search to get data
* @param customerId internal id of customer record
* @returns {{}}
*/
searchCustomerData(customerId, subsidiaryId) {
if (!customerId)
return {};
try {
let customerSearchObj = search.create({
type: "customer",
filters:
[
["internalid", "anyof", customerId]
],
columns:
[
search.createColumn({
name: "entityid",
sort: search.Sort.ASC,
label: "ID"
}),
search.createColumn({ name: "email", label: "Email" }),
search.createColumn({ name: "phone", label: "Phone" }),
search.createColumn({ name: "internalid", label: "Internal ID" }),
search.createColumn({ name: "isinactive", label: "Inactive" }),
search.createColumn({ name: "companyname", label: "Company Name" }),
search.createColumn({ name: "isperson", label: "Is Individual" }),
search.createColumn({ name: "firstname", label: "Name" }),
//search.createColumn({ name: "custentity_jj_tracktracerx_uuid", label: "TRACKTRACERX UUID" })
search.createColumn({ name: subsidiaryId, label: "JJ Tracktrace UUID" }),
search.createColumn({
name: "internalid",
join: "mseSubsidiary",
label: "Internal ID"
}),
]
});
let searchResultCount = customerSearchObj.runPaged().count;
let objDetails = {};
customerSearchObj.run().each(function (result) {
objDetails.customerid = result.getValue({ name: "entityid" }),
objDetails.companyName = result.getValue({ name: "companyname" }),
objDetails.isperson = result.getValue({ name: "isperson" }),
objDetails.email = result.getValue({ name: "email" }),
objDetails.phone = result.getValue({ name: "phone" }),
objDetails.altname = result.getValue({ name: "firstname" }),
objDetails.internalId = result.getValue({ name: "internalid" }),
objDetails.isInactive = result.getValue({ name: "isinactive" }),
//objDetails.uuid = result.getValue({ name: "custentity_jj_tracktracerx_uuid" })
objDetails.uuid = result.getValue({ name: subsidiaryId }),
objDetails.tuuid = result.getValue({
name: "internalid",
join: "mseSubsidiary",
label: "Internal ID"
})
});
return objDetails;
} catch (e) {
log.error("error", e);
return {};
}
}
}
/**
* @description customer body creating
* @param {Object}vendorRecord current customer record
* @returns {String}
*/
function trackTraceCustomerProcess(customerRecord, subsidiaryId) {
try {
let customerObj = SAVEDSEARCH.searchCustomerData(customerRecord.id, subsidiaryId);
log.debug("customerObj", customerObj)
let trackTraceCustomerBody = {
"custom_uuid": customerObj.uuid || "",
"name": (customerObj.isperson == true) ? customerObj.altname : customerObj.companyName,
"gs1_id": "",
"gs1_company_id": "",
"gs1_sgln": "",
"type": "CUSTOMER",
"parent_tp_uuid": "",
"customer_id": customerObj.customerid,
"friendly_name": "",
"default_billing_address_uuid": "",
"default_shipping_address_uuid": "",
"phone": customerObj.phone,
"phone_ext": "",
"notification_email": customerObj.email,
"new_trx_notification_type": "ALL",
"flag_notification_name": "",
"flag_notification_email": "",
"flag_notification_phone": "",
"flag_notification_phone_ext": "",
"external_reference": "",
"is_active": !(customerObj.isInactive),
"inbound_shipping_check_percentage": "",
"outbound_shipping_check_percentage": "",
"sender_id": "",
"receiver_id": "",
"as2_id": "",
"is_a_3pl_client": false,
"3pl_is_our_company_is_internal_entity_of_tp": false,
"is_send_outbond_epcis": false,
"is_send_outbond_x12": false,
"default_outbound_transaction_type": "SALES",
"send_copy_outbound_shipment_external_trading_entity_id": "",
"outbound_epcis_generator_type": "",
"is_enable_transmit_outbound_850": "",
"omit_comm_aggr_in_epcis": false
}
let formDataString = jjUtil.formData(trackTraceCustomerBody);
return formDataString;
} catch (e) {
log.error("error", e);
return "";
}
}
/**
* @description Function to get data from the address record related to the customer.
* @param {Object} customerRecord Current customer record object
* @returns
*/
function customerData(customerRecord, addressSubId) {
try {
let numLines = customerRecord.getLineCount({ sublistId: 'addressbook' });
let addressEmail = customerRecord.getValue({ fieldId: 'email' });
log.debug("addressEmail", addressEmail)
let arrayData = [];
for (let i = 0; i < numLines; i++) {
let objAddrDetails = {};
let subrec = customerRecord.getSublistSubrecord({
sublistId: 'addressbook',
fieldId: 'addressbookaddress',
line: i
});
objAddrDetails.countryCode = subrec.getValue({ fieldId: 'country' });
objAddrDetails.addrLine = subrec.getValue({ fieldId: 'addr1' });
objAddrDetails.addrSecondLine = subrec.getValue({ fieldId: 'addr2' });
objAddrDetails.addrPhone = subrec.getValue({ fieldId: 'addrphone' });
objAddrDetails.state = subrec.getValue({ fieldId: 'state' });
objAddrDetails.city = subrec.getValue({ fieldId: 'city' });
objAddrDetails.zip = subrec.getValue({ fieldId: 'zip' });
objAddrDetails.addrGs1Sgln = subrec.getValue({ fieldId: 'custrecord_jj_addr_gs1_sgln' });
objAddrDetails.addrGs1Id = subrec.getValue({ fieldId: 'custrecord_jj_addr_gs1_id' });
objAddrDetails.addrName = subrec.getValue({ fieldId: 'addressee' });
//objAddrDetails.customerUid = subrec.getValue({ fieldId: 'custrecord_jj_address_uuid' });
objAddrDetails.customerUid = subrec.getValue({ fieldId: addressSubId }),
objAddrDetails.addressEmail = addressEmail;
arrayData.push(objAddrDetails);
}
return arrayData
} catch (e) {
log.error("error in vendor data", e);
return {};
}
}
/**
* @description Creating addressbook request Object.
* @param {Object} addressCustomerObj Result data from the customer data function
* @returns {Array}
*/
function trackTraceCustomerAddressProcess(addressCustomerObj) {
try {
let formDataAddressString;
let arrayBody = [];
for (let i = 0; i < addressCustomerObj.length; i++) {
let trackTraceCustomerAddressBody = {
"address_nickname": "Main Address",
"address_gs1_id": addressCustomerObj[i].addrGs1Id,
"gs1_sgln": addressCustomerObj[i].addrGs1Sgln,
"recipient_name": addressCustomerObj[i].addrName,
"line1": addressCustomerObj[i].addrLine,
"line2": addressCustomerObj[i].addrSecondLine,
"country_code": addressCustomerObj[i].countryCode,
"state": addressCustomerObj[i].state,
"city": addressCustomerObj[i].city,
"zip": addressCustomerObj[i].zip,
"phone": addressCustomerObj[i].addrPhone,
"is_licence_required": false,
"email": addressCustomerObj[i].addressEmail
}
formDataAddressString = jjUtil.formData(trackTraceCustomerAddressBody);
arrayBody.push(formDataAddressString)
}
return arrayBody;
} catch (e) {
log.error("error", e);
return "";
}
}
/**
* Defines the function definition that is executed before record is loaded.
* @param {Object} scriptContext
* @param {Record} scriptContext.newRecord - New record
* @param {string} scriptContext.type - Trigger type; use values from the context.UserEventType enum
* @param {Form} scriptContext.form - Current form
* @param {ServletRequest} scriptContext.request - HTTP request information sent from the browser for a client action only.
* @since 2015.2
*/
const beforeLoad = (scriptContext) => {
try {
let oldRecordCheckbox = scriptContext.newRecord;
let checkboxOld = oldRecordCheckbox.getValue({
fieldId: 'custentity_jj_tractrace_cussync'
});
let form = scriptContext.form;
let checkboxId = form.getField({
id: 'custentity_jj_tractrace_cussync'
});
let customerUuid = oldRecordCheckbox.getValue({
fieldId: "custentity_jj_tracktracerx_uuid"
})
if (scriptContext.type == 'edit' && checkboxOld == true && jjUtil.checkForParameter(customerUuid)) {
checkboxId.updateDisplayType({
displayType: serverWidget.FieldDisplayType.DISABLED
});
}
}
catch (e) {
log.error("error@beforeLoad", e)
}
}
/**
* Defines the function definition that is executed before record is submitted.
* @param {Object} scriptContext
* @param {Record} scriptContext.newRecord - New record
* @param {Record} scriptContext.oldRecord - Old record
* @param {string} scriptContext.type - Trigger type; use values from the context.UserEventType enum
* @since 2015.2
*/
const beforeSubmit = (scriptContext) => {
try {
let customerRecord = scriptContext.newRecord;
let customerOldRecord = scriptContext.oldRecord;
let numLinessubsidiary = vendorOldRecord.getLineCount({
sublistId: 'submachine'
});
let arrayData = [];
for (let i = 0; i < numLinessubsidiary; i++) {
let objAddrDetails = {};
let subsidiary = vendorOldRecord.getSublistValue({
sublistId: 'submachine',
fieldId: 'subsidiary',
line: i
})
arrayData.push(subsidiary);
}
log.debug("arrayData", arrayData)
if (scriptContext.type == 'create') {
customerRecord.setValue({
fieldId: subsidiaryMap[arrayData[i]],
value: "",
});
}
else if (scriptContext.type == 'delete') {
for (let i = 0; i < arrayData.length; i++) {
let configurationSearch = trackTraceAPI.Library.apiConfigfileSearch(arrayData[i]);
let subsidiaryId = subsidiaryMap[arrayData[i]];
log.debug("subsidiaryId", subsidiaryId);
let vendoroldUuid = vendorOldRecord.getValue({
fieldId: subsidiaryId
});
//trackTraceAPI.Library.trackTraceDelete("DELETE", configurationSearch?.domain + '/' + configurationSearch?.version + trackTraceAPI.Library.TRACKTRACERX_API_REQUESTS.tradingPartners + '/' + customerOldUuid);
let requestUrl = configurationSearch?.domain + '/' + configurationSearch?.version + '/' + (trackTraceAPI.Library.TRACKTRACERX_API_REQUESTS.tradingPartnerDelete).replace('{uuid}', customerOldUuid);
let deleteResponse = trackTraceAPI.Library.requestToTrackTrace("DELETE", requestUrl, '', configurationSearch);
}
}
} catch (e) {
log.error("error@beforeSubmit", e)
}
}
/**
* @description To determine the script execution environment
* @returns {null}
*/
function shouldProceed() {
let envMethods = jjUtil.envMethods.init();
log.debug('shouldProceed, envMethods', envMethods);
return envMethods.envType.SANDBOX; //todo PRODUCTION
}
/**
* @description set values in the fields after sync
* @param {Object} vendorRecord current record
* @param {Object} response tracktracerx response
* @param {Number} code response code
*/
function valueSetInRecord(customerRecord, subsidiaryId,response, code) {
try {
log.debug("subsidiaryId", subsidiaryId)
var fieldValues = {};
fieldValues[subsidiaryId] = response.body.uuid;
if (code == 200) {
record.submitFields({
type: customerRecord.type,
id: customerRecord.id,
values: fieldValues,
options: {
enableSourcing: false,
ignoreMandatoryFields: true
}
});
}
} catch (e) {
log.error("error@valueSetInRecord", e)
}
}
/**
* @description The function to set the sync data from the responce
* @param {Object} itemRecord current item record
* @param {Object} response api response
*/
function valueSetemptyInRecord(customerRecord, subsidiaryId, response, code) {
try {
log.debug("subsidiaryId", subsidiaryId)
var fieldValues = {};
fieldValues[subsidiaryId] = '';
if (code == 200) {
record.submitFields({
type: customerRecord.type,
id: customerRecord.id,
values: fieldValues,
options: {
enableSourcing: false,
ignoreMandatoryFields: true
}
});
}
} catch (err) {
log.error("err @ value set function", err)
}
}
/**
* @description Set value in the address record.
* @param {Object} customerRecord Customer record object.
* @param {Object} response Response object from the tracktrace
* @param {Number} code response code.
* @param {Number} i Iterator specifier.
*/
function addressSetInRecord(customerRecord,addressSubId, response, code, i) {
try {
if (code == 200) {
let rec = record.load({
type: record.Type.CUSTOMER,
id: customerRecord.id,
isDynamic: false
});
let subrec = rec.getSublistSubrecord({
sublistId: 'addressbook',
fieldId: 'addressbookaddress',
line: i
});
subrec.setValue({
fieldId: addressSubId,
value: response.body.uuid
});
rec.save();
}
} catch (err) {
log.error('err @ address book set function', err)
}
}
/**
* Defines the function definition that is executed after record is submitted.
* @param {Object} scriptContext
* @param {Record} scriptContext.newRecord - New record
* @param {Record} scriptContext.oldRecord - Old record
* @param {string} scriptContext.type - Trigger type; use values from the context.UserEventType enum
* @since 2015.2
*/
const afterSubmit = (scriptContext) => {
try {
if (shouldProceed()) {
let customerRecord = scriptContext.newRecord;
let syncCheckbox = customerRecord.getValue({
fieldId: "custentity_jj_tractrace_cussync",
})
let inactiveCheckbox = customerRecord.getValue({
fieldId: "isinactive"
})
let numLinessubsidiary = customerRecord.getLineCount({
sublistId: 'submachine'
});
let arrayData = [];
for (let i = 0; i < numLinessubsidiary; i++) {
let objAddrDetails = {};
let arraySub = customerRecord.getSublistValue({
sublistId: 'submachine',
fieldId: 'subsidiary',
line: i
})
arrayData.push(arraySub);
}
let customerDataObj = {};
let customerAddressArr = {};
let requestUrl;
if (scriptContext.type == 'create' || scriptContext.type == 'edit' || scriptContext.type == 'xedit') {
for (let i = 0; i < arrayData.length; i++) {
if (arrayData[i] == '29' || arrayData[i] == '26' || arrayData[i] == '17' || arrayData[i] == '12') {
configurationSearch = trackTraceAPI.Library.apiConfigfileSearch(arrayData[i])
let subsidiaryId = subsidiaryMap[arrayData[i]];
log.debug("subsidiaryId", subsidiaryId);
let addressSubId = addressMap[arrayData[i]];
log.debug("addressSubId", addressSubId);
log.debug("configurationSearch", configurationSearch)
if (scriptContext.type == 'create' && syncCheckbox == true) {
let createResponse;
customerDataObj = trackTraceCustomerProcess(customerRecord, subsidiaryId);
if (jjUtil.checkForParameter(customerDataObj)) {
requestUrl = configurationSearch?.domain + '/' + configurationSearch?.version + trackTraceAPI.Library.TRACKTRACERX_API_REQUESTS.tradingPartnerCreate
createResponse = trackTraceAPI.Library.requestToTrackTrace("POST", requestUrl, customerDataObj, configurationSearch);
valueSetInRecord(customerRecord,subsidiaryId, createResponse, createResponse.code);
let customerNewUuid = createResponse.body.uuid;
if (jjUtil.checkForParameter(customerNewUuid)) {
let addressCustomerObj = customerData(customerRecord, addressSubId);
customerAddressArr = trackTraceCustomerAddressProcess(addressCustomerObj, addressSubId);
if (jjUtil.checkForParameter(customerAddressArr)) {
for (let i = 0; i < customerAddressArr.length; i++) {
try {
requestUrl = (configurationSearch?.domain + '/' + configurationSearch?.version + trackTraceAPI.Library.TRACKTRACERX_API_REQUESTS.tradingPartnerAddressBookCreate).replace("{uuid}", customerNewUuid);
let createAddressResponse = trackTraceAPI.Library.requestToTrackTrace("POST", requestUrl, customerAddressArr[i], configurationSearch);
addressSetInRecord(customerRecord, addressSubId,createAddressResponse, createAddressResponse.code, i);
} catch (e) {
log.error("error@create", e)
}
}
}
}
}
}
else if ((scriptContext.type == 'edit' || scriptContext.type == 'xedit') && syncCheckbox == true) {
let oldCusRecord = scriptContext.oldRecord;
let inactiveCheckboxOldValue = oldCusRecord.getValue({
fieldId: "isinactive"
})
let customerUuid = customerRecord.getValue({
fieldId: subsidiaryId
})
let updateResponse;
if (inactiveCheckbox != inactiveCheckboxOldValue) {
customerDataObj = trackTraceCustomerProcess(customerRecord, subsidiaryId);
if (jjUtil.checkForParameter(customerDataObj)) {
requestUrl = (configurationSearch?.domain + '/' + configurationSearch?.version + trackTraceAPI.Library.TRACKTRACERX_API_REQUESTS.tradingPartnerUpdate).replace("{uuid}", customerUuid);
updateResponse = trackTraceAPI.Library.requestToTrackTrace("PUT", requestUrl, customerDataObj, configurationSearch);
valueSetInRecord(customerUuid,subsidiaryId, updateResponse, updateResponse.code);
}
}
let numLinessubsidiarys = oldCusRecord.getLineCount({
sublistId: 'submachine'
});
let arrayDatas = [];
for (let i = 0; i < numLinessubsidiarys; i++) {
let objAddrDetails = {};
let arraySubs = oldCusRecord.getSublistValue({
sublistId: 'submachine',
fieldId: 'subsidiary',
line: i
})
arrayDatas.push(arraySubs);
}
let removedSubsidiaries = arrayDatas.filter(sub => !arrayData.includes(sub));
log.debug("removedSubsidiaries", removedSubsidiaries);
for (let j = 0; j < removedSubsidiaries.length; j++) {
if (removedSubsidiaries[i] == '29' || removedSubsidiaries[i] == '26' || removedSubsidiaries[i] == '17' || removedSubsidiaries[i] == '12') {
let configurationSearchOld = trackTraceAPI.Library.apiConfigfileSearch(removedSubsidiaries[i])
let subsidiaryId = subsidiaryMap[removedSubsidiaries[i]];
let customerUuids = oldCusRecord.getValue({
fieldId: subsidiaryId
})
let requestUrl = configurationSearchOld?.domain + '/' + configurationSearchOld?.version + '/' + (trackTraceAPI.Library.TRACKTRACERX_API_REQUESTS.tradingPartnerDelete).replace('{uuid}', customerUuids);
let createResponsedelete = trackTraceAPI.Library.requestToTrackTrace("DELETE", requestUrl, '', configurationSearchOld);
valueSetemptyInRecord(customerRecord, subsidiaryId, createResponsedelete, createResponsedelete.code);
}
}
if (jjUtil.checkForParameter(customerUuid)) {
let addressCustomerObj = customerData(customerRecord,addressSubId);
customerAddressArr = trackTraceCustomerAddressProcess(addressCustomerObj,addressSubId);
if (jjUtil.checkForParameter(customerAddressArr)) {
for (let i = 0; i < customerAddressArr.length; i++) {
if (jjUtil.checkForParameter(addressCustomerObj[i].customerUid)) {
try {
requestUrl = (
configurationSearch?.domain + '/' + configurationSearch?.version +
trackTraceAPI.Library.TRACKTRACERX_API_REQUESTS.tradingPartnerAddressBookUpdate
).replace("{uuid}", customerUuid).replace("{address_uuid}", addressCustomerObj[i].customerUid);
let updateAddressResponse = trackTraceAPI.Library.requestToTrackTrace("PUT", requestUrl, customerAddressArr[i], configurationSearch);
addressSetInRecord(customerRecord, addressSubId,updateAddressResponse, updateAddressResponse.code, i);
} catch (e) {
log.error("error@create", e)
}
}
else {
let customerUuidForCreation = customerRecord.getValue({
fieldId: subsidiaryId
})
try {
requestUrl = (
configurationSearch?.domain + '/' + configurationSearch?.version +
trackTraceAPI.Library.TRACKTRACERX_API_REQUESTS.tradingPartnerAddressBookCreate
).replace("{uuid}", customerUuidForCreation);
let createAddressResponse = trackTraceAPI.Library.requestToTrackTrace("POST", requestUrl, customerAddressArr[i], configurationSearch);
addressSetInRecord(customerRecord, addressSubId,createAddressResponse, createAddressResponse.code, i);
} catch (e) {
log.error("error@create", e)
}
}
}
}
}
else {
let createResponse;
customerDataObj = trackTraceCustomerProcess(customerRecord);
if (jjUtil.checkForParameter(customerDataObj)) {
requestUrl = configurationSearch?.domain + '/' + configurationSearch?.version + trackTraceAPI.Library.TRACKTRACERX_API_REQUESTS.tradingPartnerCreate
createResponse = trackTraceAPI.Library.requestToTrackTrace("POST", requestUrl, customerDataObj, configurationSearch);
valueSetInRecord(customerRecord, createResponse, createResponse.code);
let customerNewOneUuid = createResponse.body.uuid;
if (jjUtil.checkForParameter(customerNewOneUuid)) {
let addressCustomerObj = customerData(customerRecord, addressSubId);
customerAddressArr = trackTraceCustomerAddressProcess(addressCustomerObj, addressSubId);
if (jjUtil.checkForParameter(customerAddressArr)) {
for (let i = 0; i < customerAddressArr.length; i++) {
try {
requestUrl = (
configurationSearch?.domain + '/' + configurationSearch?.version +
trackTraceAPI.Library.TRACKTRACERX_API_REQUESTS.tradingPartnerAddressBookCreate
).replace("{uuid}", customerNewOneUuid);
let createAddressResponse = trackTraceAPI.Library.requestToTrackTrace("POST", requestUrl, customerAddressArr[i], configurationSearch);
addressSetInRecord(customerRecord,addressSubId, createAddressResponse, createAddressResponse.code, i);
} catch (e) {
log.error("error@create", e)
}
}
}
}
}
}
}
}
}
}
}
} catch (e) {
log.error("error@afterSubmit", e)
}
}
return { beforeLoad, beforeSubmit, afterSubmit }
});