788 lines
27 KiB
JavaScript
788 lines
27 KiB
JavaScript
|
|
require('dotenv').config()
|
|
|
|
CONSOLE_LOG = process.env.CONSOLE_LOG === "true"
|
|
CONSOLE_ERROR_LOG = process.env.CONSOLE_ERROR_LOG === "true"
|
|
LOG_FILE_CONTENT = process.env.LOG_FILE_CONTENT === "true"
|
|
|
|
if (CONSOLE_LOG === true) { console.log('[INFO] server -> Node Server Starting.') }
|
|
|
|
global.DEFAULT_OK_RESPONSE = {
|
|
result: 'Ok',
|
|
message: 'Operation Succeeded'
|
|
}
|
|
|
|
global.DEFAULT_FAIL_RESPONSE = {
|
|
result: 'Fail',
|
|
message: 'Operation Failed'
|
|
}
|
|
|
|
global.DEFAULT_RETRY_RESPONSE = {
|
|
result: 'Retry',
|
|
message: 'Retry Later'
|
|
}
|
|
|
|
global.CUSTOM_OK_RESPONSE = {
|
|
result: 'Ok, but check Message',
|
|
message: 'Custom Message'
|
|
}
|
|
|
|
global.CUSTOM_FAIL_RESPONSE = {
|
|
result: 'Fail Because',
|
|
message: 'Custom Message'
|
|
}
|
|
|
|
let storageData
|
|
let http = require('http')
|
|
let port = process.env.PORT || 1337
|
|
let isHttpServerStarted = false
|
|
const AZURE_STORAGE = require('./Server/AzureStorage')
|
|
const MINIO_STORAGE = require('./Server/MinioStorage')
|
|
let ecosystemObject = require("./Server/config/ecosystem.json");
|
|
|
|
switch (process.env.STORAGE_PROVIDER) {
|
|
case 'Azure': {
|
|
storage = AZURE_STORAGE.newAzureStorage();
|
|
break;
|
|
}
|
|
case 'Minio': {
|
|
storage = MINIO_STORAGE.newMinioStorage();
|
|
break;
|
|
}
|
|
default: {
|
|
console.log('[ERROR] server -> Storage Provider not supported -> process.env.STORAGE_PROVIDER = ' + process.env.STORAGE_PROVIDER)
|
|
return;
|
|
}
|
|
}
|
|
|
|
initialize()
|
|
|
|
function initialize () {
|
|
if (CONSOLE_LOG === true) { console.log('[INFO] server -> initialize -> Entering function.') }
|
|
|
|
/* Clear all cached information. */
|
|
|
|
storageData = new Map()
|
|
|
|
const CONFIG_READER = require('./Server/ConfigReader')
|
|
let configReader = CONFIG_READER.newConfigReader()
|
|
|
|
configReader.initialize(ecosystemObject, storageData, storage, onInitialized)
|
|
|
|
function onInitialized (err) {
|
|
if (err.result !== global.DEFAULT_OK_RESPONSE.result) {
|
|
console.log('[ERROR] server -> initialize -> onInitialized -> err.message = ' + err.message)
|
|
console.log('[ERROR] server -> initialize -> onInitialized -> Terminating Execution. ')
|
|
|
|
return
|
|
}
|
|
|
|
configReader.loadConfigs(onConfigsLoaded)
|
|
|
|
function onConfigsLoaded (err, pEcosystemObject) {
|
|
if (err.result !== global.DEFAULT_OK_RESPONSE.result) {
|
|
console.log('[ERROR] server -> initialize -> onInitialized -> onConfigsLoaded -> err.message = ' + err.message)
|
|
console.log('[ERROR] server -> initialize -> onInitialized -> onConfigsLoaded -> Terminating Execution. ')
|
|
|
|
return
|
|
}
|
|
|
|
ecosystemObject = pEcosystemObject
|
|
|
|
storage.initialize(storageData, ecosystemObject) // TODO do not initialize as a general option
|
|
|
|
startHtttpServer ()
|
|
}
|
|
}
|
|
}
|
|
|
|
function startHtttpServer () {
|
|
if (CONSOLE_LOG === true) { console.log('[INFO] server -> startHtttpServer -> Entering function.') }
|
|
|
|
try {
|
|
if (isHttpServerStarted === false) {
|
|
gWebServer = http.createServer(onBrowserRequest).listen(port)
|
|
isHttpServerStarted = true
|
|
}
|
|
} catch (err) {
|
|
console.log('[ERROR] server -> startHtttpServer -> Error = ' + err)
|
|
}
|
|
}
|
|
|
|
function onBrowserRequest (request, response) {
|
|
if (CONSOLE_LOG === true) { console.log('[INFO] server -> onBrowserRequest -> Entering function.') }
|
|
if (CONSOLE_LOG === true && request.url.indexOf('NO-LOG') === -1) { console.log('[INFO] server -> onBrowserRequest -> request.url = ' + request.url) }
|
|
|
|
let requestParameters = request.url.split('/')
|
|
|
|
if (requestParameters[1].indexOf('index.html') >= 0) {
|
|
/*
|
|
We use this to solve the problem when someone is arriving to the site with a sessionToken in the queryString. We extract here that
|
|
token, that will be sent later embedded into the HTML code, so that it can enter into the stardard circuit where any site can put
|
|
the sessionToken into their HTML code and from there the Browser app will log the user in.
|
|
*/
|
|
|
|
let queryString = requestParameters[1].split('?')
|
|
|
|
requestParameters[1] = ''
|
|
requestParameters[2] = queryString[1]
|
|
homePage()
|
|
|
|
return
|
|
}
|
|
|
|
requestParameters = request.url.split('?') // Remove version information
|
|
requestParameters = requestParameters[0].split('/')
|
|
|
|
switch (requestParameters[1]) {
|
|
|
|
case process.env.REINITIALIZE_COMMAND: {
|
|
initialize()
|
|
|
|
respondWithContent('Node JS Server Reinitilized.', response)
|
|
}
|
|
break
|
|
|
|
case 'MQService':
|
|
{
|
|
let filePath = "./node_modules/@superalgos/mqservice/orderLifeCicle/webDependency.js"
|
|
|
|
respondWithFile(filePath, response)
|
|
break;
|
|
}
|
|
|
|
// case 'FileService':
|
|
// {
|
|
|
|
// processPost(request, response, onPostReceived)
|
|
|
|
// function onPostReceived(pData) {
|
|
|
|
// let request = JSON.parse(pData);
|
|
|
|
// storage.readData(undefined, request.path, request.conatinerName, false, onReady)
|
|
|
|
// function onReady(err, pFileContent) {
|
|
|
|
// let responseToClient = {
|
|
// err: err,
|
|
// text: pFileContent
|
|
// };
|
|
|
|
// respondWithContent(JSON.stringify(responseToClient), response);
|
|
// }
|
|
// }
|
|
|
|
// break;
|
|
// }
|
|
case 'Plotter.js':
|
|
{
|
|
/*
|
|
|
|
This file is built dinamically because it has the code to instantiate the different configured Plotters. The instantiation code
|
|
will be generated using a pre-defined string with replacement points. We will go through the configuration file to learn
|
|
about all the possible plotters the system can load.
|
|
|
|
*/
|
|
|
|
let fs = require('fs')
|
|
try {
|
|
let fileName = 'Plotter.js'
|
|
fs.readFile(fileName, onFileRead)
|
|
|
|
function onFileRead (err, file) {
|
|
if (CONSOLE_LOG === true) { console.log('[INFO] server -> onBrowserRequest -> onFileRead -> Entering function.') }
|
|
|
|
try {
|
|
let fileContent = file.toString()
|
|
|
|
/* This is the string we will use to insert into the Plotters.js script. */
|
|
|
|
let caseString = '' +
|
|
' case "@newFunctionName@":' + '\n' +
|
|
' {' + '\n' +
|
|
' plotter = newPlotterName();' + '\n' +
|
|
' }' + '\n' +
|
|
' break;' + '\n' + '\n'
|
|
|
|
let devTeams = ecosystemObject.devTeams
|
|
let hosts = ecosystemObject.hosts
|
|
|
|
addToFileContent(devTeams)
|
|
addToFileContent(hosts)
|
|
|
|
function addToFileContent (pDevTeamsOrHosts) {
|
|
if (CONSOLE_LOG === true) { console.log('[INFO] server -> onBrowserRequest -> onFileRead -> addToFileContent -> Entering function.') }
|
|
|
|
for (let i = 0; i < pDevTeamsOrHosts.length; i++) {
|
|
let devTeam = pDevTeamsOrHosts[i]
|
|
|
|
for (let j = 0; j < devTeam.plotters.length; j++) {
|
|
let plotter = devTeam.plotters[j]
|
|
|
|
for (let k = 0; k < plotter.modules.length; k++) {
|
|
|
|
let module = plotter.modules[k]
|
|
|
|
let caseStringCopy = caseString
|
|
|
|
let newFunctionName = devTeam.codeName + plotter.codeName + module.codeName
|
|
newFunctionName = newFunctionName.replace(/-/g, '')
|
|
|
|
let stringToInsert
|
|
stringToInsert = caseStringCopy.replace('@newFunctionName@', newFunctionName)
|
|
stringToInsert = stringToInsert.replace('newPlotterName', 'new' + newFunctionName)
|
|
|
|
let firstPart = fileContent.substring(0, fileContent.indexOf('// Cases'))
|
|
let secondPart = fileContent.substring(fileContent.indexOf('// Cases'))
|
|
|
|
fileContent = firstPart + stringToInsert + secondPart
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
respondWithContent(fileContent, response)
|
|
} catch (err) {
|
|
console.log('[ERROR] server -> onBrowserRequest -> File Not Found: ' + fileName + ' or Error = ' + err)
|
|
}
|
|
}
|
|
} catch (err) {
|
|
console.log(err)
|
|
}
|
|
}
|
|
break
|
|
|
|
case 'PlotterPanel.js':
|
|
{
|
|
/*
|
|
|
|
This file is build dinamically because it has the code to instantiate the different configured Plotter Panels. The instantiation code
|
|
will be generated using a pre-defined string with replacement points. We will go through the configuration file to learn
|
|
about all the possible plotters panels the system can load.
|
|
|
|
*/
|
|
|
|
let fs = require('fs')
|
|
try {
|
|
let fileName = 'PlotterPanel.js'
|
|
fs.readFile(fileName, onFileRead)
|
|
|
|
function onFileRead (err, file) {
|
|
if (CONSOLE_LOG === true) { console.log('[INFO] server -> onBrowserRequest -> onFileRead -> Entering function.') }
|
|
|
|
try {
|
|
let fileContent = file.toString()
|
|
|
|
/* This is the string we will use to insert into the Plotters.js script. */
|
|
|
|
let caseString = '' +
|
|
' case "@newFunctionName@":' + '\n' +
|
|
' {' + '\n' +
|
|
' plotterPanel = newPlotterPanelName();' + '\n' +
|
|
' }' + '\n' +
|
|
' break;' + '\n' + '\n'
|
|
|
|
let devTeams = ecosystemObject.devTeams
|
|
let hosts = ecosystemObject.hosts
|
|
|
|
addToFileContent(devTeams)
|
|
addToFileContent(hosts)
|
|
|
|
function addToFileContent (pDevTeamsOrHosts) {
|
|
if (CONSOLE_LOG === true) { console.log('[INFO] server -> onBrowserRequest -> onFileRead -> addToFileContent -> Entering function.') }
|
|
|
|
for (let i = 0; i < pDevTeamsOrHosts.length; i++) {
|
|
let devTeam = pDevTeamsOrHosts[i]
|
|
|
|
for (let j = 0; j < devTeam.plotters.length; j++) {
|
|
let plotter = devTeam.plotters[j]
|
|
|
|
for (let k = 0; k < plotter.modules.length; k++) {
|
|
|
|
let module = plotter.modules[k]
|
|
|
|
for (let l = 0; l < module.panels.length; l++) {
|
|
|
|
let panel = module.panels[l]
|
|
|
|
let caseStringCopy = caseString
|
|
|
|
let newFunctionName = devTeam.codeName + plotter.codeName + module.codeName + panel.codeName
|
|
newFunctionName = newFunctionName.replace(/-/g, '')
|
|
|
|
let stringToInsert
|
|
stringToInsert = caseStringCopy.replace('@newFunctionName@', newFunctionName)
|
|
stringToInsert = stringToInsert.replace('newPlotterPanelName', 'new' + newFunctionName)
|
|
|
|
let firstPart = fileContent.substring(0, fileContent.indexOf('// Cases'))
|
|
let secondPart = fileContent.substring(fileContent.indexOf('// Cases'))
|
|
|
|
fileContent = firstPart + stringToInsert + secondPart
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
respondWithContent(fileContent, response)
|
|
} catch (err) {
|
|
console.log('[ERROR] server -> onBrowserRequest -> File Not Found: ' + fileName + ' or Error = ' + err)
|
|
}
|
|
}
|
|
} catch (err) {
|
|
console.log(err)
|
|
}
|
|
}
|
|
break
|
|
|
|
case 'Ecosystem.js':
|
|
{
|
|
/*
|
|
|
|
At this page we need to insert the configuration file for the whole system that we assamble before at the begining of this module
|
|
execution. So what we do is to load a template file with an insertion point where the configuration json is injected in.
|
|
|
|
*/
|
|
|
|
let fs = require('fs')
|
|
try {
|
|
let fileName = 'Ecosystem.js'
|
|
fs.readFile(fileName, onFileRead)
|
|
|
|
function onFileRead (err, file) {
|
|
if (CONSOLE_LOG === true) { console.log('[INFO] server -> onBrowserRequest -> onFileRead -> Entering function.') }
|
|
|
|
try {
|
|
let fileContent = file.toString()
|
|
let insertContent = JSON.stringify(ecosystemObject)
|
|
|
|
fileContent = fileContent.replace('"@ecosystem.json@"', insertContent)
|
|
|
|
respondWithContent(fileContent, response)
|
|
} catch (err) {
|
|
console.log('[ERROR] server -> onBrowserRequest -> File Not Found: ' + fileName + ' or Error = ' + err)
|
|
}
|
|
}
|
|
} catch (err) {
|
|
console.log(err)
|
|
}
|
|
}
|
|
break
|
|
|
|
case 'CloudAppWrapper': // This means the BrowserRun folder.
|
|
{
|
|
let filePath = requestParameters[2]
|
|
|
|
if (requestParameters[3] !== undefined) {
|
|
filePath = filePath + '/' + requestParameters[3]
|
|
}
|
|
|
|
if (requestParameters[4] !== undefined) {
|
|
filePath = filePath + '/' + requestParameters[4]
|
|
}
|
|
|
|
respondWithFile(process.env.PATH_TO_CLOUD_APP_WRAPPER_COMPONENT + '/' + filePath, response)
|
|
}
|
|
break
|
|
|
|
case 'Images': // This means the Scripts folder.
|
|
{
|
|
let path = './Images/' + requestParameters[2]
|
|
|
|
if (requestParameters[3] !== undefined) {
|
|
path = path + '/' + requestParameters[3]
|
|
}
|
|
|
|
if (requestParameters[4] !== undefined) {
|
|
path = path + '/' + requestParameters[4]
|
|
}
|
|
|
|
if (requestParameters[5] !== undefined) {
|
|
path = path + '/' + requestParameters[5]
|
|
}
|
|
|
|
path = unescape(path)
|
|
|
|
respondWithImage(path, response)
|
|
}
|
|
break
|
|
|
|
case 'favicon.ico': // This means the Scripts folder.
|
|
{
|
|
respondWithImage('./Images/' + 'favicon.ico', response)
|
|
}
|
|
break
|
|
|
|
case 'CockpitSpace': // This means the CockpitSpace folder.
|
|
{
|
|
respondWithFile(process.env.PATH_TO_CANVAS_APP + '/CockpitSpace/' + requestParameters[2], response)
|
|
}
|
|
break
|
|
|
|
case 'TopSpace': // This means the TopSpace folder.
|
|
{
|
|
respondWithFile(process.env.PATH_TO_CANVAS_APP + '/TopSpace/' + requestParameters[2], response)
|
|
}
|
|
break
|
|
|
|
case 'StrategySpace': // This means the StrategySpace folder.
|
|
{
|
|
respondWithFile(process.env.PATH_TO_CANVAS_APP + '/StrategySpace/' + requestParameters[2], response)
|
|
}
|
|
break
|
|
|
|
case 'ControlsToolBox': // This means the StrategySpace folder.
|
|
{
|
|
respondWithFile(process.env.PATH_TO_CANVAS_APP + '/ControlsToolBox/' + requestParameters[2], response)
|
|
}
|
|
break
|
|
|
|
case 'Utilities': // This means the StrategySpace folder.
|
|
{
|
|
respondWithFile(process.env.PATH_TO_CANVAS_APP + '/Utilities/' + requestParameters[2], response)
|
|
}
|
|
break
|
|
|
|
case 'Scripts': // This means the Scripts folder.
|
|
{
|
|
if (requestParameters[2] === 'AppLoader.js') {
|
|
let fs = require('fs')
|
|
try {
|
|
let fileName = './Scripts/' + 'AppLoader.js'
|
|
fs.readFile(fileName, onFileRead)
|
|
|
|
function onFileRead (err, file) {
|
|
if (CONSOLE_LOG === true) { console.log('[INFO] server -> onBrowserRequest -> onFileRead -> Entering function.') }
|
|
|
|
try {
|
|
let fileContent = file.toString()
|
|
|
|
addPlotters()
|
|
|
|
function addPlotters () {
|
|
if (CONSOLE_LOG === true) { console.log('[INFO] server -> onBrowserRequest -> onFileRead -> addPlotters -> Entering function.') }
|
|
|
|
let htmlLinePlotter = '' + '\n' +
|
|
' "Plotters/@devTeam@/@repo@/@module@.js",'
|
|
|
|
let htmlLinePlotterPanel = '' + '\n' +
|
|
' "PlotterPanels/@devTeam@/@repo@/@module@.js",'
|
|
|
|
let devTeams = ecosystemObject.devTeams
|
|
let hosts = ecosystemObject.hosts
|
|
|
|
addScript(devTeams)
|
|
addScript(hosts)
|
|
|
|
function addScript (pDevTeamsOrHosts) {
|
|
if (CONSOLE_LOG === true) { console.log('[INFO] server -> onBrowserRequest -> onFileRead -> addPlotters -> addScript -> Entering function.') }
|
|
|
|
for (let i = 0; i < pDevTeamsOrHosts.length; i++) {
|
|
|
|
let devTeam = pDevTeamsOrHosts[i]
|
|
|
|
for (let j = 0; j < devTeam.plotters.length; j++) {
|
|
|
|
let plotter = devTeam.plotters[j]
|
|
|
|
if (plotter.modules !== undefined) {
|
|
|
|
for (let k = 0; k < plotter.modules.length; k++) {
|
|
|
|
let module = plotter.modules[k]
|
|
|
|
let htmlLineCopy = htmlLinePlotter
|
|
|
|
let stringToInsert
|
|
stringToInsert = htmlLineCopy.replace('@devTeam@', devTeam.codeName)
|
|
stringToInsert = stringToInsert.replace('@repo@', plotter.repo)
|
|
stringToInsert = stringToInsert.replace('@module@', module.moduleName)
|
|
|
|
let firstPart = fileContent.substring(0, fileContent.indexOf('/* Plotters */') + 14)
|
|
let secondPart = fileContent.substring(fileContent.indexOf('/* Plotters */') + 14)
|
|
|
|
fileContent = firstPart + stringToInsert + secondPart
|
|
|
|
if (module.panels !== undefined) {
|
|
|
|
for (let l = 0; l < module.panels.length; l++) {
|
|
|
|
let panel = module.panels[l]
|
|
|
|
let htmlLineCopy = htmlLinePlotterPanel
|
|
|
|
let stringToInsert
|
|
stringToInsert = htmlLineCopy.replace('@devTeam@', devTeam.codeName)
|
|
stringToInsert = stringToInsert.replace('@repo@', plotter.repo)
|
|
stringToInsert = stringToInsert.replace('@module@', panel.moduleName)
|
|
|
|
let firstPart = fileContent.substring(0, fileContent.indexOf('/* PlotterPanels */') + 19)
|
|
let secondPart = fileContent.substring(fileContent.indexOf('/* PlotterPanels */') + 19)
|
|
|
|
fileContent = firstPart + stringToInsert + secondPart
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
respondWithContent(fileContent, response)
|
|
} catch (err) {
|
|
console.log('[ERROR] server -> onBrowserRequest -> File Not Found: ' + fileName + ' or Error = ' + err)
|
|
}
|
|
}
|
|
} catch (err) {
|
|
console.log(err)
|
|
}
|
|
} else {
|
|
respondWithFile('./Scripts/' + requestParameters[2], response)
|
|
}
|
|
}
|
|
break
|
|
|
|
case 'Plotters': // This means the plotter folder, not to be confused with the Plotters script!
|
|
{
|
|
storage.readData(requestParameters[2] + '/' + 'plotters', requestParameters[3], requestParameters[4], true, onDataArrived)
|
|
|
|
function onDataArrived (err, pData) {
|
|
if (err.result !== global.DEFAULT_OK_RESPONSE.result) {
|
|
console.log('[ERROR] server -> onBrowserRequest -> Plotters -> onDataArrived -> Could not read a file. ')
|
|
console.log('[ERROR] server -> onBrowserRequest -> Plotters -> onDataArrived -> err.message = ' + err.message)
|
|
|
|
pData = ''
|
|
}
|
|
|
|
respondWithContent(pData, response)
|
|
}
|
|
}
|
|
break
|
|
|
|
case 'PlotterPanels': // This means the PlotterPanels folder, not to be confused with the Plotter Panels scripts!
|
|
{
|
|
storage.readData(requestParameters[2] + '/' + 'plotters', requestParameters[3], requestParameters[4], true, onDataArrived)
|
|
|
|
function onDataArrived (err, pData) {
|
|
if (err.result !== global.DEFAULT_OK_RESPONSE.result) {
|
|
console.log('[ERROR] server -> onBrowserRequest -> Plotters -> PlotterPanels -> Could not read a file. ')
|
|
console.log('[ERROR] server -> onBrowserRequest -> Plotters -> PlotterPanels -> err.message = ' + err.message)
|
|
|
|
pData = ''
|
|
}
|
|
|
|
respondWithContent(pData, response)
|
|
}
|
|
}
|
|
break
|
|
case 'Panels':
|
|
{
|
|
respondWithFile(process.env.PATH_TO_CANVAS_APP + '/' + requestParameters[1] + '/' + requestParameters[2], response)
|
|
}
|
|
break
|
|
|
|
case 'ChartLayers':
|
|
{
|
|
respondWithFile(process.env.PATH_TO_CANVAS_APP + '/' + requestParameters[1] + '/' + requestParameters[2], response)
|
|
}
|
|
break
|
|
|
|
case 'Azure':
|
|
{
|
|
respondWithFile('./' + requestParameters[1] + '/' + requestParameters[2], response)
|
|
}
|
|
break
|
|
|
|
case 'Spaces':
|
|
{
|
|
respondWithFile(process.env.PATH_TO_CANVAS_APP + '/' + requestParameters[1] + '/' + requestParameters[2], response)
|
|
}
|
|
break
|
|
|
|
case 'Scales':
|
|
{
|
|
respondWithFile(process.env.PATH_TO_CANVAS_APP + '/' + requestParameters[1] + '/' + requestParameters[2], response)
|
|
}
|
|
break
|
|
|
|
case 'Files':
|
|
{
|
|
respondWithFile(process.env.PATH_TO_FILES_COMPONENT + '/' + requestParameters[2], response)
|
|
}
|
|
break
|
|
|
|
case 'FloatingSpace':
|
|
{
|
|
respondWithFile(process.env.PATH_TO_CANVAS_APP + '/' + requestParameters[1] + '/' + requestParameters[2], response)
|
|
}
|
|
break
|
|
|
|
case 'ChartsSpace':
|
|
{
|
|
respondWithFile(process.env.PATH_TO_CANVAS_APP + '/' + requestParameters[1] + '/' + requestParameters[2], response)
|
|
}
|
|
break
|
|
|
|
default:
|
|
{
|
|
homePage()
|
|
}
|
|
}
|
|
|
|
function homePage () {
|
|
if (requestParameters[1] === '') {
|
|
let fs = require('fs')
|
|
try {
|
|
let fileName = 'index.html'
|
|
fs.readFile(fileName, onFileRead)
|
|
|
|
function onFileRead (err, file) {
|
|
if (CONSOLE_LOG === true) { console.log('[INFO] server -> onBrowserRequest -> onFileRead -> Entering function.') }
|
|
|
|
try {
|
|
let fileContent = file.toString()
|
|
|
|
/* The second request parameters is the sessionToken, if it exists. */
|
|
|
|
if (requestParameters[2] !== '' && requestParameters[2] !== undefined) {
|
|
fileContent = fileContent.replace("window.canvasApp.sessionToken = ''", "window.canvasApp.sessionToken = '" + requestParameters[2] + "'")
|
|
}
|
|
|
|
respondWithContent(fileContent, response)
|
|
} catch (err) {
|
|
console.log('[ERROR] server -> onBrowserRequest -> File Not Found: ' + fileName + ' or Error = ' + err)
|
|
}
|
|
}
|
|
} catch (err) {
|
|
console.log(err)
|
|
}
|
|
} else {
|
|
respondWithFile(process.env.PATH_TO_CANVAS_APP + '/' + requestParameters[1], response)
|
|
}
|
|
}
|
|
}
|
|
|
|
function respondWithContent (content, response) {
|
|
if (CONSOLE_LOG === true) { console.log('[INFO] server -> respondWithContent -> Entering function.') }
|
|
|
|
try {
|
|
response.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate') // HTTP 1.1.
|
|
response.setHeader('Pragma', 'no-cache') // HTTP 1.0.
|
|
response.setHeader('Expires', '0') // Proxies.
|
|
response.setHeader('Access-Control-Allow-Origin', '*') // Allows to access data from other domains.
|
|
|
|
response.writeHead(200, { 'Content-Type': 'text/html' })
|
|
response.write(content)
|
|
response.end('\n')
|
|
// console.log("Content Sent: " + content);
|
|
} catch (err) {
|
|
returnEmptyArray(response)
|
|
}
|
|
}
|
|
|
|
function respondWithFile (fileName, response) {
|
|
if (CONSOLE_LOG === true) { console.log('[INFO] server -> respondWithFile -> Entering function.') }
|
|
|
|
let fs = require('fs')
|
|
try {
|
|
if (fileName.indexOf('undefined') > 0) {
|
|
console.log('[WRN] server -> respondWithFile -> Received request for undefined file. ')
|
|
return
|
|
}
|
|
|
|
fs.readFile(fileName, onFileRead)
|
|
|
|
function onFileRead (err, file) {
|
|
if (CONSOLE_LOG === true) { console.log('[INFO] server -> respondWithFile -> onFileRead -> Entering function.') }
|
|
|
|
try {
|
|
let htmlResponse = file.toString()
|
|
|
|
response.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate') // HTTP 1.1.
|
|
response.setHeader('Pragma', 'no-cache') // HTTP 1.0.
|
|
response.setHeader('Expires', '0') // Proxies.
|
|
response.setHeader('Access-Control-Allow-Origin', '*') // Allows to access data from other domains.
|
|
|
|
// response.writeHead(200, { 'Content-Type': 'text/html' });
|
|
response.write(htmlResponse)
|
|
response.end('\n')
|
|
// console.log("File Sent: " + fileName);
|
|
//
|
|
} catch (err) {
|
|
console.log('[ERROR] server -> respondWithFile -> onFileRead -> File Not Found: ' + fileName + ' or Error = ' + err)
|
|
returnEmptyArray()
|
|
}
|
|
}
|
|
} catch (err) {
|
|
returnEmptyArray()
|
|
}
|
|
}
|
|
|
|
function respondWithImage (fileName, response) {
|
|
if (CONSOLE_LOG === true) { console.log('[INFO] server -> respondWithImage -> Entering function.') }
|
|
|
|
let fs = require('fs')
|
|
try {
|
|
fs.readFile(fileName, onFileRead)
|
|
|
|
function onFileRead (err, file) {
|
|
if (CONSOLE_LOG === true) { console.log('[INFO] server -> respondWithImage -> onFileRead -> Entering function.') }
|
|
|
|
try {
|
|
response.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate') // HTTP 1.1.
|
|
response.setHeader('Pragma', 'no-cache') // HTTP 1.0.
|
|
response.setHeader('Expires', '0') // Proxies.
|
|
response.setHeader('Access-Control-Allow-Origin', '*') // Allows to access data from other domains.
|
|
|
|
response.writeHead(200, { 'Content-Type': 'image/png' })
|
|
response.end(file, 'binary')
|
|
} catch (err) {
|
|
console.log('[ERROR] server -> respondWithImage -> onFileRead -> File Not Found: ' + fileName + ' or Error = ' + err)
|
|
}
|
|
}
|
|
} catch (err) {
|
|
console.log('[ERROR] server -> respondWithImage -> err = ' + err)
|
|
}
|
|
}
|
|
|
|
function returnEmptyArray (response) {
|
|
try {
|
|
if (CONSOLE_LOG === true) { console.log('[INFO] server -> respondWithFile -> returnEmptyArray -> Entering function.') }
|
|
|
|
response.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate') // HTTP 1.1.
|
|
response.setHeader('Pragma', 'no-cache') // HTTP 1.0.
|
|
response.setHeader('Expires', '0') // Proxies.
|
|
|
|
response.writeHead(200, { 'Content-Type': 'text/html' })
|
|
response.write('[]')
|
|
response.end('\n')
|
|
} catch (err) {
|
|
console.log('[ERROR] server -> returnEmptyArray -> err.message ' + err.message)
|
|
}
|
|
}
|
|
|
|
function processPost (request, response, callback) {
|
|
let data = ''
|
|
if (typeof callback !== 'function') return null
|
|
|
|
if (request.method == 'POST') {
|
|
request.on('data', function (pData) {
|
|
data += pData
|
|
if (data.length > 1e6) {
|
|
data = ''
|
|
response.writeHead(413, { 'Content-Type': 'text/plain' }).end()
|
|
request.connection.destroy()
|
|
}
|
|
})
|
|
|
|
request.on('end', function () {
|
|
callback(data)
|
|
})
|
|
} else {
|
|
response.writeHead(405, { 'Content-Type': 'text/plain' })
|
|
response.end()
|
|
}
|
|
}
|