Description
Jira Code : MICL-180
The below code can be reused for fetching the details from NetSuite using the Restlet GET API
Only we need to change the parameters , validations and saved searches
Solution
/**
* @NApiVersion 2.1
* @NScriptType Restlet
*/
define(["N/https", "N/record", "N/runtime", "N/search", "N/url"],
/**
* @param{https} https
* @param{record} record
* @param{runtime} runtime
* @param{search} search
* @param{url} url
*/
(https,record, runtime, search, url) =>
{
let PAGE_SIZE = 30;
let API = "MADI_PRICELIST";
/**
* @description the function to check whether a value exists in parameter
* @param parameter -passing parameter
* @param parameterName - passing parameter name
* @returns{Boolean}
*/
function checkForParameter(parameter, parameterName) {
if (
parameter != "" &&
parameter != null &&
parameter != undefined &&
parameter != "null" &&
parameter != "undefined" &&
parameter != " " &&
parameter != false
)
{
return true;
}
else {
if (parameterName)
log.debug("Empty Value found", "Empty Value for parameter " + parameterName );
return false;
}
}
/**
* @description the function to check whether a value exists in parameter
* @param customRecInformations
* @returns{Boolean}
*/
function processResponseDetails(customRecInformations)
{
let results = []; let response = [];
let customRecArray = [];
for (let line of customRecInformations)
{
let customRecrObj = line;
let Index = customRecArray.indexOf(customRecrObj["Internal ID"]["value"]);
if (Index == -1)
{
results.push({
madi_price_integration_internalid: customRecrObj["Internal ID"]["value"],
madi_price_integration_name: customRecrObj["Name"]["value"],
parent_item : customRecrObj["Parent Item"]["text"],
currency : customRecrObj["Currency"]["text"],
country : customRecrObj["Country"]["text"],
uae_baseprice: customRecrObj["UAE Base Price"]["value"],
uae_discount: customRecrObj["UAE Discount"]["value"],
ksa_baseprice: customRecrObj["KSA Base Price"]["value"],
ksa_discount: customRecrObj["KSA Discount"]["value"],
omn_baseprice: customRecrObj["OMN Base Price"]["value"],
omn_discount: customRecrObj["OMN Discount"]["value"],
qat_baseprice: customRecrObj["QAT Base Price"]["value"],
qat_discount: customRecrObj["QAT Discount"]["value"],
bah_baseprice: customRecrObj["BAH Base Price"]["value"],
bah_discount: customRecrObj["BAH Discount"]["value"],
date_created : customRecrObj["Date Created"]["value"],
last_modified_by : customRecrObj["Last Modified By"]["text"],
});
customRecArray.push(customRecrObj["Internal ID"]["value"]);
}
}
// response.push(results);
return results;
}
/** dataSets from Saved Search and formating Saved Search results **/
const dataSets = {
fetchSavedSearchColumn: function (savedSearchObj, priorityKey) { //to format saved search column to key-value pair
var columns = savedSearchObj.columns;
var columnsData = {},
columnName = '';
columns.forEach(function (result, counter) {
columnName = '';
if (result[priorityKey]) {
columnName += result[priorityKey];
} else {
if (result.summary)
columnName += result.summary + '__';
if (result.formula)
columnName += result.formula + '__';
if (result.join)
columnName += result.join + '__';
columnName += result.name;
}
columnsData[columnName] = result;
});
return columnsData;
},
formatSingleSavedSearchResult: function (searchResult, columns) { //to fetch and format the single saved search result
var responseObj = {};
for (var column in columns)
responseObj[column] = {
value: searchResult.getValue(columns[column]),
text: searchResult.getText(columns[column])
};
return responseObj;
},
iterateSavedSearch: function (searchObj, columns, PAGE_INDEX, PAGE_SIZE) { //to iterate over and initiate format of each saved search result
if (!checkForParameter(searchObj))
return false;
if (!checkForParameter(columns))
columns = dataSets.fetchSavedSearchColumn(searchObj);
var response = [];
var searchPageRanges;
try {
searchPageRanges = searchObj.runPaged({
pageSize: Number.isInteger(Number(PAGE_SIZE)) ? parseInt(Number(PAGE_SIZE)) : 30 //Default Page Size
});
} catch (err) {
return Number.isInteger(PAGE_INDEX) ? {
pageInfo: {
pageLength: 1,
pageIndex: 1,
isLastPage: true
},
lines: []
} : [];
}
if (searchPageRanges.pageRanges.length < 1)
return Number.isInteger(PAGE_INDEX) ? {
pageInfo: {
pageLength: 1,
pageIndex: 1,
isLastPage: true
},
lines: []
} : [];
var pageRangeLength = searchPageRanges.pageRanges.length;
log.debug('pageRangeLength', pageRangeLength);
//To make sure the pageIndex has minimum value of one and maximum value of pageRangeLength
const pageIndexRangeRectifier = function (value, pageRange) {
if (!Number.isInteger(Number(value)))
return 1;
if ((Number(value) - 1) <= 0)
return 1;
if ((Number(value) - 1) >= Number(pageRange))
return Number(pageRange);
return Number(value);
};
if (Number.isInteger(PAGE_INDEX))
searchPageRanges.fetch({
index: pageIndexRangeRectifier(PAGE_INDEX, pageRangeLength) - 1
}).data.forEach(function (result) {
response.push(dataSets.formatSingleSavedSearchResult(result, columns));
});
else
for (var pageIndex = 0; pageIndex < pageRangeLength; pageIndex++)
searchPageRanges.fetch({
index: pageIndex
}).data.forEach(function (result) {
response.push(dataSets.formatSingleSavedSearchResult(result, columns));
});
return Number.isInteger(PAGE_INDEX) ? {
pageInfo: {
pageLength: pageRangeLength,
pageIndex: Number(pageIndexRangeRectifier(PAGE_INDEX, pageRangeLength)),
isLastPage: Number(pageIndexRangeRectifier(PAGE_INDEX, pageRangeLength)) >= Number(pageRangeLength) ? true : false
},
lines: response
} : response;
},
// To check whether the passed currency is exists in NetSuite
fetchCurrency: (currencyName) => {
try
{
let currencySearchObj = search.create({
type: "currency",
filters:
[
["name","is",currencyName],
"AND",
["isinactive","is","F"]
],
columns:
[
search.createColumn({ name: "internalid", label: "InternalID" })
]
});
let searchResultCount = currencySearchObj.runPaged().count;
if(searchResultCount > 0)
//return dataSets.iterateSavedSearch(currencySearchObj, dataSets.fetchSavedSearchColumn(currencySearchObj, 'label'));
return dataSets.iterateSavedSearch(currencySearchObj, dataSets.fetchSavedSearchColumn(currencySearchObj, 'label'));
else
return false;
}
catch (e) {
log.error("Error @ fetchCurrency", e);
return false;
}
},
getcustomRecordIDs: function ( currency , pageIndex )
{
const searchFilters = [
["isinactive","is","F"]
];
if (checkForParameter(currency))
searchFilters.push("AND", ["custrecordsf_currency_integ","anyof",currency]);
const customrecord_price_integSearchObj = search.create({
type: "customrecordsf_price_integ",
filters: searchFilters,
columns: [
search.createColumn({ name: "internalid", label: "Internal ID" }),
],
});
const searchResultCount = customrecord_price_integSearchObj.runPaged().count;
log.debug("searchResultCount",searchResultCount);
if(searchResultCount>0)
{
return dataSets.iterateSavedSearch(customrecord_price_integSearchObj, dataSets.fetchSavedSearchColumn(customrecord_price_integSearchObj, 'label'), pageIndex, 30);
}
else return false;
},
getCustomRecordResults: (customRecIDs) => {
try {
if (checkForParameter(customRecIDs) && util.isArray(customRecIDs) && (customRecIDs.length)) {
let madi_Price_Integration_Search = search.create({
type: "customrecordsf_price_integ",
filters:
[
["isinactive", "is", "F"],
"AND",
["internalid", "anyof", ...customRecIDs],
],
columns: [
search.createColumn({name: "internalid", label: "Internal ID"}),
search.createColumn({
name: "name",
sort: search.Sort.ASC,
label: "Name"
}),
search.createColumn({name: "custrecord37", label: "Parent Item"}),
search.createColumn({name: "custrecordsf_currency_integ", label: "Currency"}),
search.createColumn({name: "custrecord38", label: "Country"}),
search.createColumn({name: "custrecordsf_uaeprice_integ", label: "UAE Base Price"}),
search.createColumn({name: "custrecordsf_aedprice_integ", label: "UAE Discount"}),
search.createColumn({name: "custrecord36", label: "KSA Base Price"}),
search.createColumn({name: "custrecordsf_ksaprice_integ", label: "KSA Discount"}),
search.createColumn({name: "custrecordomnprice_integ", label: "OMN Base Price"}),
search.createColumn({name: "custrecord39", label: "OMN Discount"}),
search.createColumn({name: "custrecord40", label: "QAT Base Price"}),
search.createColumn({name: "custrecord41", label: "QAT Discount"}),
search.createColumn({name: "custrecord42", label: "BAH Base Price"}),
search.createColumn({name: "custrecord43", label: "BAH Discount"}),
search.createColumn({name: "created", label: "Date Created"}),
search.createColumn({name: "lastmodifiedby", label: "Last Modified By"})
],
});
const searchResultCount = madi_Price_Integration_Search.runPaged().count;
log.debug("Madi_Price_Integration_Search result count", searchResultCount);
return dataSets.iterateSavedSearch(madi_Price_Integration_Search, dataSets.fetchSavedSearchColumn(madi_Price_Integration_Search, 'label'));
}
}
catch (e) {
log.error("Error @ getCustomRecordResults", e);
return false;
}
}
}
/**
* Defines the function that is executed when a GET request is sent to a RESTlet.
* @param {Object} requestParams - Parameters from HTTP request URL; parameters passed as an Object (for all supported
* content types)
* @returns {string | Object} HTTP response body; returns a string when request Content-Type is 'text/plain'; returns an
* Object when request Content-Type is 'application/json' or 'application/xml'
* @since 2015.2
*/
const get = (requestParams) =>
{
try
{
log.debug("requestParams", requestParams);
const requestObj = {
Currency: requestParams?.Currency,
pageIndex: requestParams?.pageIndex,
};
log.debug("requestObj", requestObj);
// log.debug("requestObj = Cur ", checkForParameter(requestObj?.Currency));
// log.debug("requestObj = Page 1", checkForParameter(requestObj?.pageIndex));
// log.debug("requestObj = Page 2 (false) for number", isNaN(Number(requestObj?.pageIndex)));
// ========================== NO PARAMETERS ============================================================
if ( checkForParameter(requestObj?.pageIndex) == false && checkForParameter(requestObj?.Currency) == false )
{
try
{
return JSON.stringify({
summary: {
status: "FAILURE",
reason: "PARAMETER_IS_INVALID"
},
result: {
pageInfo: {
pageLength: 0,
pageIndex: 0,
isLastPage: true
},
lines: []
}
});
}
catch(e)
{
log.debug("Error @ checking both parameter", e);
return JSON.stringify({
summary: {
status: "FAILURE",
reason: "PARAMETER_IS_INVALID"
},
result: {
pageInfo: {
pageLength: 0,
pageIndex: 0,
isLastPage: true
},
lines: []
}
});
}
}
// =================================== Currency Validation =============================================
let currencyName = requestObj.Currency;
let currencyID ;
if (checkForParameter(currencyName)) // if the currency is not empty
{
try
{
currencyName = currencyName.toString().toUpperCase();
// if the currency is not exists in the NetSuite
currencyID = dataSets.fetchCurrency(currencyName);
if ( currencyID == false )
{
return JSON.stringify({
summary: {
status: "FAILURE",
reason: "CURRENCY_IS_INVALID"
},
result: {
pageInfo: {
pageLength: 0,
pageIndex: 0,
isLastPage: true
},
lines: []
}
});
}
}
catch (e)
{
log.debug("Error@ currency Format", e);
return JSON.stringify({
summary: {
status: "FAILURE",
reason: "CURRENCY_IS_INVALID"
},
result: {
pageInfo: {
pageLength: 0,
pageIndex: 0,
isLastPage: true
},
lines: []
}
});
}
}
if (checkForParameter(currencyName) == false)
{
try
{
return JSON.stringify({
summary: {
status: "FAILURE",
reason: "CURRENCY_IS_INVALID"
},
result: {
pageInfo: {
pageLength: 0,
pageIndex: 0,
isLastPage: true
},
lines: []
}
});
}
catch (e) {
return JSON.stringify({
summary: {
status: "FAILURE",
reason: "CURRENCY_IS_INVALID"
},
result: {
pageInfo: {
pageLength: 0,
pageIndex: 0,
isLastPage: true
},
lines: []
}
});
}
}
// ============================== pageIndex validation =================================================
if ( (checkForParameter(requestObj?.pageIndex) == false) || isNaN(Number(requestObj?.pageIndex)) )
{
return JSON.stringify({
summary: {
status: "FAILURE",
reason: "PAGENUMBER_FORMAT_IS_INVALID"
},
result: {
pageInfo: {
pageLength: 0,
pageIndex: 0,
isLastPage: true
},
lines: []
}
});
}
requestObj.pageIndex = Number(requestObj.pageIndex) < 1 ? 1 : Number(requestObj.pageIndex);
currencyID = currencyID[0].InternalID.value;
let customRecordID = dataSets.getcustomRecordIDs(currencyID, requestObj?.pageIndex);
if (customRecordID) {
const customRecInternalIds = customRecordID.lines.map(el => el["Internal ID"]["value"]);
log.debug("customRecInternalId", customRecInternalIds);
const customRecInformations = dataSets.getCustomRecordResults(customRecInternalIds);
const processedResponse = processResponseDetails(customRecInformations);
return JSON.stringify({
summary: {
status: "SUCCESS",
reason: "RECORD_FOUND"
},
result: {
pageInfo: customRecordID.pageInfo,
lines: processedResponse
}
});
}
else {
return JSON.stringify({
summary: {
status: "SUCCESS",
reason: "RECORD_NOT_FOUND"
},
result: {
pageInfo: {
pageLength: 0,
pageIndex: 0,
isLastPage: true
},
lines: []
}
});
}
}
catch (e)
{
log.debug("Error @ get", e );
return JSON.stringify({
summary: {
status: "FAILURE",
reason: "ERROR"
},
result: {
pageInfo: {
pageLength: 0,
pageIndex: 0,
isLastPage: true
},
lines: []
}
});
}
}
return { get }
});