348 lines
11 KiB
JavaScript
348 lines
11 KiB
JavaScript
const path = require("path");
|
|
require("dotenv").config({
|
|
path: path.resolve(process.cwd(), `.env.${process.env.NODE_ENV || "development"}`)
|
|
});
|
|
|
|
const GraphQLClient = require("graphql-request").GraphQLClient;
|
|
// const CalcualteAllocations = require("../cdk/cdk-calculate-allocations").default;
|
|
const InstanceMgr = require("../utils/instanceMgr").default;
|
|
const CreateFortellisLogEvent = require("./fortellis-logger");
|
|
const queries = require("../graphql-client/queries");
|
|
const logger = require("../utils/logger");
|
|
const uuid = require("uuid").v4;
|
|
const AxiosLib = require("axios").default;
|
|
const axios = AxiosLib.create();
|
|
const axiosCurlirize = require('axios-curlirize').default;
|
|
|
|
axiosCurlirize(axios, (result, err) => {
|
|
const { command } = result;
|
|
console.log("*** ~ axiosCurlirize ~ command:", command);
|
|
|
|
// if (err) {
|
|
// use your logger here
|
|
// } else {
|
|
// }
|
|
});
|
|
|
|
const getTransactionType = (jobid) => `fortellis:${jobid}`;
|
|
const defaultFortellisTTL = 60 * 60;
|
|
|
|
async function GetAuthToken() {
|
|
//Done with Authorization Code Flow
|
|
//https://docs.fortellis.io/docs/tutorials/solution-integration/authorization-code-flow/
|
|
|
|
//TODO: This should get stored in the redis cache and only be refreshed when it expires.
|
|
const {
|
|
data: { access_token, expires_in, token_type }
|
|
} = await axios.post(
|
|
process.env.FORTELLIS_AUTH_URL,
|
|
{},
|
|
{
|
|
auth: {
|
|
username: process.env.FORTELLIS_KEY,
|
|
password: process.env.FORTELLIS_SECRET
|
|
},
|
|
params: {
|
|
grant_type: "client_credentials",
|
|
scope: "anonymous"
|
|
}
|
|
}
|
|
);
|
|
return access_token;
|
|
}
|
|
|
|
async function FetchSubscriptions({ redisHelpers, socket, jobid }) {
|
|
try {
|
|
const { setSessionTransactionData, getSessionTransactionData } = redisHelpers;
|
|
|
|
//Get Subscription ID from Transaction Envelope
|
|
const { SubscriptionID } = await getSessionTransactionData(socket.id, getTransactionType(jobid), `txEnvelope`);
|
|
if (!SubscriptionID) {
|
|
throw new Error("Subscription ID not found in transaction envelope.");
|
|
}
|
|
|
|
//Check to See if the subscription meta is in the Redis Cache.
|
|
const SubscriptionMetaFromCache = await getSessionTransactionData(
|
|
socket.id,
|
|
getTransactionType(jobid),
|
|
FortellisCacheEnums.SubscriptionMeta
|
|
);
|
|
|
|
// If it is, return it.
|
|
if (SubscriptionMetaFromCache) {
|
|
return SubscriptionMetaFromCache;
|
|
} else {
|
|
const access_token = await GetAuthToken();
|
|
const subscriptions = await axios.get(`https://subscriptions.fortellis.io/v1/solution/subscriptions`, {
|
|
headers: { Authorization: `Bearer ${access_token}` }
|
|
});
|
|
const SubscriptionMeta = subscriptions.data.subscriptions.find((s) => s.subscriptionId === SubscriptionID);
|
|
await setSessionTransactionData(
|
|
socket.id,
|
|
getTransactionType(jobid),
|
|
FortellisCacheEnums.SubscriptionMeta,
|
|
SubscriptionMeta,
|
|
defaultFortellisTTL
|
|
);
|
|
return SubscriptionMeta;
|
|
}
|
|
} catch (error) {
|
|
CreateFortellisLogEvent(socket, "ERROR", `Error fetching subscription metadata`, {
|
|
error: error.message,
|
|
stack: error.stack
|
|
});
|
|
}
|
|
}
|
|
|
|
async function GetDepartmentId({ apiName, debug = false, SubscriptionMeta }) {
|
|
if (!apiName) throw new Error("apiName not provided. Unable to get department without apiName.");
|
|
if (debug) {
|
|
console.log("API Names & Departments ");
|
|
console.log("===========");
|
|
console.log(
|
|
JSON.stringify(
|
|
SubscriptionMeta.apiDmsInfo.map((a) => ({
|
|
name: a.name,
|
|
departments: a.departments.map((d) => d.id)
|
|
})),
|
|
null,
|
|
4
|
|
)
|
|
);
|
|
console.log("===========");
|
|
}
|
|
//TODO: Verify how to select the correct department.
|
|
const departmentIds2 = SubscriptionMeta.apiDmsInfo //Get the subscription object.
|
|
.find((info) => info.name === apiName)?.departments; //Departments are categorized by API name and have an array of departments.
|
|
|
|
return departmentIds2 && departmentIds2[0] && departmentIds2[0].id; //TODO: This makes the assumption that there is only 1 department.
|
|
}
|
|
|
|
//Highest level function call to make a call to fortellis. This should be the only call required, and it will handle all the logic for making the call.
|
|
async function MakeFortellisCall({
|
|
apiName,
|
|
url,
|
|
headers = {},
|
|
body = {},
|
|
type = "post",
|
|
debug = true,
|
|
requestPathParams,
|
|
requestSearchParams = [], //Array of key/value strings like [["key", "value"]]
|
|
jobid,
|
|
redisHelpers,
|
|
socket,
|
|
}) {
|
|
const { setSessionTransactionData, getSessionTransactionData } = redisHelpers;
|
|
|
|
const fullUrl = constructFullUrl({ url, pathParams: requestPathParams, requestSearchParams });
|
|
|
|
if (debug) logger.log(`Executing ${type} to ${fullUrl}`);
|
|
const ReqId = uuid();
|
|
const access_token = await GetAuthToken();
|
|
const SubscriptionMeta = await FetchSubscriptions({ redisHelpers, socket, jobid });
|
|
const DepartmentId = await GetDepartmentId({ apiName, debug, SubscriptionMeta });
|
|
|
|
if (debug) {
|
|
console.log(
|
|
`ReqID: ${ReqId} | SubscriptionID: ${SubscriptionMeta.subscriptionId} | DepartmentId: ${DepartmentId}`
|
|
);
|
|
console.log(`Body Contents: ${JSON.stringify(body, null, 4)}`);
|
|
}
|
|
|
|
try {
|
|
let result;
|
|
switch (type) {
|
|
case "post":
|
|
default:
|
|
result = await axios.post(fullUrl, body, {
|
|
headers: {
|
|
Authorization: `Bearer ${access_token}`,
|
|
"Subscription-Id": SubscriptionMeta.subscriptionId,
|
|
"Request-Id": ReqId,
|
|
...DepartmentId && { "Department-Id": DepartmentId },
|
|
...headers
|
|
}
|
|
});
|
|
break;
|
|
case "get":
|
|
result = await axios.get(fullUrl, {
|
|
headers: {
|
|
Authorization: `Bearer ${access_token}`,
|
|
"Subscription-Id": SubscriptionMeta.subscriptionId,
|
|
"Request-Id": ReqId,
|
|
"Department-Id": DepartmentId,
|
|
...headers
|
|
}
|
|
});
|
|
break;
|
|
case "put":
|
|
result = await axios.put(fullUrl, body, {
|
|
headers: {
|
|
Authorization: `Bearer ${access_token}`,
|
|
"Subscription-Id": SubscriptionMeta.subscriptionId,
|
|
"Request-Id": ReqId,
|
|
"Department-Id": DepartmentId,
|
|
...headers
|
|
}
|
|
});
|
|
break;
|
|
}
|
|
|
|
if (debug) {
|
|
console.log(`ReqID: ${ReqId} Data`);
|
|
console.log(JSON.stringify(result.data, null, 4));
|
|
}
|
|
|
|
if (result.data.checkStatusAfterSeconds) {
|
|
return DelayedCallback({
|
|
delayMeta: result.data,
|
|
access_token,
|
|
SubscriptionID: SubscriptionMeta.subscriptionId,
|
|
ReqId,
|
|
departmentIds: DepartmentId
|
|
});
|
|
}
|
|
return result.data;
|
|
} catch (error) {
|
|
console.log(`ReqID: ${ReqId} Error`, error.response?.data);
|
|
//console.log(`ReqID: ${ReqId} Full Error`, JSON.stringify(error, null, 4));
|
|
}
|
|
}
|
|
|
|
//Some Fortellis calls return a batch result that isn't ready immediately.
|
|
//This function will check the status of the call and wait until it is ready.
|
|
//It will try 5 times before giving up.
|
|
async function DelayedCallback({ delayMeta, access_token, SubscriptionID, ReqId, departmentIds }) {
|
|
for (let index = 0; index < 5; index++) {
|
|
await sleep(delayMeta.checkStatusAfterSeconds * 1000);
|
|
//Check to see if the call is ready.
|
|
const statusResult = await axios.get(delayMeta._links.status.href, {
|
|
headers: {
|
|
Authorization: `Bearer ${access_token}`,
|
|
"Subscription-Id": SubscriptionID,
|
|
"Request-Id": ReqId,
|
|
"Department-Id": departmentIds[0].id
|
|
}
|
|
});
|
|
|
|
//TODO: Add a check if the status result is not ready, to try again.
|
|
if (statusResult.data.status === "complete") {
|
|
//This may have to check again if it isn't ready.
|
|
const batchResult = await axios.get(statusResult.data._links.result.href, {
|
|
headers: {
|
|
Authorization: `Bearer ${access_token}`,
|
|
"Subscription-Id": SubscriptionID,
|
|
"Request-Id": ReqId
|
|
//"Department-Id": departmentIds[0].id
|
|
}
|
|
});
|
|
return batchResult;
|
|
} else {
|
|
return "Error!!! Still need to implement batch waiting.";
|
|
}
|
|
}
|
|
}
|
|
function sleep(ms) {
|
|
return new Promise((resolve) => setTimeout(resolve, ms));
|
|
}
|
|
|
|
const isProduction = process.env.NODE_ENV === "production";
|
|
|
|
const FortellisActions = {
|
|
QueryVehicles: {
|
|
url: isProduction
|
|
? "https://api.fortellis.io/cdkdrive/service/v1/vehicles/"
|
|
: "https://api.fortellis.io/cdk-test/cdkdrive/service/v1/vehicles/",
|
|
type: "get",
|
|
apiName: "Service Vehicle - Query Vehicles"
|
|
},
|
|
GetVehicleId: {
|
|
url: isProduction
|
|
? "https://api.fortellis.io/cdk/drive/service-vehicle-mgmt/v2/vehicle-ids/" //Request path params of vins
|
|
: "https://api.fortellis.io/cdk-test/drive/service-vehicle-mgmt/v2/vehicle-ids/",
|
|
type: "get",
|
|
apiName: "CDK Drive Post Service Vehicle",
|
|
},
|
|
GetVehicleById: {
|
|
url: isProduction
|
|
? "https://api.fortellis.io/cdk/drive/service-vehicle-mgmt/v2/" //Request path params of vehicleId
|
|
: "https://api.fortellis.io/cdk-test/drive/service-vehicle-mgmt/v2/",
|
|
type: "get",
|
|
apiName: "CDK Drive Post Service Vehicle",
|
|
},
|
|
QueryCustomerByName: {
|
|
url: isProduction
|
|
? "https://api.fortellis.io/cdk/drive/customerpost/v1/search"
|
|
: "https://api.fortellis.io/cdk-test/drive/customerpost/v1/search",
|
|
type: "get",
|
|
apiName: "CDK Drive Post Customer",
|
|
},
|
|
ReadCustomer: {
|
|
url: isProduction
|
|
? "https://api.fortellis.io/cdk/drive/customerpost/v1/" //Customer ID is request param.
|
|
: "https://api.fortellis.io/cdk-test/drive/customerpost/v1/",
|
|
type: "get",
|
|
apiName: "CDK Drive Post Customer",
|
|
},
|
|
CreateCustomer: {
|
|
url: isProduction
|
|
? "https://api.fortellis.io/cdk/drive/customerpost/v1/"
|
|
: "https://api.fortellis.io/cdk-test/drive/customerpost/v1/",
|
|
type: "post",
|
|
apiName: "CDK Drive Post Customer",
|
|
},
|
|
InsertVehicle: {
|
|
url: isProduction
|
|
? "https://api.fortellis.io/cdk/drive/service-vehicle-mgmt/v2/"
|
|
: "https://api.fortellis.io/cdk-test/drive/service-vehicle-mgmt/v2/",
|
|
type: "post",
|
|
apiName: "CDK Drive Post Service Vehicle",
|
|
},
|
|
UpdateVehicle: {
|
|
url: isProduction
|
|
? "https://api.fortellis.io/cdk/drive/service-vehicle-mgmt/v2/"
|
|
: "https://api.fortellis.io/cdk-test/drive/service-vehicle-mgmt/v2/",
|
|
type: "put",
|
|
apiName: "CDK Drive Post Customer",
|
|
},
|
|
GetCOA: {
|
|
type: "get",
|
|
apiName: "CDK Drive Post Accounts GL WIP",
|
|
url: `https://api.fortellis.io/cdk-test/drive/chartofaccounts/v2/bulk/`,
|
|
waitForResult: true
|
|
}
|
|
};
|
|
|
|
const FortellisCacheEnums = {
|
|
txEnvelope: "txEnvelope",
|
|
SubscriptionMeta: "SubscriptionMeta",
|
|
DepartmentId: "DepartmentId",
|
|
JobData: "JobData",
|
|
DMSVid: "DMSVid",
|
|
DMSVeh: "DMSVeh",
|
|
DMSVehCustomer: "DMSVehCustomer",
|
|
DMSCustList: "DMSCustList",
|
|
DMSCust: "DMSCust",
|
|
selectedCustomerId: "selectedCustomerId",
|
|
};
|
|
|
|
function constructFullUrl({ url, pathParams = "", requestSearchParams = [] }) {
|
|
// Ensure the base URL ends with a single "/"
|
|
url = url.replace(/\/+$/, "/");
|
|
const fullPath = pathParams ? `${url}${pathParams}` : url;
|
|
const searchParams = new URLSearchParams(requestSearchParams).toString();
|
|
const fullUrl = searchParams ? `${fullPath}?${searchParams}` : fullPath;
|
|
return fullUrl;
|
|
}
|
|
|
|
|
|
|
|
module.exports = {
|
|
GetAuthToken,
|
|
FortellisCacheEnums,
|
|
MakeFortellisCall,
|
|
FortellisActions,
|
|
getTransactionType,
|
|
defaultFortellisTTL
|
|
};
|