Jira Code: NMS-1004
Suite billing API is used to create a customer record, sales order record, subscription record in NetSuite from external sources. Resets are set up in to receive the external calls.
Customer API
/**
* @NApiVersion 2.x
* @NScriptType Restlet
* @NModuleScope SameAccount
*/
/**
* Script Description
* Script contains a RESTlet to Handle Customer API
* Date Created : 08-September-2018
*/
/*******************************************************************************
* $Author: EDD
*
*
*
******************************************************************************/
define(['N/format', 'N/record', 'N/runtime', 'N/search', 'N/log'],
function(format, record, runtime, search, log) {
//To check whether a value exists in parameter
function checkForParameter(parameter, parameterName) {
if (parameter != "" && parameter !== null && parameter !== undefined && parameter !== false && parameter !== "null" && parameter !== "undefined" && parameter !== 'false' && parameter != " ")
return true;
else {
if (parameterName)
log.debug('Empty Value found', 'Empty Value for parameter ' + parameterName);
return false;
}
}
//To assign a default value if the it is empty
function assignDefaultValue(value, defaultValue) {
if (checkForParameter(value))
return value;
else
return defaultValue;
}
//returns error
function getError(e) {
var stErrMsg = '';
if (e.getDetails != undefined) {
stErrMsg = '_' + e.getCode() + '<br>' + e.getDetails() + '<br>' +
e.getStackTrace();
} else {
stErrMsg = '_' + e.toString();
}
return stErrMsg;
}
//main or root object for this entire restlet scritpt
var main = {
addAddressEntry: function(addressObj, customerRecord) {
//Add Address
var selectLine = customerRecord.selectNewLine({
sublistId: 'addressbook'
});
customerRecord.setCurrentSublistValue({
sublistId: 'addressbook',
fieldId: 'defaultshipping',
value: addressObj['defaultshipping']
});
delete addressObj['defaultshipping'];
customerRecord.setCurrentSublistValue({
sublistId: 'addressbook',
fieldId: 'defaultbilling',
value: addressObj['defaultbilling']
});
delete addressObj['defaultbilling'];
var myaddressSubrecord = customerRecord.getCurrentSublistSubrecord({
sublistId: 'addressbook',
fieldId: 'addressbookaddress'
});
for (var key in addressObj) {
try {
myaddressSubrecord.setValue({
fieldId: key.toLowerCase(),
value: addressObj[key]
});
} catch (er1) {
try {
myaddressSubrecord.setText({
fieldId: key.toLowerCase(),
text: addressObj[key]
});
} catch (er2) {
return {
summary: {
status: 'FAILED',
message: getError(er2)
}
};
}
}
}
customerRecord.commitLine({
sublistId: 'addressbook'
});
return {
summary: {
status: 'SUCCESS',
message: 'ADDRESS COMITTED'
}
};
},
doPut: function(requestBody) {
requestBody = JSON.parse(requestBody);
requestBody = requestBody.customer;
var response;
var customerRecord = record.create({
type: record.Type.CUSTOMER,
isDynamic: true
});
for (var key in requestBody) {
if (key != 'addressbookList') {
try {
customerRecord.setValue({
fieldId: key.toLowerCase(),
value: requestBody[key]
});
} catch (er1) {
try {
customerRecord.setText({
fieldId: key.toLowerCase(),
text: requestBody[key]
});
} catch (er2) {
return {
summary: {
status: 'FAILED',
message: getError(er2)
}
};
}
}
} else {
for (var index = 0, len = requestBody[key].length; index < len; index++) {
response = main.addAddressEntry(requestBody[key][index], customerRecord);
if (response.summary.status == 'FAILED')
return response;
}
}
}
var recordID = customerRecord.save({
enableSourcing: true,
ignoreMandatoryFields: true
});
return {
summary: {
status: 'SUCCESS',
message: 'CUSTOMER CREATED'
},
details: {
internalid: recordID
}
};
},
put: function(requestBody) {
/**
* Function called upon sending a PUT request to the RESTlet.
*
* @param {string | Object} requestBody - The HTTP request body; request body will be passed into function as a string when request Content-Type is 'text/plain'
* or parsed into an Object when request Content-Type is 'application/json' (in which case the body must be a valid JSON)
* @returns {string | Object} HTTP response body; return string when request Content-Type is 'text/plain'; return Object when request Content-Type is 'application/json'
* @since 2015.2
*/
var response = main.doPut(requestBody);
return JSON.stringify(response);
},
doPost: function(requestBody) {
requestBody = JSON.parse(requestBody);
requestBody = requestBody.customer;
var response;
var customerRecord = record.load({
type: record.Type.CUSTOMER,
id: requestBody.internalId,
isDynamic: true,
});
for (var key in requestBody) {
if (key != 'addressbookList') {
try {
customerRecord.setValue({
fieldId: key.toLowerCase(),
value: requestBody[key]
});
} catch (er1) {
try {
customerRecord.setText({
fieldId: key.toLowerCase(),
text: requestBody[key]
});
} catch (er2) {
return {
summary: {
status: 'FAILED',
message: getError(er2)
}
};
}
}
} else {
for (var index = 0, len = requestBody[key].length; index < len; index++) {
response = main.addAddressEntry(requestBody[key][index], customerRecord);
if (response.summary.status == 'FAILED')
return response;
}
}
}
var recordID = customerRecord.save({
enableSourcing: true,
ignoreMandatoryFields: true
});
return {
summary: {
status: 'SUCCESS',
message: 'CUSTOMER UPDATED'
},
details: {
internalid: recordID
}
};
},
post: function(requestBody) {
/**
* Function called upon sending a POST request to the RESTlet.
*
* @param {string | Object} requestBody - The HTTP request body; request body will be passed into function as a string when request Content-Type is 'text/plain'
* or parsed into an Object when request Content-Type is 'application/json' (in which case the body must be a valid JSON)
* @returns {string | Object} HTTP response body; return string when request Content-Type is 'text/plain'; return Object when request Content-Type is 'application/json'
* @since 2015.2
*/
var response = main.doPost(requestBody);
return JSON.stringify(response);
},
doGet: function(requestParams) {
log.debug('requestParams', requestParams);
log.debug('requestParams.internalid', requestParams.internalid);
var customerRecord = record.load({
type: record.Type.CUSTOMER,
id: requestParams.internalid,
isDynamic: true,
});
var fieldID = ['externalId', 'entityid', 'customform', 'subsidiary', 'isperson', 'companyname', 'entitystatus', 'receivablesaccount', 'custentity_customer_channel_tier', 'email', 'vatregnumber', 'taxitem', 'terms'];
var details = {},
addressLineDetails = [],
addressLineObj = {};
for (var index = 0, len = fieldID.length; index < len; index++)
details[fieldID[index]] = {
value: assignDefaultValue(customerRecord.getValue({
fieldId: fieldID[index]
}), ''),
text: assignDefaultValue(customerRecord.getText({
fieldId: fieldID[index]
}), '')
};
fieldID = ['country', 'attention', 'addressee', 'addrphone', 'addr1', 'addr2', 'city', 'state', 'zip'];
var addressLines = customerRecord.getLineCount({
sublistId: 'addressbook'
});
for (var index = 0, len = fieldID.length; index < len; index++) {
for (address_index = 0; address_index < addressLines; address_index++) {
addressLineObj = undefined;
addressLineObj = {};
addressLineObj[fieldID[index]] = {
value: assignDefaultValue(customerRecord.getValue({
fieldId: fieldID[index]
}), ''),
text: assignDefaultValue(customerRecord.getText({
fieldId: fieldID[index]
}), '')
};
details['addressbookList'][fieldID[index]] = {
};
}
}
return {
summary: {
status: 'SUCCESS',
message: 'CUSTOMER FTECHED SUCCESSFULLY'
},
details: details
};
},
'get': function(requestParams) {
/**
* Function called upon sending a GET request to the RESTlet.
*
* @param {Object} requestParams - Parameters from HTTP request URL; parameters will be passed into function as an Object (for all supported content types)
* @returns {string | Object} HTTP response body; return string when request Content-Type is 'text/plain'; return Object when request Content-Type is 'application/json'
* @since 2015.1
*/
var response = main.doGet(requestParams);
return JSON.stringify(response);
},
'delete': function(requestParams) {
/**
* Function called upon sending a DELETE request to the RESTlet.
*
* @param {Object} requestParams - Parameters from HTTP request URL; parameters will be passed into function as an Object (for all supported content types)
* @returns {string | Object} HTTP response body; return string when request Content-Type is 'text/plain'; return Object when request Content-Type is 'application/json'
* @since 2015.2
*/
var response = {
summary: {
status: 'FAILED',
message: 'API Not Supported'
}
};
return JSON.stringify(response);
},
remainingUsage: function() {
//var scriptObj = runtime.getCurrentScript();
var remainingTime = runtime.getCurrentScript().getRemainingUsage();
return remainingTime;
}
};
for (var key in main) {
if (typeof main[key] === 'function') {
main[key] = trycatch(main[key], key);
}
}
function trycatch(myfunction, key) {
function logDetails(error) {
//log.debug("Error in function " + key, JSON.stringify(error));
log.debug('Error on function ' + key, JSON.stringify(getError(error)));
//log.error("Error in function " + key, JSON.stringify(error));
log.error('Error on function ' + key, JSON.stringify(getError(error)));
}
return function() {
try {
return myfunction.apply(this, arguments);
} catch (error) {
logDetails(error);
var response = {
summary: {
status: 'FAILED',
message: error
}
};
return response;
}
};
}
return main;
});Sales Order API
/**
* @NApiVersion 2.x
* @NScriptType Restlet
* @NModuleScope SameAccount
*/
/**
* Script Description
* Script contains a RESTlet to Handle SalesOrder API
* Date Created : 08-September-2018
*/
/*******************************************************************************
* $Author: Jobin & Jismi IT Services LLP
*
*
*
*
******************************************************************************/
define(['N/format', 'N/record', 'N/runtime', 'N/search', 'N/log'],
function(format, record, runtime, search, log) {
//To check whether a value exists in parameter
function checkForParameter(parameter, parameterName) {
if (parameter != "" && parameter !== null && parameter !== undefined && parameter !== false && parameter !== "null" && parameter !== "undefined" && parameter !== 'false' && parameter != " ")
return true;
else {
if (parameterName)
log.debug('Empty Value found', 'Empty Value for parameter ' + parameterName);
return false;
}
}
//To assign a default value if the it is empty
function assignDefaultValue(value, defaultValue) {
if (checkForParameter(value))
return value;
else
return defaultValue;
}
//returns error
function getError(e) {
var stErrMsg = '';
if (e.getDetails != undefined) {
stErrMsg = '_' + e.getCode() + '<br>' + e.getDetails() + '<br>' +
e.getStackTrace();
} else {
stErrMsg = '_' + e.toString();
}
return stErrMsg;
}
//main or root object for this entire restlet scritpt
var main = {
removAlllines: function(objRecord, lineCount) {
log.debug("lineCount", lineCount);
for (var i = 0; i <= lineCount; i++) {
objRecord.removeLine({
sublistId: 'item',
line: 0,
ignoreRecalc: true
});
}
return objRecord;
},
doPut: function(requestBody) {
//requestBody = JSON.parse(requestBody);
requestBody = requestBody.salesorder;
var response;
var salesRecord = record.create({
type: "salesorder",
isDynamic: true
});
for (var key in requestBody) {
if (key != 'item') {
try {
salesRecord.setValue({
fieldId: key.toLowerCase(),
value: requestBody[key]
});
} catch (er1) {
try {
salesRecord.setText({
fieldId: key.toLowerCase(),
text: requestBody[key]
});
} catch (er2) {
return {
summary: {
status: 'FAILED',
message: getError(er2),
timeStamp: Date.now()
}
};
}
}
} else {
for (var index = 0, len = requestBody[key].length; index < len; index++) {
var currentItem = requestBody[key][index];
var selectLine = salesRecord.selectNewLine({
sublistId: 'item'
});
for (var linekey in currentItem) {
try {
salesRecord.setCurrentSublistValue({
sublistId: 'item',
fieldId: linekey,
value: currentItem[linekey]
});
} catch (e) {
salesRecord.setCurrentSublistText({
sublistId: 'item',
fieldId: 'item',
text: currentItem[linekey]
});
log.debug("e", e);
}
}
salesRecord.commitLine({
sublistId: 'item'
});
}
}
}
var recordID = salesRecord.save({
enableSourcing: true,
ignoreMandatoryFields: true
});
salesRecord = record.load({
type: "salesorder",
id: recordID,
isDynamic: false,
});
var detailsObj = {};
detailsObj.internalid = {
value: salesRecord.id,
text: salesRecord.id
};
var fieldID = ['externalid', 'datecreated', 'lastmodifieddate'];
fieldID.forEach(function(result) {
try {
detailsObj[result] = {
value: assignDefaultValue(salesRecord.getValue({
fieldId: (result).toLowerCase(),
}), ''),
text: assignDefaultValue(salesRecord.getText({
fieldId: (result).toLowerCase(),
}), '')
};
} catch (er2) {
detailsObj[result] = {
value: assignDefaultValue(salesRecord.getValue({
fieldId: (result).toLowerCase(),
}), ''),
text: ''
};
}
});
return {
summary: {
status: 'SUCCESS',
message: 'SalesOrder CREATED',
timeStamp: Date.now()
},
details: detailsObj
};
},
put: function(requestBody) {
/**
* Function called upon sending a PUT request to the RESTlet.
*
* @param {string | Object} requestBody - The HTTP request body; request body will be passed into function as a string when request Content-Type is 'text/plain'
* or parsed into an Object when request Content-Type is 'application/json' (in which case the body must be a valid JSON)
* @returns {string | Object} HTTP response body; return string when request Content-Type is 'text/plain'; return Object when request Content-Type is 'application/json'
* @since 2015.2
*/
var response = main.doPut(requestBody);
log.debug("response", response);
return JSON.stringify(response);
},
doPost: function(requestBody) {
// requestBody = JSON.parse(requestBody);
requestBody = requestBody.salesorder;
var response;
var salesRecord = record.load({
type: "salesorder",
id: requestBody.internalid,
isDynamic: true,
});
for (var key in requestBody) {
if (key != 'item') {
try {
salesRecord.setValue({
fieldId: key.toLowerCase(),
value: requestBody[key]
});
} catch (er1) {
try {
salesRecord.setText({
fieldId: key.toLowerCase(),
text: requestBody[key]
});
} catch (er2) {
return {
summary: {
status: 'FAILED',
message: getError(er2),
timeStamp: Date.now()
}
};
}
}
} else {
var lineCount = salesRecord.getLineCount({
sublistId: 'item'
});
main.removAlllines(salesRecord, lineCount);
for (var index = 0, len = requestBody[key].length; index < len; index++) {
var currentItem = requestBody[key][index];
for (var linekey in currentItem) {
var selectLine = salesRecord.selectNewLine({
sublistId: 'item'
});
try {
salesRecord.setCurrentSublistValue({
sublistId: 'item',
fieldId: linekey,
value: currentItem[linekey]
});
} catch (esub1) {
try {
log.debug("new esub1", esub1);
salesRecord.setCurrentSublistText({
sublistId: 'item',
fieldId: linekey,
text: currentItem[linekey]
});
} catch (esub) {
return {
summary: {
status: 'FAILED',
message: getError(esub),
timeStamp: Date.now()
}
};
}
}
}
salesRecord.commitLine({
sublistId: 'item'
});
}
}
}
var recordID = salesRecord.save({
enableSourcing: true,
ignoreMandatoryFields: true
});
salesRecord = record.load({
type: "salesorder",
id: recordID,
isDynamic: false,
});
var detailsObj = {};
detailsObj.internalid = {
value: salesRecord.id,
text: salesRecord.id
};
var fieldID = ['externalid', 'datecreated', 'lastmodifieddate'];
fieldID.forEach(function(result) {
try {
detailsObj[result] = {
value: assignDefaultValue(salesRecord.getValue({
fieldId: (result).toLowerCase(),
}), ''),
text: assignDefaultValue(salesRecord.getText({
fieldId: (result).toLowerCase(),
}), '')
};
} catch (er2) {
detailsObj[result] = {
value: assignDefaultValue(salesRecord.getValue({
fieldId: (result).toLowerCase(),
}), ''),
text: ''
};
}
});
return {
summary: {
status: 'SUCCESS',
message: 'SalesOrder UPDATED',
timeStamp: Date.now()
},
details: detailsObj
};
},
post: function(requestBody) {
/**
* Function called upon sending a POST request to the RESTlet.
*
* @param {string | Object} requestBody - The HTTP request body; request body will be passed into function as a string when request Content-Type is 'text/plain'
* or parsed into an Object when request Content-Type is 'application/json' (in which case the body must be a valid JSON)
* @returns {string | Object} HTTP response body; return string when request Content-Type is 'text/plain'; return Object when request Content-Type is 'application/json'
* @since 2015.2
*/
var response = main.doPost(requestBody);
return JSON.stringify(response);
},
doGet: function(requestParams) {
log.debug('requestParams', requestParams);
log.debug('requestParams.internalid', requestParams.internalid);
var salesRecord = record.load({
type: "salesorder",
id: requestParams.internalid,
isDynamic: true,
});
var fieldID = ['externalId', 'internalId', 'customform', 'entity', 'trandate', 'orderstatus', 'custbody_order_type', 'custbody_end_user', 'otherrefnum'];
var details = {},
addressLineDetails = [],
addressLineObj = {};
for (var index = 0, len = fieldID.length; index < len; index++)
details[fieldID[index]] = {
value: assignDefaultValue(salesRecord.getValue({
fieldId: fieldID[index]
}), ''),
text: assignDefaultValue(salesRecord.getText({
fieldId: fieldID[index]
}), '')
};
details.internalId = requestParams.internalid;
var lineID = ['item', 'quantity', 'amount'];
var itemLines = salesRecord.getLineCount({
sublistId: 'item'
});
var item = [];
for (item_index = 0; item_index < itemLines; item_index++) {
var itemLineObj = {};
for (var key in lineID) {
try {
itemLineObj[lineID[key]] = {
value: assignDefaultValue(salesRecord.getSublistValue({
sublistId: 'item',
fieldId: lineID[key],
line: item_index
}), ''),
text: assignDefaultValue(salesRecord.getSublistText({
sublistId: 'item',
fieldId: lineID[key],
line: item_index
}), '')
};
} catch (er2) {
itemLineObj[lineID[key]] = {
value: assignDefaultValue(salesRecord.getSublistValue({
sublistId: 'item',
fieldId: lineID[key],
line: item_index
}), ''),
text: ''
};
}
}
item.push(itemLineObj);
}
details.item = item;
return {
summary: {
status: 'SUCCESS',
message: 'SalesOrder Fetched',
timeStamp: Date.now()
},
details: details
};
},
'get': function(requestParams) {
/**
* Function called upon sending a GET request to the RESTlet.
*
* @param {Object} requestParams - Parameters from HTTP request URL; parameters will be passed into function as an Object (for all supported content types)
* @returns {string | Object} HTTP response body; return string when request Content-Type is 'text/plain'; return Object when request Content-Type is 'application/json'
* @since 2015.1
*/
var response = main.doGet(requestParams);
return JSON.stringify(response);
},
'delete': function(requestParams) {
/**
* Function called upon sending a DELETE request to the RESTlet.
*
* @param {Object} requestParams - Parameters from HTTP request URL; parameters will be passed into function as an Object (for all supported content types)
* @returns {string | Object} HTTP response body; return string when request Content-Type is 'text/plain'; return Object when request Content-Type is 'application/json'
* @since 2015.2
*/
var response = {
summary: {
status: 'FAILED',
message: 'API Not Supported',
timeStamp: Date.now()
}
};
return JSON.stringify(response);
},
remainingUsage: function() {
//var scriptObj = runtime.getCurrentScript();
var remainingTime = runtime.getCurrentScript().getRemainingUsage();
return remainingTime;
}
};
for (var key in main) {
if (typeof main[key] === 'function') {
main[key] = trycatch(main[key], key);
}
}
function trycatch(myfunction, key) {
function logDetails(error) {
//log.debug("Error in function " + key, JSON.stringify(error));
log.debug('Error on function ' + key, JSON.stringify(getError(error)));
//log.error("Error in function " + key, JSON.stringify(error));
log.error('Error on function ' + key, JSON.stringify(getError(error)));
}
return function() {
try {
return myfunction.apply(this, arguments);
} catch (error) {
logDetails(error);
var response = {
summary: {
status: 'FAILED',
message: error.message,
timeStamp: Date.now()
}
};
return response;
}
};
}
return main;
});Suvscription API
/**
* @NApiVersion 2.x
* @NScriptType Restlet
* @NModuleScope SameAccount
*/
/**
* Script Description
* Script contains a RESTlet to Handle subscription API
* Date Created : 17-September-2018
*/
/*******************************************************************************
* $Author: Jobin & Jismi IT Services LLP
*
*
*
*
******************************************************************************/
define(['N/format', 'N/record', 'N/runtime', 'N/search', 'N/log'],
function(format, record, runtime, search, log) {
//To check whether a value exists in parameter
function checkForParameter(parameter, parameterName) {
if (parameter != "" && parameter !== null && parameter !== undefined && parameter !== false && parameter !== "null" && parameter !== "undefined" && parameter !== 'false' && parameter != " ")
return true;
else {
if (parameterName)
log.debug('Empty Value found', 'Empty Value for parameter ' + parameterName);
return false;
}
}
//To assign a default value if the it is empty
function assignDefaultValue(value, defaultValue) {
if (checkForParameter(value))
return value;
else
return defaultValue;
}
//returns error
function getError(e) {
var stErrMsg = '';
if (e.getDetails != undefined) {
stErrMsg = '_' + e.getCode() + '<br>' + e.getDetails() + '<br>' +
e.getStackTrace();
} else {
stErrMsg = '_' + e.toString();
}
return stErrMsg;
}
//main or root object for this entire restlet scritpt
var main = {
removAlllines: function(objRecord, lineCount) {
log.debug("lineCount", lineCount);
for (var i = 0; i <= lineCount; i++) {
objRecord.removeLine({
sublistId: 'item',
line: 0,
ignoreRecalc: true
});
}
return objRecord;
},
doPut: function(requestBody) {
//requestBody = JSON.parse(requestBody);
requestBody = requestBody.subscription;
var response;
var subscriptionRecord = record.create({
type: "subscription",
isDynamic: true
});
for (var key in requestBody) {
log.debug(typeof requestBody[key], key);
if (typeof requestBody[key] != "object") {
try {
subscriptionRecord.setValue({
fieldId: key.toLowerCase(),
value: requestBody[key]
});
} catch (er1) {
try {
subscriptionRecord.setText({
fieldId: key.toLowerCase(),
text: requestBody[key]
});
} catch (er2) {
return {
summaryfield: {
status: 'FAILED',
message: getError(er2),
timeStamp: Date.now()
}
};
}
}
} else {
return {
summary: {
status: 'FAILED',
message: "Sublist Actions Not Supported",
timeStamp: Date.now()
}
};
}
}
var recordID = subscriptionRecord.save({
enableSourcing: true,
ignoreMandatoryFields: true
});
subscriptionRecord = record.load({
type: "subscription",
id: recordID,
isDynamic: false,
});
var detailsObj = {};
detailsObj.internalid = {
value: subscriptionRecord.id,
text: subscriptionRecord.id
};
var fieldID = ['externalid', 'datecreated', 'lastmodifieddate'];
fieldID.forEach(function(result) {
try {
detailsObj[result] = {
value: assignDefaultValue(subscriptionRecord.getValue({
fieldId: (result).toLowerCase(),
}), ''),
text: assignDefaultValue(subscriptionRecord.getText({
fieldId: (result).toLowerCase(),
}), '')
};
} catch (er2) {
detailsObj[result] = {
value: assignDefaultValue(subscriptionRecord.getValue({
fieldId: (result).toLowerCase(),
}), ''),
text: ''
};
}
});
return {
summary: {
status: 'SUCCESS',
message: 'subscription CREATED',
timeStamp: Date.now()
},
details: detailsObj
};
},
put: function(requestBody) {
/**
* Function called upon sending a PUT request to the RESTlet.
*
* @param {string | Object} requestBody - The HTTP request body; request body will be passed into function as a string when request Content-Type is 'text/plain'
* or parsed into an Object when request Content-Type is 'application/json' (in which case the body must be a valid JSON)
* @returns {string | Object} HTTP response body; return string when request Content-Type is 'text/plain'; return Object when request Content-Type is 'application/json'
* @since 2015.2
*/
var response = main.doPut(requestBody);
log.debug("response", response);
return JSON.stringify(response);
},
doPost: function(requestBody) {
//requestBody = JSON.parse(requestBody);
requestBody = requestBody.subscription;
var response;
var subscriptionRecord = record.load({
type: "subscription",
id: requestBody.internalid,
isDynamic: true,
});
for (var key in requestBody) {
if (key != 'item') {
try {
subscriptionRecord.setValue({
fieldId: key.toLowerCase(),
value: requestBody[key]
});
} catch (er1) {
try {
subscriptionRecord.setText({
fieldId: key.toLowerCase(),
text: requestBody[key]
});
} catch (er2) {
return {
summary: {
status: 'FAILED',
message: getError(er2),
timeStamp: Date.now()
}
};
}
}
} else {
return {
summary: {
status: 'FAILED',
message: "Sublist Actions Not Supported",
timeStamp: Date.now()
}
};
}
}
var recordID = subscriptionRecord.save({
enableSourcing: true,
ignoreMandatoryFields: true
});
subscriptionRecord = record.load({
type: "subscription",
id: recordID,
isDynamic: false,
});
var detailsObj = {};
detailsObj.internalid = {
value: subscriptionRecord.id,
text: subscriptionRecord.id
};
var fieldID = ['externalid', 'datecreated', 'lastmodifieddate'];
fieldID.forEach(function(result) {
try {
detailsObj[result] = {
value: assignDefaultValue(subscriptionRecord.getValue({
fieldId: (result).toLowerCase(),
}), ''),
text: assignDefaultValue(subscriptionRecord.getText({
fieldId: (result).toLowerCase(),
}), '')
};
} catch (er2) {
detailsObj[result] = {
value: assignDefaultValue(subscriptionRecord.getValue({
fieldId: (result).toLowerCase(),
}), ''),
text: ''
};
}
});
return {
summary: {
status: 'SUCCESS',
message: 'subscription UPDATED',
timeStamp: Date.now()
},
details: detailsObj
};
},
post: function(requestBody) {
/**
* Function called upon sending a POST request to the RESTlet.
*
* @param {string | Object} requestBody - The HTTP request body; request body will be passed into function as a string when request Content-Type is 'text/plain'
* or parsed into an Object when request Content-Type is 'application/json' (in which case the body must be a valid JSON)
* @returns {string | Object} HTTP response body; return string when request Content-Type is 'text/plain'; return Object when request Content-Type is 'application/json'
* @since 2015.2
*/
var response = main.doPost(requestBody);
return JSON.stringify(response);
},
doGet: function(requestParams) {
log.debug('requestParams', requestParams);
log.debug('requestParams.internalid', requestParams.internalid);
var subscriptionRecord = record.load({
type: "subscription",
id: requestParams.internalid,
isDynamic: true,
});
var fieldID = ['externalId', 'internalId', 'name', 'customer', 'billingaccount', 'subsidiary', 'currency', 'subscriptionplan', 'initialterm', 'pricebook', 'startdate', 'enddate'];
var details = {},
addressLineDetails = [],
addressLineObj = {};
for (var index = 0, len = fieldID.length; index < len; index++)
details[fieldID[index]] = {
value: assignDefaultValue(subscriptionRecord.getValue({
fieldId: fieldID[index]
}), ''),
text: assignDefaultValue(subscriptionRecord.getText({
fieldId: fieldID[index]
}), '')
};
details.internalId = requestParams.internalid;
var lineID = ['item', 'billingmode', 'status', 'linenumber', 'subscriptionline', 'startdate', 'enddate'];
var itemLines = subscriptionRecord.getLineCount({
sublistId: 'subscriptionline'
});
var item = [];
for (item_index = 0; item_index < itemLines; item_index++) {
var itemLineObj = {};
for (var key in lineID) {
try {
itemLineObj[lineID[key]] = {
value: assignDefaultValue(subscriptionRecord.getSublistValue({
sublistId: 'subscriptionline',
fieldId: lineID[key],
line: item_index
}), ''),
text: assignDefaultValue(subscriptionRecord.getSublistText({
sublistId: 'subscriptionline',
fieldId: lineID[key],
line: item_index
}), '')
};
} catch (er2) {
itemLineObj[lineID[key]] = {
value: assignDefaultValue(subscriptionRecord.getSublistValue({
sublistId: 'subscriptionline',
fieldId: lineID[key],
line: item_index
}), ''),
text: ''
};
}
}
item.push(itemLineObj);
}
details.item = item;
return {
summary: {
status: 'SUCCESS',
message: 'subscription Fetched',
timeStamp: Date.now()
},
details: details
};
},
'get': function(requestParams) {
/**
* Function called upon sending a GET request to the RESTlet.
*
* @param {Object} requestParams - Parameters from HTTP request URL; parameters will be passed into function as an Object (for all supported content types)
* @returns {string | Object} HTTP response body; return string when request Content-Type is 'text/plain'; return Object when request Content-Type is 'application/json'
* @since 2015.1
*/
var response = main.doGet(requestParams);
return JSON.stringify(response);
},
'delete': function(requestParams) {
/**
* Function called upon sending a DELETE request to the RESTlet.
*
* @param {Object} requestParams - Parameters from HTTP request URL; parameters will be passed into function as an Object (for all supported content types)
* @returns {string | Object} HTTP response body; return string when request Content-Type is 'text/plain'; return Object when request Content-Type is 'application/json'
* @since 2015.2
*/
var response = {
summary: {
status: 'FAILED',
message: 'API Not Supported',
timeStamp: Date.now()
}
};
return JSON.stringify(response);
},
remainingUsage: function() {
//var scriptObj = runtime.getCurrentScript();
var remainingTime = runtime.getCurrentScript().getRemainingUsage();
return remainingTime;
}
};
for (var key in main) {
if (typeof main[key] === 'function') {
main[key] = trycatch(main[key], key);
}
}
function trycatch(myfunction, key) {
function logDetails(error) {
//log.debug("Error in function " + key, JSON.stringify(error));
log.debug('Error on function ' + key, JSON.stringify(getError(error)));
//log.error("Error in function " + key, JSON.stringify(error));
log.error('Error on function ' + key, JSON.stringify(getError(error)));
}
return function() {
try {
return myfunction.apply(this, arguments);
} catch (error) {
logDetails(error);
var response = {
summary: {
status: 'FAILED',
message: error.message,
timeStamp: Date.now()
}
};
return response;
}
};
}
return main;
});