KilometerTracker

#!/usr/bin/env node

const db = require('../db')();

const googleMapsClient = require('@google/maps').createClient({
    key: 'YOUR API KEY HERE',
    Promise: Promise
});

function sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
}

function CalculateDistanceInKM(origin, destinations) {
    return new Promise((resolve, reject) => {
        var result = {
            routes: [], //origin, destination, kms
            totalKms: 0
        };

        var query = {
            mode: 'bicycling',
            origin: origin,
            destination: origin,
            waypoints: destinations
        };

        return googleMapsClient.directions(query, function(err, res) {
            if(err)
                reject(err);

            var result = {
                routes: [], //origin, destination, kms
                totalKms: 0
            };

            for(var i = 0; i < res.json.routes[0].legs.length; i++) {
                var origin = res.json.routes[0].legs[i].start_address;
                var destination = res.json.routes[0].legs[i].end_address;
                var distance = res.json.routes[0].legs[i].distance.value;

                result.routes.push({
                    origin: origin,
                    destination: destination,
                    meters: distance
                });
                result.totalKms += distance;
            }

            result.totalKms = Math.round(result.totalKms / 1000);
            console.log("\nresult:");
            console.log(result);
            resolve(result);
        });
    });
}

/*function GetEmployeeDistanceInKM(employeeId, date)
{
    return new Promise((resolve, reject) =>{

        db.models.Appointments.findAll({
            order: [
                ['appointmentDate','ASC'],
                ['appointmentTime','ASC']
            ],
            include: [
                {model: db.models.Workorders},
                {model: db.models.Clients, include: [{model: db.models.ClientAddresses}]},
                {model: db.models.Employees, include: [{model: db.models.EmployeeAddresses}]}
            ],
            where: {  EmployeeId: employeeId, appointmentDate: date }
        }).then(appointments => {

            if(appointments.length == 0)
                return;

            var employeeAddress = appointments.map(a => a.Employee.EmployeeAddress.street + ' '
                                                + a.Employee.EmployeeAddress.housenumber + ', '
                                                + a.Employee.EmployeeAddress.zipcode + ' '
                                                + a.Employee.EmployeeAddress.city + ', België')[0];

            var clientAddresses = appointments.map(a => a.Client.ClientAddress.street + ' '
                                                + a.Client.ClientAddress.housenumber + ', '
                                                + a.Client.ClientAddress.zipcode + ' '
                                                + a.Client.ClientAddress.city + ', België');


            return CalculateDistanceInKM(employeeAddress, clientAddresses)
            .then(result => {
                resolve(result);
            })
            .catch(error => {
                reject(error);
            });

        });
    });
}*/

function AddressToAddressTring(address) {
    return address.street + ' '
        + address.housenumber + ', '
        + address.zipcode + ' '
        + address.city + ', België';
}

function EmployeeTravelDataFor(beginDate, endDate) {

    return new Promise((resolve, reject) => {

        db.models.Appointments.findAll({
            order: [
                ['EmployeeId', 'ASC'],
                ['appointmentDate','ASC'],
                ['appointmentTime','ASC']
            ],
            include: [
                {model: db.models.Workorders},
                {model: db.models.Clients, include: [{model: db.models.ClientAddresses}]},
                {model: db.models.Employees, include: [{model: db.models.EmployeeAddresses}]}
            ],
            where: {
                appointmentDate: {
                    $gte: beginDate,
                    $lte: endDate
                }
            }
        }).then(appointments => {

            if(appointments.length == 0)
                reject('No appointments found between this range');

            var result = {
                beginDate: beginDate,
                endDate: endDate,
                employees: [],
                totalKms: 0
            }


            var currentDate = appointments[0].appointmentDate;
            var currentEmployee = appointments[0].Employee.id;

            var origin;
            var destinations = [];

            var employeeData = {
                id: currentEmployee,
                travelData: [],
                totalKms: 0
            }

            for(var i = 0; i < appointments.length; i++)
            {
                if(currentEmployee != appointments[i].Employee.id)
                {
                    currentEmployee = appointments[i].Employee.id;

                    result.employees.push(employeeData);
                    result.totalKms += employeeData.totalKms;

                    employeeData = {
                        id: currentEmployee,
                        travelData: [],
                        totalKms: 0
                    }
                }

                if(currentDate != appointments[i].appointmentDate)
                {
                    currentDate = appointments[i].appointmentDate;
                    CalculateDistanceInKM(origin, destinations)
                    .then(result => {
                        employeeData.travelData.push({
                            day: currentDate,
                            routes: result.routes,
                            kms: result.totalKms
                        });
                        employeeData.totalKms++;
                    }).catch(error => {
                        reject(error);
                    });
                    origin = AddressToAddressTring(appointments[i].Employee.EmployeeAddress);
                    destinations = [];
                }
                destinations.push([AddressToAddressTring(appointments[i].Client.ClientAddress)]);
            }
            resolve(result);
        });
    });
}

EmployeeTravelDataFor('2018-09-15', '2018-09-20')
.then(result => {
    console.log('\n\n end result:')
    console.log(result);
})
.catch(error =>
{
    console.log('Error:' + error)
})


/*GetEmployeeDistanceInKM(10, '2018-09-03')
    .then(result => {
        console.log(result);
        console.log('\n\n');
        for(var i = 0; i < result.routes.length; i++)
            console.log(result.routes[i].origin + ' -> ' + result.routes[i].destination + ' = ' + result.routes[i].meters + ' meters')
        console.log('\n\nHet afgelegde fietstraject is: ' + result.totalKms + ' KM');
    })
    .catch(error => {
        console.log('Error: ' + error);
    });*/