path: root/src/background.js

import * as gapi from './gapi';
import { msgType, Msg } from './msg';
import { Duration } from './duration';
import moment from 'moment';
import { getChartData } from './Chart';
import { PatternEntry } from './pattern';

let mainPatterns = [];
let analyzePatterns = [];
let calendars = {};
let calData = {};
let config = {
    trackedPeriods: [
        {name: 'Today', start: Duration.days(1), end: Duration.days(0)},
        {name: 'Yesterday', start: Duration.days(2), end: Duration.days(1)},
        {name: 'This Week', start: Duration.weeks(1), end: Duration.weeks(0)},
        {name: 'This Month', start: Duration.months(1), end: Duration.months(0)}]
};
let mainGraphData = [{}, {}, {}, {}];
let dirtyMetadata = false;

function loadMetadata() {
    return new Promise(resolver => chrome.storage.local.get([
        'calendars', 'config', 'mainPatterns', 'analyzePatterns',
    ], function(items) {
        if (chrome.runtime.lastError)
        {
            console.error("error while loading saved metadata");
            return;
        }
        if (!items.hasOwnProperty('config'))
        {
            console.log("no saved metadata");
            return;
        }
        console.log('metadata loaded');
        config = {
            trackedPeriods: items.config.trackedPeriods.map(p => ({
                name: p.name,
                start: Duration.inflate(p.start),
                end: Duration.inflate(p.end),
            }))
        };
        calendars = items.calendars;
        mainPatterns = items.mainPatterns.map(p => PatternEntry.inflate(p));
        analyzePatterns = items.analyzePatterns.map(p => PatternEntry.inflate(p));
        resolver();
    }));
}

function saveMetadata() {
    return new Promise(resolver => chrome.storage.local.set({
        calendars,
        config: {
            trackedPeriods: config.trackedPeriods.map(p => ({
                name: p.name,
                start: p.start.deflate(),
                end: p.end.deflate()
            }))
        },
        mainPatterns: mainPatterns.map(p => p.deflate()),
        analyzePatterns: analyzePatterns.map(p => p.deflate())
    }, function() {
        console.log('metadata saved');
        resolver();
    }));
}

function getCalEvents(id, start, end) {
    if (!calData.hasOwnProperty(id))
        calData[id] = new gapi.GCalendar(id, calendars[id].summary);
    return calData[id].getEvents(new Date(start), new Date(end))
        .catch(e => {
            console.log(`cannot load calendar ${id}`, e);
            calendars[id].enabled = false;
            return [];
        });
}

function updateMainGraphData() {
    console.log('refreshing graph data');
    console.log(mainGraphData);
    let pms = [];
    for (let i = 0; i < config.trackedPeriods.length; i++)
    {
        let p = config.trackedPeriods[i];
        let startD = p.start.toMoment();
        let endD = p.end.toMoment();
        if (!(startD && endD)) return;
        let start = moment().endOf('day');
        if (endD.valueOf() == 0) {
            switch (p.start.unit) {
                case 'days': start = moment().endOf('day'); break;
                case 'weeks': start = moment().endOf('week'); break;
                case 'months': start = moment().endOf('month'); break;
                default:
            }
        }
        let end = start.clone();
        start.subtract(startD);
        end.subtract(endD);
        pms.push(getChartData(
            start.toDate(),
            end.toDate(),
            mainPatterns,
            calendars,
            (id, start,end) => getCalEvents(id, start, end).then(d => d.map(e => ({
                id: e.id,
                start: e.start.getTime(),
                end: e.end.getTime()
            })))).then(results => {
            mainGraphData[i] = {
                name: p.name, start, end,
                data: results.patternGraphData
            };
        }));
    }
    return Promise.all