734 lines
27 KiB
JavaScript
734 lines
27 KiB
JavaScript
// Copyright (c) 2024, snegov
|
|
// All rights reserved.
|
|
|
|
const pathnameRegex = /^\/\w{2}-\w{2}\/n?iv/;
|
|
const MAX_SIGNIN_ATTEMPTS = 3;
|
|
const PAGE_WAIT_TIME = 3792;
|
|
const MINUTE = 60;
|
|
const RANDOM_JITTER = 0.1;
|
|
const SOFT_BAN_TIMEOUT = 27;
|
|
const NOTIF_CHANNEL = "snegov_test"
|
|
|
|
let cfg = {
|
|
activate: undefined,
|
|
username: undefined,
|
|
password: undefined,
|
|
frequency: undefined,
|
|
consulates: undefined,
|
|
deltaAppt: undefined,
|
|
deltaNow: undefined,
|
|
};
|
|
let ctx = {
|
|
apptId: undefined,
|
|
currentAppt: {
|
|
consulate: undefined,
|
|
date: undefined,
|
|
},
|
|
signinAttempts: undefined,
|
|
consulates: undefined,
|
|
statusMsg: undefined,
|
|
}
|
|
let isRunning = false;
|
|
let msg = "";
|
|
let isFoundAppointment = false;
|
|
|
|
async function delay(ms) {
|
|
return new Promise(resolve => setTimeout(resolve, ms));
|
|
}
|
|
|
|
async function sendNotification(message, channel = NOTIF_CHANNEL) {
|
|
await fetch('https://ntfy.sh/' + channel, {
|
|
method: 'POST',
|
|
body: "[US visa bot] " + message,
|
|
})
|
|
.then(() => console.log('Notification sent'))
|
|
.catch(e => console.error(e));
|
|
}
|
|
|
|
function getRandomInt(max) {
|
|
return Math.floor(Math.random() * Math.floor(max));
|
|
}
|
|
|
|
|
|
function getJitter(frequency) {
|
|
return frequency * MINUTE * RANDOM_JITTER;
|
|
}
|
|
|
|
function getFutureDate(minutes, maxRandomSeconds = 0) {
|
|
// return date some amount of minutes in future plus random amount of seconds
|
|
let futureDate = new Date();
|
|
futureDate.setSeconds(futureDate.getSeconds() + minutes * MINUTE + getRandomInt(maxRandomSeconds));
|
|
return futureDate.toISOString();
|
|
}
|
|
|
|
function hiddenPassword(cfg) {
|
|
return {
|
|
...cfg,
|
|
password: cfg.password.replace(/./g, "*"),
|
|
};
|
|
}
|
|
|
|
function diffObjects(obj1, obj2) {
|
|
let diff = {};
|
|
|
|
for (let key in obj1) {
|
|
if (typeof obj1[key] === 'object' && obj1[key] !== null && obj2[key]) {
|
|
let nestedDiff = diffObjects(obj1[key], obj2[key]);
|
|
if (Object.keys(nestedDiff).length > 0) {
|
|
diff[key] = nestedDiff;
|
|
}
|
|
} else if (obj2[key] && obj1[key] !== obj2[key]) {
|
|
diff[key] = [obj1[key], obj2[key]];
|
|
}
|
|
}
|
|
|
|
for (let key in obj2) {
|
|
if (obj1[key] === undefined && obj2[key] !== undefined) {
|
|
diff[key] = [undefined, obj2[key]];
|
|
}
|
|
}
|
|
|
|
return diff;
|
|
}
|
|
|
|
function hasAllKeys(obj, keys) {
|
|
return keys.every(k => obj.hasOwnProperty(k));
|
|
}
|
|
|
|
function ensureRequiredConsulateProperties(consCtx, consCfg, frequency = 1) {
|
|
let reqCfgKeys = ["isSelected", "autoBook"];
|
|
let reqStateKeys = ["id", "bestDate", "currentDate", "nextCheckAt"];
|
|
|
|
for (let c in consCtx) {
|
|
if (!hasAllKeys(consCtx[c], reqStateKeys)) {
|
|
consCtx[c] = {
|
|
"id": consCtx[c]?.id || null,
|
|
"bestDate": consCtx[c]?.bestDate || null,
|
|
"currentDate": consCtx[c]?.currentDate || null,
|
|
"nextCheckAt": consCtx[c]?.nextCheckAt || getFutureDate(0, frequency * MINUTE),
|
|
};
|
|
}
|
|
if (!consCfg[c] || !hasAllKeys(consCfg[c], reqCfgKeys)) {
|
|
consCfg[c] = {
|
|
"isSelected": consCfg[c]?.isSelected || false,
|
|
"autoBook": consCfg[c]?.autoBook || false,
|
|
};
|
|
}
|
|
}
|
|
|
|
return [consCtx, consCfg];
|
|
}
|
|
|
|
function getPathnameParts(pathname) {
|
|
let pathParts = pathname.split('/');
|
|
let locale = pathParts[1] || 'en-us';
|
|
let visaType = pathParts[2] || 'niv';
|
|
return [ locale, visaType ];
|
|
}
|
|
|
|
function isSignInPage() {
|
|
return Boolean(window.location.pathname.match(/^\/\w{2}-\w{2}\/n?iv\/users\/sign_in/));
|
|
}
|
|
|
|
function isLoggedOutPage() {
|
|
return Boolean(window.location.pathname.match(/^\/\w{2}-\w{2}\/n?iv$/));
|
|
}
|
|
|
|
function isDashboardPage() {
|
|
return Boolean(window.location.pathname.match(/^\/\w{2}-\w{2}\/n?iv\/groups\/\d+/));
|
|
}
|
|
|
|
function isAppointmentPage() {
|
|
return Boolean(window.location.pathname.match(/^\/\w{2}-\w{2}\/n?iv\/schedule\/\d+\/appointment$/));
|
|
}
|
|
|
|
function isConfirmationPage() {
|
|
return Boolean(window.location.pathname.match(/^\/\w{2}-\w{2}\/n?iv\/schedule\/\d+\/appointment\/instructions$/));
|
|
}
|
|
|
|
function isNotEnglishPage() {
|
|
return Boolean(isSignInPage()
|
|
|| isLoggedOutPage()
|
|
|| isDashboardPage()
|
|
|| isAppointmentPage()
|
|
|| isConfirmationPage()
|
|
) && !window.location.pathname.match(/^\/en-/);
|
|
}
|
|
|
|
async function handleHttpError(e) {
|
|
if (e.response && e.response.status === 401) {
|
|
msg = "Unauthorized";
|
|
console.log(msg);
|
|
await sendNotification(msg);
|
|
await logOut();
|
|
} else {
|
|
console.error(e);
|
|
}
|
|
}
|
|
|
|
async function switchToEnglishPage() {
|
|
window.location.href(window.location.pathname.replace(/^\/\w{2}-{2}/, '/en-us'));
|
|
await delay(PAGE_WAIT_TIME);
|
|
// Should be on English page
|
|
}
|
|
|
|
async function logOut() {
|
|
let [locale, visaType] = getPathnameParts(window.location.pathname);
|
|
let signOutPath = `/${locale}/${visaType}/users/sign_out`;
|
|
window.location.href = window.location.origin + signOutPath;
|
|
await delay(PAGE_WAIT_TIME);
|
|
return isLoggedOutPage();
|
|
}
|
|
|
|
async function goToSignInPage() {
|
|
let [locale, visaType] = getPathnameParts(window.location.pathname);
|
|
let signInPath = `/${locale}/${visaType}/users/sign_in`;
|
|
window.location.href = window.location.origin + signInPath;
|
|
await delay(PAGE_WAIT_TIME);
|
|
return isSignInPage();
|
|
}
|
|
|
|
async function goToDashboardPage() {
|
|
let [locale, visaType] = getPathnameParts(window.location.pathname);
|
|
let dashboardPath = `/${locale}/${visaType}/account`;
|
|
window.location.href = window.location.origin + dashboardPath;
|
|
await delay(PAGE_WAIT_TIME);
|
|
return isDashboardPage();
|
|
}
|
|
|
|
async function enterCredentials(username, password) {
|
|
// close warning modal
|
|
let modalElement = Array.from(document.querySelectorAll('div'))
|
|
.find(d => d.textContent.includes('You need to sign in or sign up before continuing.'));
|
|
if (modalElement && window.getComputedStyle(modalElement).display !== 'none') {
|
|
let buttons = Array.from(modalElement.querySelectorAll('button'));
|
|
let okButton = buttons.find(b => b.textContent === 'OK');
|
|
if (okButton) {
|
|
okButton.click();
|
|
await delay(PAGE_WAIT_TIME);
|
|
}
|
|
}
|
|
|
|
document.getElementById("user_email").value = username;
|
|
document.getElementById("user_password").value = password;
|
|
let policyConfirmed = document.querySelector('[for="policy_confirmed"]');
|
|
if (!policyConfirmed.getElementsByTagName('input')[0].checked) {
|
|
policyConfirmed.click();
|
|
}
|
|
document.querySelector("#sign_in_form input[type=submit]").click();
|
|
|
|
await delay(PAGE_WAIT_TIME);
|
|
return isDashboardPage();
|
|
}
|
|
|
|
async function getAppointmentId() {
|
|
let appointments = document.querySelectorAll("p.consular-appt [href]")
|
|
if (appointments.length > 1) {
|
|
console.log("Multiple appointments found, taking the first one");
|
|
}
|
|
let apptId = appointments[0].href.replace(/\D/g, "");
|
|
return apptId;
|
|
}
|
|
|
|
async function getConsulates() {
|
|
let consulatesSelect = document.querySelector("#appointments_consulate_appointment_facility_id")
|
|
let consulatesDict = {};
|
|
|
|
for (let option of consulatesSelect.options) {
|
|
if (!option.value) continue; // skip empty option
|
|
consulatesDict[option.text] = {
|
|
"id": parseInt(option.value),
|
|
};
|
|
}
|
|
return consulatesDict;
|
|
}
|
|
|
|
async function getAvailableDates(consulateId) {
|
|
let addressUri = window.location.pathname + `/address/${consulateId}`
|
|
fetch(addressUri, { headers: { "x-requested-with": "XMLHttpRequest" } })
|
|
.catch(error => console.error('Error:', error));
|
|
|
|
let datesUri = window.location.pathname + `/days/${consulateId}.json?appointments[expedite]=false`
|
|
let dates = fetch(datesUri, { headers: {
|
|
"x-requested-with": "XMLHttpRequest",
|
|
"accept": "application/json, text/javascript, */*; q=0.01",
|
|
// "cache-control": "no-cache",
|
|
}})
|
|
.catch(async e => {
|
|
await handleHttpError(e);
|
|
throw e;
|
|
})
|
|
.then(d => d.json())
|
|
.then(data => {
|
|
let dateList = data.map(item => item.date);
|
|
dateList.sort();
|
|
return dateList;
|
|
})
|
|
.catch(e => null);
|
|
return dates;
|
|
}
|
|
|
|
async function filterDates(dates, currentAppt, deltaFromAppt, deltaFromNow) {
|
|
let maxDate = new Date(currentAppt);
|
|
maxDate.setDate(maxDate.getDate() - deltaFromAppt);
|
|
let minDate = new Date();
|
|
minDate.setDate(minDate.getDate() + deltaFromNow);
|
|
let availableDates = dates.filter(d => new Date(d) >= minDate && new Date(d) < maxDate);
|
|
return availableDates;
|
|
}
|
|
|
|
async function getAvailableTimes(consulateId, date) {
|
|
let uri = window.location.pathname + `/times/${consulateId}.json?date=${date}&appointments[expedite]=false`
|
|
let times = fetch(uri, { headers: { "x-requested-with": "XMLHttpRequest" } })
|
|
.catch(async e => {
|
|
await handleHttpError(e);
|
|
throw e;
|
|
})
|
|
.then(d => d.json())
|
|
.then(data => data.available_times)
|
|
.catch(e => null);
|
|
return times;
|
|
}
|
|
|
|
async function runner() {
|
|
if (isRunning) {
|
|
return;
|
|
}
|
|
isRunning = true;
|
|
|
|
let prev_cfg = Object.assign({}, cfg);
|
|
let prev_ctx = Object.assign({}, ctx);
|
|
|
|
let result = await new Promise(resolve => chrome.storage.local.get(null, resolve));
|
|
cfg.activate = result['cfg_activate'] || false;
|
|
cfg.username = result['cfg_username'] || "";
|
|
cfg.password = result['cfg_password'] || "";
|
|
cfg.frequency = parseFloat(result['cfg_frequency'] || 1);
|
|
cfg.consulates = result['cfg_consulates'] || {};
|
|
cfg.deltaAppt = result['cfg_deltaAppt'] || 1;
|
|
cfg.deltaNow = result['cfg_deltaNow'] || 1;
|
|
|
|
ctx.apptId = result['ctx_apptId'] || null;
|
|
ctx.signinAttempts = result['ctx_signinAttempts'] || 0;
|
|
ctx.currentAppt = result['ctx_currentAppt'] || { consulate: null, date: null };
|
|
ctx.consulates = result['ctx_consulates'] || {};
|
|
ctx.statusMsg = result['ctx_statusMsg'] || "";
|
|
|
|
[ctx.consulates, cfg.consulates] = ensureRequiredConsulateProperties(
|
|
ctx.consulates, cfg.consulates, cfg.frequency
|
|
);
|
|
await chrome.storage.local.set({ "cfg_consulates": cfg.consulates });
|
|
await chrome.storage.local.set({ "ctx_consulates": ctx.consulates });
|
|
|
|
if (prev_cfg.activate === undefined) {
|
|
console.log('Reading config: ' + JSON.stringify(hiddenPassword(cfg)));
|
|
isRunning = false;
|
|
return;
|
|
}
|
|
|
|
for (let key in cfg) {
|
|
if (cfg.hasOwnProperty(key)
|
|
&& !_.isEqual(cfg[key], prev_cfg[key])) {
|
|
msg = `Config change: ${key}`
|
|
if (key === 'password') {
|
|
msg += ', ******** => ********';
|
|
} else if (key === 'consulates') {
|
|
msg += `, ${JSON.stringify(diffObjects(cfg[key], prev_cfg[key]))}`;
|
|
} else {
|
|
msg += `, ${prev_cfg[key]} => ${cfg[key]}`;
|
|
}
|
|
console.log(msg);
|
|
|
|
// reduce wait times for consulates if frequency is increased
|
|
if (key === 'frequency') {
|
|
let wasChanged = false;
|
|
for (let c in ctx.consulates) {
|
|
let newNextCheckAt = getFutureDate(cfg.frequency, getJitter(cfg.frequency));
|
|
if (ctx.consulates[c].nextCheckAt > newNextCheckAt) {
|
|
console.log(`Reducing wait time for ${c} from ${ctx.consulates[c].nextCheckAt} to ${newNextCheckAt}`);
|
|
ctx.consulates[c].nextCheckAt = newNextCheckAt;
|
|
wasChanged = true;
|
|
}
|
|
}
|
|
// TODO maybe causes additional requests
|
|
if (wasChanged) {
|
|
await chrome.storage.local.set({ "ctx_consulates": ctx.consulates });
|
|
}
|
|
}
|
|
|
|
if (key === 'activate') {
|
|
if (cfg[key]) {
|
|
console.log('Activating extension');
|
|
} else {
|
|
console.log('Deactivating extension');
|
|
await chrome.storage.local.set({ "ctx_statusMsg": "inactive" });
|
|
}
|
|
}
|
|
|
|
// clear signin attempts when credentials are changed
|
|
if (key === 'username' && cfg[key]
|
|
|| key === 'password' && cfg[key]) {
|
|
ctx.signinAttempts = 0;
|
|
await chrome.storage.local.set({ "ctx_signinAttempts": ctx.signinAttempts });
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!cfg.activate) {
|
|
isRunning = false;
|
|
return;
|
|
}
|
|
|
|
if (cfg.username === "" || cfg.password === "") {
|
|
console.log('Username or password is empty');
|
|
await chrome.storage.local.set({ "ctx_statusMsg": "missing credentials" });
|
|
isRunning = false;
|
|
return;
|
|
}
|
|
|
|
if (cfg.frequency <= 0) {
|
|
console.log('Frequency is 0 or negative');
|
|
await chrome.storage.local.set({ "ctx_statusMsg": "invalid frequency" });
|
|
isRunning = false;
|
|
return;
|
|
}
|
|
|
|
// Check if current time is between 11pm and 9am UTC (4pm - 2am PST)
|
|
let now = new Date();
|
|
let currentHourUTC = now.getUTCHours();
|
|
if (currentHourUTC >= 23 || currentHourUTC < 9) {
|
|
// Continue running the code
|
|
} else {
|
|
await chrome.storage.local.set({ "ctx_statusMsg": "not operational hours" });
|
|
isRunning = false;
|
|
return;
|
|
}
|
|
|
|
if (isFoundAppointment) {
|
|
// don't do anything if appointment is found and manual booking is required
|
|
if (isAppointmentPage()) {
|
|
isRunning = false;
|
|
return;
|
|
// we're not on an appointment page, so seems like we're done, and we can check dates again
|
|
} else {
|
|
isFoundAppointment = false;
|
|
}
|
|
}
|
|
|
|
if (isNotEnglishPage()) {
|
|
await switchToEnglishPage();
|
|
}
|
|
|
|
if (isLoggedOutPage()) {
|
|
if (!await goToSignInPage()) {
|
|
msg = 'Failed to go to sign in page';
|
|
console.log(msg);
|
|
await chrome.storage.local.set({ "ctx_statusMsg": msg });
|
|
isRunning = false;
|
|
return;
|
|
};
|
|
|
|
}
|
|
|
|
else if (isSignInPage()) {
|
|
// Prevent brute forcing
|
|
if (ctx.signinAttempts >= MAX_SIGNIN_ATTEMPTS) {
|
|
if (prev_ctx.signinAttempts < MAX_SIGNIN_ATTEMPTS) {
|
|
msg = 'Too many sign in attempts';
|
|
console.log(msg);
|
|
await sendNotification(msg);
|
|
}
|
|
await chrome.storage.local.set({ "ctx_statusMsg": "too many sign in attempts" });
|
|
isRunning = false;
|
|
return;
|
|
}
|
|
|
|
// Sign in
|
|
msg = 'Signing in attempt: ' + ctx.signinAttempts;
|
|
console.log(msg)
|
|
await chrome.storage.local.set({ "ctx_statusMsg": msg });
|
|
let signedIn = await enterCredentials(cfg.username, cfg.password);
|
|
ctx.signinAttempts += 1;
|
|
await chrome.storage.local.set({ "ctx_signinAttempts": ctx.signinAttempts });
|
|
if (!signedIn) {
|
|
msg = 'Failed to sign in';
|
|
console.log(msg);
|
|
await chrome.storage.local.set({ "ctx_statusMsg": msg });
|
|
isRunning = false;
|
|
return;
|
|
};
|
|
|
|
}
|
|
|
|
else if (isDashboardPage()) {
|
|
// reset signin attempts when successfully logged in
|
|
ctx.signinAttempts = 0;
|
|
await chrome.storage.local.set({ "ctx_statusMsg": "fetching appointment info" });
|
|
await chrome.storage.local.set({ "ctx_signinAttempts": ctx.signinAttempts });
|
|
|
|
// get appointmentId
|
|
if (!ctx.apptId) {
|
|
ctx.apptId = await getAppointmentId();
|
|
if (ctx.apptId) {
|
|
console.log(`Appointment ID: ${ctx.apptId}`);
|
|
await chrome.storage.local.set({ "ctx_apptId": ctx.apptId });
|
|
} else {
|
|
msg = 'No appointments found';
|
|
console.log(msg);
|
|
await chrome.storage.local.set({ "ctx_statusMsg": msg });
|
|
isRunning = false;
|
|
return;
|
|
}
|
|
}
|
|
|
|
// get current appointment date
|
|
let apptInfoCard = document.querySelector("p.consular-appt [href*='" + ctx.apptId + "']").parentNode.parentNode.parentNode
|
|
if (!apptInfoCard.querySelector("h4").innerText.match(/Attend Appointment/)) {
|
|
msg = 'Appointment not available';
|
|
console.log(msg);
|
|
await chrome.storage.local.set({ "ctx_statusMsg": msg });
|
|
isRunning = false;
|
|
return;
|
|
}
|
|
let apptInfo = apptInfoCard.querySelector("p.consular-appt").innerText;
|
|
let apptConsulate = (apptInfo.match(/at (\w+)/) || [])[1];
|
|
let apptDate = new Date(apptInfo.match(/\d{1,2} \w+, \d{4}/)[0]);
|
|
apptDate = apptDate.toISOString().slice(0, 10);
|
|
if (!apptDate || !apptConsulate) {
|
|
msg = 'Failed to fetch appointment date or consulate';
|
|
console.log(msg);
|
|
await chrome.storage.local.set({ "ctx_statusMsg": msg });
|
|
isRunning = false;
|
|
return;
|
|
}
|
|
|
|
if (apptDate != ctx.currentAppt.date || apptConsulate != ctx.currentAppt.consulate) {
|
|
console.log(`New appointment date: ${apptDate} at ${apptConsulate},
|
|
old: ${ctx.currentAppt.consulate} at ${ctx.currentAppt.date}`);
|
|
ctx.currentAppt = { consulate: apptConsulate, date: apptDate };
|
|
await chrome.storage.local.set({ "ctx_currentAppt": ctx.currentAppt });
|
|
}
|
|
|
|
// go to appointment page
|
|
let apptLink = apptInfoCard.querySelector("p.consular-appt [href]")
|
|
.getAttribute("href").replace("/addresses/consulate", "/appointment");
|
|
window.location.href = apptLink;
|
|
await delay(PAGE_WAIT_TIME);
|
|
}
|
|
|
|
else if (isAppointmentPage()) {
|
|
// if no apptDate, fetch it from dashboard page
|
|
if (!ctx.currentAppt.date) {
|
|
console.log('No appointment date is set, going back to dashboard');
|
|
await goToDashboardPage();
|
|
isRunning = false;
|
|
return;
|
|
}
|
|
|
|
let applicantForm = document.querySelector('form[action*="' + window.location.pathname + '"]');
|
|
if (applicantForm && applicantForm.method.toLowerCase() == "get") {
|
|
applicantForm.submit();
|
|
await delay(PAGE_WAIT_TIME);
|
|
isRunning = false;
|
|
return;
|
|
}
|
|
|
|
// TODO maybe it's a rare case
|
|
if (!document.getElementById("consulate_date_time")) {
|
|
msg = 'No available appointments';
|
|
console.log(msg);
|
|
await chrome.storage.local.set({ "ctx_statusMsg": msg });
|
|
isRunning = false;
|
|
return;
|
|
};
|
|
|
|
if (!ctx.consulates || Object.keys(ctx.consulates).length == 0) {
|
|
await chrome.storage.local.set({ "ctx_statusMsg": "Fetching consulates" });
|
|
ctx.consulates = await getConsulates();
|
|
if (!ctx.consulates || Object.keys(ctx.consulates).length == 0) {
|
|
msg = "No consulates found";
|
|
console.log(msg);
|
|
await chrome.storage.local.set({ "ctx_statusMsg": msg });
|
|
sendNotification(msg);
|
|
}
|
|
|
|
[ctx.consulates, cfg.consulates] = ensureRequiredConsulateProperties(
|
|
ctx.consulates, cfg.consulates, cfg.frequency
|
|
);
|
|
|
|
// if no consulates are selected, select one which we have appointment with
|
|
let selectedConsulates = Object.keys(ctx.consulates).filter(c => cfg.consulates[c].isSelected);
|
|
if (selectedConsulates.length == 0) {
|
|
for (let c in cfg.consulates) {
|
|
if (c === ctx.currentAppt.consulate) {
|
|
cfg.consulates[c].isSelected = true;
|
|
}
|
|
}
|
|
}
|
|
await chrome.storage.local.set({ "cfg_consulates": cfg.consulates });
|
|
await chrome.storage.local.set({ "ctx_consulates": ctx.consulates });
|
|
isRunning = false;
|
|
return;
|
|
}
|
|
|
|
// TODO choose ASC facility
|
|
// document.querySelector("#appointments_asc_appointment_facility_id [selected]").innerText
|
|
|
|
// for each selected consulate check available dates
|
|
let selectedConsulates = Object.keys(ctx.consulates).filter(c => cfg.consulates[c].isSelected);
|
|
if (selectedConsulates.length == 0) {
|
|
msg = 'No selected consulates found';
|
|
console.log(msg);
|
|
await chrome.storage.local.set({ "ctx_statusMsg": msg });
|
|
isRunning = false;
|
|
return;
|
|
}
|
|
|
|
let processedConsulates = 0;
|
|
for (let c of selectedConsulates) {
|
|
// only one consulate per run
|
|
if (processedConsulates > 0) {
|
|
break;
|
|
}
|
|
// skip if not time to check
|
|
if (ctx.consulates[c].nextCheckAt > new Date().toISOString()) {
|
|
continue;
|
|
}
|
|
|
|
processedConsulates += 1;
|
|
|
|
msg = `Checking dates for ${c}`;
|
|
console.log(msg);
|
|
await chrome.storage.local.set({ "ctx_statusMsg": msg });
|
|
let availDates = await getAvailableDates(ctx.consulates[c].id);
|
|
ctx.consulates[c].nextCheckAt = getFutureDate(cfg.frequency, getJitter(cfg.frequency));
|
|
|
|
if (!availDates) {
|
|
msg = `Failed to fetch available dates in ${c}`;
|
|
console.log(msg);
|
|
await chrome.storage.local.set({ "ctx_statusMsg": msg });
|
|
continue;
|
|
}
|
|
|
|
// if empty list, either we're banned or non operational hours or dead consulate
|
|
// wait for some time before checking again
|
|
let now = new Date();
|
|
let currentHourUTC = now.getUTCHours();
|
|
let currentMinuteUTC = now.getUTCMinutes();
|
|
|
|
if (availDates.length == 0) {
|
|
msg = `No available dates in ${c}, probably banned`;
|
|
console.log(msg);
|
|
await chrome.storage.local.set({ "ctx_statusMsg": msg });
|
|
|
|
// Only set SOFT_BAN_TIMEOUT if it's not the first 5 minutes of 23pm UTC
|
|
if (!(currentHourUTC === 23 && currentMinuteUTC < 5)) {
|
|
ctx.consulates[c].nextCheckAt = getFutureDate(SOFT_BAN_TIMEOUT, getJitter(cfg.frequency));
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
msg = `Available dates for ${c}: ${availDates.slice(0, 5)}`;
|
|
if (availDates.length > 5) {
|
|
msg += ` and ${availDates.length - 10} more`;
|
|
}
|
|
console.log(msg);
|
|
ctx.consulates[c].currentDate = availDates[0];
|
|
if (!ctx.consulates[c].bestDate || availDates[0] < ctx.consulates[c].bestDate) {
|
|
console.log(`New record for ${c}: ${availDates[0]}`);
|
|
ctx.consulates[c].bestDate = availDates[0];
|
|
}
|
|
|
|
// filter dates with our requests
|
|
let filteredDates = await filterDates(availDates, ctx.currentAppt.date, cfg.deltaAppt, cfg.deltaNow);
|
|
if (!filteredDates.length) {
|
|
console.log(`No better dates in ${c}, currently available ${availDates[0]}`);
|
|
await chrome.storage.local.set({ "ctx_statusMsg": `no better dates in ${c}`});
|
|
continue;
|
|
}
|
|
|
|
console.log(`Dates worth rescheduling in ${c}: ${filteredDates}`);
|
|
let chosenDate = filteredDates[0];
|
|
await chrome.storage.local.set({ "ctx_statusMsg": `Found in ${c} better date ${chosenDate}`});
|
|
|
|
// fill date in reschedule form
|
|
await delay(PAGE_WAIT_TIME);
|
|
document.getElementById("appointments_consulate_appointment_date").value = chosenDate;
|
|
document.getElementById("appointments_consulate_appointment_time").innerHTML = "<option></option>"
|
|
|
|
let availTimes = await getAvailableTimes(ctx.consulates[c].id, chosenDate);
|
|
if (!availTimes) {
|
|
msg = `Failed to fetch available timeslots in ${c} at ${chosenDate}`;
|
|
console.log(msg);
|
|
await chrome.storage.local.set({ "ctx_statusMsg": msg});
|
|
continue;
|
|
}
|
|
if (availTimes.length == 0) {
|
|
msg = `No timeslots in ${c} at ${chosenDate}`;
|
|
console.log(msg);
|
|
await chrome.storage.local.set({ "ctx_statusMsg": msg});
|
|
continue;
|
|
}
|
|
console.log(`Available timeslots in ${c} at ${chosenDate}: ${availTimes}`);
|
|
let chosenTime = availTimes[0];
|
|
|
|
// fill timeslot in reschedule form
|
|
await delay(PAGE_WAIT_TIME);
|
|
document.getElementById("appointments_consulate_appointment_time").innerHTML = `<option value='${chosenTime}'>${chosenTime}</option>`;
|
|
document.getElementById("appointments_consulate_appointment_time").value = chosenTime;
|
|
|
|
// TODO process ASC facilities here
|
|
|
|
await delay(PAGE_WAIT_TIME);
|
|
document.getElementById("appointments_submit").removeAttribute("disabled");
|
|
document.getElementById("appointments_submit").click();
|
|
|
|
msg = `Found better appointment in ${c} at ${chosenDate} ${chosenTime}`;
|
|
console.log(msg);
|
|
await sendNotification(msg);
|
|
|
|
if (!cfg.consulates[c].autoBook) {
|
|
isFoundAppointment = true;
|
|
} else {
|
|
await delay(PAGE_WAIT_TIME);
|
|
msg = `Auto booking in ${c} at ${chosenDate} ${chosenTime}`;
|
|
console.log(msg);
|
|
await sendNotification(msg);
|
|
document.querySelector(".reveal-overlay:last-child [data-reveal] .button.alert").click();
|
|
}
|
|
} // end consulates loop
|
|
|
|
for (let c in ctx.consulates) {
|
|
if (!prev_ctx?.consulates?.[c]) continue;
|
|
if (ctx.consulates[c].nextCheckAt != prev_ctx.consulates[c].nextCheckAt) {
|
|
console.log(`Next check for ${c} at ${ctx.consulates[c].nextCheckAt}`);
|
|
}
|
|
}
|
|
await chrome.storage.local.set({ "cfg_consulates": cfg.consulates });
|
|
await chrome.storage.local.set({ "ctx_consulates": ctx.consulates });
|
|
isRunning = false;
|
|
return;
|
|
}
|
|
|
|
else if (isConfirmationPage) {
|
|
// go back to dashboard after successful reschedule
|
|
await delay(PAGE_WAIT_TIME);
|
|
ctx.currentAppt = { consulate: null, date: null};
|
|
await chrome.storage.local.set({"ctx_currentAppt": ctx.currentAppt});
|
|
console.log('Rescheduled successfully');
|
|
|
|
// switch off autoBook for all consulates after successful reschedule
|
|
for (let c in cfg.consulates) {
|
|
cfg.consulates[c].autoBook = false;
|
|
}
|
|
|
|
await goToDashboardPage();
|
|
}
|
|
|
|
// console.log('runner done');
|
|
isRunning = false;
|
|
}
|
|
|
|
setInterval(runner, 500);
|