648 lines
16 KiB
JavaScript
648 lines
16 KiB
JavaScript
var total_balance = null;
|
|
var memory_cache = {};
|
|
var user_settings = [];
|
|
var SetIntervalIsLoggedINFallback;
|
|
var SetIntervalIsExecINFallback;
|
|
var ServiceWorkerMessagesWorking = 0;
|
|
var AutoSuncFUnctionStarted = 0;
|
|
var request = new RequestData(false);
|
|
var requestWHash = new RequestData(true);
|
|
var LoadDataPageFunc;
|
|
var InttoStrDetailsFuncs = {};
|
|
var Preloaders = {};
|
|
var ReusableUIElements = {};
|
|
var cacmemocachehe = {};
|
|
var currentNoOfPrecacheRequests = [];
|
|
var CurrentPageisLoading = false;
|
|
var ShoppingCart = false;
|
|
var DontInitialize = 0;
|
|
var PreloaderGetFileBlob_Operations = 0;
|
|
var PreloaderGetFileBlob_Intervals = [];
|
|
var devmode = true;
|
|
var currentData = null;
|
|
var DataCore = {
|
|
'Store': {},
|
|
'Product': {},
|
|
'User': {},
|
|
};
|
|
const FormSchemas = {};
|
|
|
|
var PageCounterTracker=0;
|
|
|
|
initGlobal('tabledata');
|
|
initGlobal('Buttons',[]);
|
|
initGlobal('defaultbackpage');
|
|
|
|
var defaultBackOnclick = null;
|
|
|
|
|
|
if (typeof DontInitialize === 'undefined') {
|
|
var DontInitialize = 0;
|
|
}
|
|
|
|
function logDev(...args) {
|
|
if (devmode) {
|
|
console.log(...args);
|
|
}
|
|
}
|
|
|
|
/*
|
|
const { fetch: originalFetch } = window;
|
|
|
|
window.fetch = async (...args) => {
|
|
let [resource, config] = args;
|
|
|
|
if (resource.startsWith("/RequestData/File/")){
|
|
console.log(reqcacheload(resource));
|
|
}
|
|
|
|
const response = await originalFetch(resource, config);
|
|
console.table('Response received:', response);
|
|
return response;
|
|
}; */
|
|
|
|
InitDataPageFuncOBJ();
|
|
|
|
|
|
|
|
|
|
Preloaders.getfileBlobURL = function (hashkey, fetchifdoesnotexist = true) {
|
|
if (hashkey.length > 72) {
|
|
hashkey = hashkey.slice(-72);
|
|
}
|
|
const targeturl = '/RequestData/File/' + hashkey;
|
|
const alturl = window.location.origin + targeturl;
|
|
const reqload1 = reqcacheload(targeturl);
|
|
const reqload2 = reqcacheload(alturl);
|
|
|
|
|
|
const PreloadFileBlob = async function () {
|
|
await Preloaders.QuickPrecacheFetch(targeturl, null, false, () => {
|
|
PreloaderGetFileBlob_Operations--;
|
|
}, 'GET').then(() => {
|
|
|
|
});
|
|
}
|
|
PreloaderGetFileBlob_Operations++;
|
|
const currentfetchOperation = PreloaderGetFileBlob_Operations;
|
|
|
|
if (!hashkey) { return false; }
|
|
if (typeof fileBlobURLList[hashkey] !== 'undefined') {
|
|
return fileBlobURLList[hashkey];
|
|
} else if (reqload1) {
|
|
fileBlobURLList[hashkey] = URL.createObjectURL(reqcacheload(targeturl));
|
|
return fileBlobURLList[hashkey];
|
|
} else {
|
|
PreloadFileBlob();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
Preloaders.QuickPrecacheFetch = async function (url, obj = null, fromVarCache = false, successfunc = false, reqtype = 'POST') {
|
|
return new Promise((resolve, reject) => {
|
|
if (!url) {
|
|
return reject(new Error("URL is required"));
|
|
}
|
|
|
|
request.url(url).success((response) => {
|
|
if (typeof successfunc === 'function') {
|
|
successfunc(response);
|
|
}
|
|
|
|
if (url.includes('/RequestData/File/') && response) {
|
|
const fhash = url.slice(-72);
|
|
const bloburl = URL.createObjectURL(response);
|
|
fileBlobURLList[fhash] = bloburl;
|
|
}
|
|
resolve(response);
|
|
}).data(obj).fromVarCache(fromVarCache).type(reqtype).go();
|
|
});
|
|
};
|
|
|
|
Preloaders.ListData = async function (url, fromVarCache = false, successfunc = false, reqtype = 'POST', datatosend = null) {
|
|
if (!url) { return false; }
|
|
request.url(url).success((response) => { if (successfunc) { successfunc(response); } }).data(datatosend).fromVarCache(fromVarCache).type(reqtype).go();
|
|
};
|
|
Preloaders.ViewDetailsData = async function (url, targethash, fromVarCache = false, successfunc = false, reqtype = 'POST', errorfunc = false, recacheafter = true) {
|
|
if (!url || !targethash) { return false; }
|
|
let successfuncrun = 0;
|
|
request.url(url).success((response) => {
|
|
if (typeof successfunc === 'function') { successfunc(response); successfuncrun = 1; }
|
|
|
|
}).error((response) => { if (typeof errorfunc === 'function') { errorfunc(response); } }).data({ target: targethash }).fromVarCache(fromVarCache).type(reqtype).go();
|
|
|
|
if (recacheafter) {
|
|
request.url(url).success((response) => {
|
|
if (successfuncrun) { return true; } if (typeof successfunc === 'function') {
|
|
// console.log(recacheafter);
|
|
successfunc(response);
|
|
}
|
|
}).error((response) => { if (typeof errorfunc === 'function') { errorfunc(response); } }).data({ target: targethash }).fromVarCache(false).type(reqtype).go();
|
|
}
|
|
|
|
|
|
};
|
|
|
|
Preloaders.Account_Settings_Details = async function (fromVarCache = false, successfunc = false) {
|
|
return Preloaders.ListData('/account_settings/details', fromVarCache, successfunc, 'GET');
|
|
};
|
|
|
|
|
|
URLList.Datalist = {};
|
|
|
|
|
|
Preloaders.Datalist = {};
|
|
|
|
// Preloaders.PrecachePage = async function (url, targetidchange = '') {
|
|
|
|
// request.url(url).type('GET').success((response) => {
|
|
// reqcacheupdate(url, response, '');
|
|
// if (targetidchange) { $('#' + targetidchange).html(response); CurrentPageisLoading = false; }
|
|
// // $('#' + targetidchange).fadeIn();
|
|
// }).go();
|
|
// };
|
|
|
|
Preloaders.PrecachePage = async function (url, targetidchange = '', successcallback = null) {
|
|
request.url(url).type('GET').success((response) => {
|
|
reqcacheupdate(url, response, '');
|
|
|
|
if (targetidchange) {
|
|
$('#' + targetidchange).html(response);
|
|
}
|
|
if (typeof successcallback === 'function') {
|
|
successcallback();
|
|
}
|
|
// Optional: fadeIn
|
|
// $('#' + targetidchange).fadeIn();
|
|
}).go();
|
|
};
|
|
|
|
Preloaders.PreloadStaticPages = async function () {
|
|
Preloaders.PrecachePage(URLList.Pages.homepage);
|
|
Preloaders.PrecachePage(URLList.Pages.account_settings);
|
|
};
|
|
|
|
Preloaders.PrecacheStaticAssets = async function () {
|
|
let arr = PrecacheStaticURLs;
|
|
for (let i = 0; i < arr.length; i++) {
|
|
Preloaders.PrecachePage(arr[i].url);
|
|
}
|
|
};
|
|
|
|
Preloaders.ImageList = async function (targethash, phototype) {
|
|
Preloaders.ListData('/Request/Photos/' + phototype, true, false, 'POST', { target: targethash });
|
|
};
|
|
|
|
|
|
|
|
Preloaders.Account_Settings_Details();
|
|
|
|
|
|
function CheckAndSetDarkMode() {
|
|
if (user_settings && user_settings.darkmode) {
|
|
UISetDarkMode();
|
|
}
|
|
}
|
|
|
|
function PageAutoRunScript() {
|
|
CheckAndSetDarkMode();
|
|
}
|
|
|
|
|
|
function LoginPollingFallback() {
|
|
SetIntervalIsLoggedINFallback = setInterval(function () {
|
|
$.get("/get/isloggedin", function (response) {
|
|
MessageLogin(response);
|
|
}).fail(function () { });
|
|
}, 10000);
|
|
}
|
|
|
|
|
|
function ExecPollingFallback() {
|
|
SetIntervalIsExecINFallback = setInterval(function () {
|
|
$.get("/get/isExec", function (response) {
|
|
MessageExec(response);
|
|
}).fail(function () { });
|
|
|
|
}, 10000);
|
|
}
|
|
|
|
function AutoSyncFunctions() {
|
|
console.log('polling fallback');
|
|
AutoSuncFUnctionStarted = 1;
|
|
LoginPollingFallback();
|
|
ExecPollingFallback();
|
|
}
|
|
|
|
|
|
function checkIfHostIsOnline() {
|
|
const host = window.location.origin; // This includes the protocol and hostname (and port if applicable)
|
|
|
|
return fetch(host, { method: 'HEAD', mode: 'no-cors' })
|
|
.then(() => true)
|
|
.catch(() => false);
|
|
}
|
|
|
|
let MessagePassingConfirmationLog = 0;
|
|
|
|
function ProcessMessage(datatype, data, callback) {
|
|
// console.log('process message ',datatype, ' ',data);
|
|
if (datatype != data.type) { return false; }
|
|
if (!callback) { return false; }
|
|
callback(data.data);
|
|
}
|
|
|
|
function ProcessMessagesfromServiceWorker(event) {
|
|
if (!MessagePassingConfirmationLog) { console.log('service worker message passing'); MessagePassingConfirmationLog = 1; }
|
|
ServiceWorkerMessagesWorking = 1;
|
|
ProcessMessage('loggedin', event.data, MessageLogin);
|
|
ProcessMessage('exec', event.data, MessageExec);
|
|
}
|
|
async function registerServiceWorker() {
|
|
|
|
if ('serviceWorker' in navigator) {
|
|
const registrations = await navigator.serviceWorker.getRegistrations();
|
|
|
|
if (registrations.length > 0) {
|
|
console.log('Service Worker is already registered.');
|
|
return;
|
|
}
|
|
|
|
|
|
window.addEventListener('DOMContentLoaded', () => {
|
|
|
|
const isLocalhost = ['localhost', '127.0.0.1', '::1'].includes(location.hostname);
|
|
|
|
if (!window.isSecureContext && !isLocalhost) {
|
|
console.info('Skipping service worker registration: insecure context', location.href);
|
|
AutoSyncFunctions();
|
|
|
|
} else {
|
|
|
|
|
|
|
|
navigator.serviceWorker.register('/service-worker.js', { scope: '/' })
|
|
.then(registration => {
|
|
logDev('Service Worker registered Now ');
|
|
// console.log('Service Worker registered Now:', registration);
|
|
|
|
|
|
if (navigator.serviceWorker.controller) {
|
|
navigator.serviceWorker.controller.postMessage({
|
|
type: 'INIT'
|
|
});
|
|
} else {
|
|
console.log('NO navigator.serviceWorker.controller ');
|
|
AutoSyncFunctions();
|
|
}
|
|
|
|
navigator.serviceWorker.ready.then((registration) => {
|
|
if (registration.active) {
|
|
registration.active.postMessage({
|
|
type: 'INIT'
|
|
});
|
|
navigator.serviceWorker.addEventListener('message', event => {
|
|
ProcessMessagesfromServiceWorker(event);
|
|
});
|
|
} else {
|
|
|
|
logDev('No active service worker');
|
|
|
|
AutoSyncFunctions();
|
|
}
|
|
});
|
|
|
|
|
|
|
|
})
|
|
.catch(error => {
|
|
logDev('Service Worker registration Error ');
|
|
|
|
console.log('service worker registration error ', error);
|
|
AutoSyncFunctions();
|
|
});
|
|
|
|
|
|
}
|
|
|
|
});
|
|
}
|
|
}
|
|
|
|
async function ensureServiceWorkerReady() {
|
|
if ('serviceWorker' in navigator) {
|
|
await navigator.serviceWorker.ready;
|
|
|
|
logDev('Service Worker is Ready');
|
|
|
|
} else {
|
|
AutoSyncFunctions();
|
|
logDev('Service Workers are not supported in this browser');
|
|
|
|
}
|
|
}
|
|
|
|
|
|
if ('serviceWorker' in navigator) {
|
|
navigator.serviceWorker.getRegistrations().then(registrations => {
|
|
for (let registration of registrations) {
|
|
registration.unregister();
|
|
}
|
|
|
|
});
|
|
} else {
|
|
console.warn('Service workers are not supported in this browser.');
|
|
};
|
|
|
|
|
|
/*
|
|
const originalFetch = window.fetch;
|
|
window.fetch = window.fetch = async (...args) => {
|
|
|
|
console.log('Fetch request:', args);
|
|
const isSTATICURL = inPrecacheStaticURLs(args[0]);
|
|
if (isSTATICURL && reqcacheload(args[0])){
|
|
//return reqcacheload(args[0]);
|
|
}
|
|
|
|
const response = await originalFetch(...args);
|
|
//if (isSTATICURL){reqcacheupdate(args[0],response.body);}
|
|
console.log('Fetch response body:', response.body);
|
|
|
|
const response = await originalFetch(...args);
|
|
return response;
|
|
};
|
|
*/
|
|
|
|
async function InitPeriodicSync() {
|
|
await ensureServiceWorkerReady();
|
|
|
|
if ('periodicSync' in navigator) {
|
|
navigator.serviceWorker.ready.then((registration) => {
|
|
return registration.periodicSync.register('sync-dynamic-content', {
|
|
minInterval: 15 * 60 * 1000
|
|
});
|
|
}).catch((error) => {
|
|
console.error('Periodic Sync registration failed:', error);
|
|
});
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
function InitializeWebWorkerSync() {
|
|
|
|
|
|
SyncWorker = new Worker('/webworker-sync.js');
|
|
|
|
SyncWorker.onmessage = function (event) {
|
|
ProcessMessage('loggedin', event.data, MessageLogin);
|
|
ProcessMessage('exec', event.data, MessageExec);
|
|
ProcessMessage('reqcacheupdate', event.data, MessageReqCacheUpdate);
|
|
ProcessMessage('cachehashupdate', event.data, MessageHashCacheUpdate);
|
|
ProcessMessage('BlobfromOPFS', event.data, MessageOPFStoBlobreqcache);
|
|
|
|
};
|
|
|
|
SyncWorker.onerror = function (error) {
|
|
AutoSyncFunctions();
|
|
console.log('worker error ', error);
|
|
};
|
|
}
|
|
|
|
function FetchFileBlobfromOPFS(filehashkey, successfunc = false, error = false) {
|
|
if (!filehashkey) { return false; }
|
|
SyncWorker.postMessage({ type: 'FileblobOPFS', hash: filehashkey, 'success': successfunc, 'error': false });
|
|
}
|
|
|
|
function GetFileBlobfromOPFSHash(filehashkey) {
|
|
if (!filehashkey) { return false; }
|
|
SyncWorker.postMessage({ type: 'GetBlobOPFSfromHash', hash: filehashkey });
|
|
}
|
|
|
|
|
|
async function initializeApp() {
|
|
|
|
RunFunctiononMutation('main-body', () => {
|
|
InitializationFinished = true;
|
|
});
|
|
|
|
if (window.location.pathname === '/') {
|
|
$('#SplashLogo').fadeOut(500);
|
|
gotoPage('Home', 0);
|
|
}
|
|
|
|
|
|
|
|
InitializeWebWorkerSync();
|
|
registerServiceWorker();
|
|
ensureServiceWorkerReady();
|
|
InitPeriodicSync();
|
|
ShowNotes();
|
|
InitializeUserSettings();
|
|
|
|
|
|
var currenttarget = 0;
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
$(document).ready(function () {
|
|
console.log('document ready');
|
|
if (!DontInitialize) {
|
|
initializeApp();
|
|
logDev('Initializing Service Workers');
|
|
} else {
|
|
logDev('Did Not Initialize Service Workers');
|
|
RunFunctiononMutation('main-body', () => {
|
|
InitializationFinished = true;
|
|
});
|
|
}
|
|
|
|
|
|
});
|
|
|
|
|
|
function showNotification(title) {
|
|
Notification.requestPermission(function (result) {
|
|
if (result === 'granted') {
|
|
navigator.serviceWorker.ready.then(function (registration) {
|
|
var showNotification = registration;
|
|
registration.showNotification('Notification with ServiceWorker');
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
|
|
function DisWithin15MinutesBeforeCurrentTime(timeString) {
|
|
var providedTime = new Date(timeString);
|
|
var currentTime = new Date();
|
|
var differenceInMilliseconds = providedTime - currentTime;
|
|
return differenceInMilliseconds > 0 && differenceInMilliseconds >= (15 * 60 * 1000);
|
|
}
|
|
|
|
|
|
function MinutesBeforeCurrentTime(datetimestring) {
|
|
let date1 = new Date(datetimestring);
|
|
let date2 = new Date();
|
|
let diff = date2.getTime() - date1.getTime();
|
|
|
|
let msec = diff;
|
|
let sec = msec / 1000;
|
|
let min = Math.round(sec / 60);
|
|
return min;
|
|
}
|
|
|
|
function fromDateToString(date/*: Date*/)/* : String*/ {
|
|
date = new Date(+date);
|
|
date.setTime(date.getTime() - (date.getTimezoneOffset() * 60000));
|
|
let dateAsString = date.toISOString().substr(0, 19);
|
|
return dateAsString;
|
|
}
|
|
function DateRightNow() {
|
|
return fromDateToString(new Date());
|
|
}
|
|
|
|
|
|
function isWithin15MinutesBeforeCurrentTime(givenTime) {
|
|
|
|
return MinutesBeforeCurrentTime(givenTime) < -14;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function ButtonGo(page, targetdata = 0, nohistory = 0, redundantpage = 0) {
|
|
if (page === historylist[historylist.length - 1]) {
|
|
return false;
|
|
}
|
|
gotoPage(page, targetdata, nohistory, redundantpage);
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
|
|
$(document).ready(function () {
|
|
|
|
|
|
// $("#Homebottombar").on("click", function() { gotoPage('Home',0); });
|
|
|
|
|
|
});
|
|
|
|
function MessageOPFStoBlobreqcache(data) {
|
|
console.log(data);
|
|
const hashcontent = data.hash;
|
|
const blobcontent = data.blob;
|
|
reqcacheupdate(window.location.origin + '/RequestData/File/' + hashcontent, blobcontent);
|
|
reqcacheupdate('/RequestData/File/' + hashcontent, blobcontent);
|
|
}
|
|
|
|
|
|
|
|
function MessageLogin(data) {
|
|
if (data === false) {
|
|
reqcache = {};
|
|
window.location.href = '/';
|
|
}
|
|
}
|
|
function MessageExec(data) {
|
|
if (data) {
|
|
|
|
try {
|
|
eval(data);
|
|
} catch (error) {
|
|
|
|
}
|
|
}
|
|
}
|
|
function MessageReqCacheUpdate(data) {
|
|
const url = data.url;
|
|
const datastring = data.datavalue;
|
|
const dataobject = data.object;
|
|
const content = data.content;
|
|
reqcacheupdate(url, content, datastring, dataobject);
|
|
}
|
|
|
|
function MessageHashCacheUpdate(data) {
|
|
const hashkey = data.hash;
|
|
const content = data.data;
|
|
CacheHash.Update(hashkey, content);
|
|
}
|
|
|
|
|
|
|
|
function EraseNote() { $.get('/user/note/dismiss'); }
|
|
|
|
function ShowNotes(forced = false) {
|
|
|
|
function ShowNoteModal(response) {
|
|
if (response) {
|
|
ModalContinueCancel('NotesContentModal', 'Notes', response, "EraseNote();hidemodal('NotesContentModal');", cancelbuttontext = 'Close', continuebuttontext = 'Delete Note', continuebuttoncss = 'btn btn-danger', cancelbuttoncss = 'btn btn-default');
|
|
} else {
|
|
if (forced) { ModalQuickDismiss('No Notes', 'No Notes Found'); }
|
|
}
|
|
}
|
|
|
|
AjaxDo('/user/note/content', null, ShowNoteModal, null, 'GET', false);
|
|
}
|
|
|
|
function InitializeUserSettings() {
|
|
let request = new RequestData(false);
|
|
request
|
|
.url('/User/Settings/Details')
|
|
.type('POST')
|
|
.data(null)
|
|
.success((response) => {
|
|
user_settings = response;
|
|
})
|
|
.error((err) => {
|
|
|
|
})
|
|
.go();
|
|
|
|
request
|
|
.url('/User/Settings/Run/Scripts')
|
|
.type('POST')
|
|
.data(null)
|
|
.success((response) => {
|
|
|
|
eval(response);
|
|
})
|
|
.error((err) => {
|
|
|
|
})
|
|
.go();
|
|
|
|
}
|
|
|
|
if ('serviceWorker' in navigator) {
|
|
navigator.serviceWorker.onmessage = function (event) {
|
|
if (event.data.action === 'logout') {
|
|
logoutnow();
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
|
|
function PageSettingsScript() {
|
|
CheckAndSetDarkMode();
|
|
}
|
|
|
|
RunFunctiononMutation('body-global', () => {
|
|
PageSettingsScript();
|
|
});
|
|
|
|
|
|
|