app.js

import axios from 'axios';
import dotenv from 'dotenv';
import schedule from 'node-schedule';
import FormData from 'form-data';
import { performance } from 'perf_hooks';

dotenv.config();

const zabApi = axios.create({
	baseURL: process.env.ZAB_API_URL,
	headers: {
		'Authorization': `Bearer ${process.env.ZAB_API_KEY}`
	}
});

const syncRoster = async() => {
	const start = performance.now();

	console.log(`Syncing Roster...`);
	
	const { data: vatusaData } = await axios.get(`https://api.vatusa.net/v2/facility/ZAB/roster/both?apikey=${process.env.VATUSA_API_KEY}`).catch(console.error);
	const { data: zabData } = await zabApi.get('/controller');
	const allZabControllers = [...zabData.data.home, ...zabData.data.visiting];
	const { data: zabRoles } = await zabApi.get('/controller/role');
	const availableRoles = zabRoles.data.map(role => role.code);

	const zabControllers = allZabControllers.map(c => c.cid); // everyone in db
	const zabMembers = allZabControllers.filter(c => c.member).map(c => c.cid); // only member: true
	const zabNonMembers = allZabControllers.filter(c => !c.member).map(c => c.cid); // only member: false
	const zabHomeControllers = zabData.data.home.map(c => c.cid); // only vis: false
	const zabVisitingControllers = zabData.data.visiting.map(c => c.cid); // only: vis: true

	const vatusaControllers = vatusaData.data.map(c => c.cid); // all controllers returned by VATUSA
	const vatusaHomeControllers = vatusaData.data.filter(c => c.membership === 'home').map(c => c.cid); // only membership: home
	const vatusaVisitingControllers = vatusaData.data.filter(c => c.membership !== 'home').map(c => c.cid); // only membership: !home

	const toBeAdded = vatusaControllers.filter(cid => !zabControllers.includes(cid));
	const makeNonMember = zabMembers.filter(cid => !vatusaControllers.includes(cid));
	const makeMember = zabNonMembers.filter(cid => vatusaControllers.includes(cid));
	const makeVisitor = zabHomeControllers.filter(cid => vatusaVisitingControllers.includes(cid));
	const makeHome = zabVisitingControllers.filter(cid => vatusaHomeControllers.includes(cid));

	console.log(`Members to be added: ${toBeAdded.join(', ')}`);
	console.log(`Members to be removed: ${makeNonMember.join(', ')}`);
	console.log(`Controllers to be made member: ${makeMember.join(', ')}`);
	console.log(`Controllers to be made visitor: ${makeVisitor.join(', ')}`);
	console.log(`Controllers to be made home controller: ${makeHome.join(', ')}`);
	
	const vatusaObject = {};

	for(const user of vatusaData.data) {
		vatusaObject[user.cid] = user;
	}

	for (const cid of toBeAdded) {
		const user = vatusaObject[cid];

		const assignableRoles = user.roles.filter(role => availableRoles.includes(role.role.toLowerCase())).map(role => role.role.toLowerCase());

		const userData = {
			fname: user.fname,
			lname: user.lname,
			cid: user.cid,
			rating: user.rating,
			home: user.facility,
			email: user.email,
			broadcast: user.flag_broadcastOptedIn,
			member: true,
			vis: (user.membership === 'home') ? false : true,
			roleCodes: (user.membership === 'home') ? assignableRoles : []
		}

		await zabApi.post(`/controller/${user.cid}`, userData);
	}

	for (const cid of makeMember) {
		await zabApi.put(`/controller/${cid}/member`, {member: true});
	}

	for (const cid of makeNonMember) {
		await zabApi.put(`/controller/${cid}/member`, {member: false});
	}

	for (const cid of makeVisitor) {
		await zabApi.put(`/controller/${cid}/visit`, {vis: true});
	}

	for (const cid of makeHome) {
		await zabApi.put(`/controller/${cid}/visit`, {vis: false});
	}
	
	console.log(`...Done!\nFinished in ${Math.round(performance.now() - start)/1000}s\n---`);
}

const syncTrainingNotes = async() => {
	const start = performance.now();

	console.log(`Syncing Training Notes...`);

	const { data: zabData } = await zabApi.get('/training/sessions/forsync');
	if(zabData.data.length) {
		let ids = [];

		const results = zabData.data.slice(0,10); // limit to 10 items per time for now

		for(const session of results) {
			let diff = new Date(session.startTime) - new Date(session.endTime);
			ids.push(session._id);

			const record = {
				instructor_id: session.instructorCid,
				session_date: `${session.startTime.split("T")[0]} ${session.startTime.split("T")[1].slice(0,5)}`,
				position: session.position,
				duration: session.duration || `${('00' + Math.floor(diff / 3.6e6)).slice(-2)}:${('00' + Math.floor((diff / 3.6e6) / 6e4)).slice(-2)}`,
				notes: session.studentNotes,
				location: session.location || 0
			}

			if(session.progress) record.score = session.progress;
			if(session.movements) record.movements = session.movements;
			if(session.ots) record.ots_status = session.ots;

			let formData = new FormData();
			Object.keys(record).forEach((key) => {
				formData.append(key, record[key])
			});

			const formHeaders = formData.getHeaders();

			await axios({
				url: `https://api.vatusa.net/v2/user/${session.studentCid}/training/record?apikey=${process.env.VATUSA_API_KEY}`,
				method: "POST",
				data: formData,
				headers: formHeaders,
				transformRequest: data => data
			})
			.catch(() => { return });
		}

		await zabApi.put('/training/sessions/setsynced', {
			ids
		});

		console.log(`...Done! Synced ${ids.length} training notes and finished in ${Math.round(performance.now() - start)/1000}s\n---`);
	} else {
		console.log('...No Training Notes that need to be synced')
		return;
	}
}

(() => {
	syncRoster();
	// syncTrainingNotes();
	schedule.scheduleJob('*/10 * * * *', syncRoster);
	// schedule.scheduleJob('*/10 * * * *', syncTrainingNotes);
})();