WorkInProgressService.js

(function () {
    'use strict';

    var dependencies = [
        'angular',
        'angular-local-storage',
    ];

    define(dependencies, function(angular) {

        function WipService ($rootScope, $log, LocalStorageService) {

            function broadcast(eventName, activity, wip) {
                return $rootScope.$broadcast(eventName, {
                    activity: activity,
                    wip: wip || [],
                    date: new Date(),
                });
            }

            function initStorage() {
                service.config.enabled = LocalStorageService.isSupported;
            }

            function removeFromStorage(key) {
                if (service.config.enabled) {
                    return LocalStorageService.remove(key);
                    //service.broadcast(service.events.storageChanged, 'cleared storage');
                    //service.broadcast(service.events.wipChanged, 'cleared wip');
                }
                return false;
            }

            function loadFromStorage(key) {
                if (service.config.enabled) {
                    var importedData = LocalStorageService.get(key);
                    if (importedData) {
                        if (!importedData.hasOwnProperty('version') ||
                            importedData.version !== service.config.version) {
                            broadcast(service.events.storageError, 'Did not load ' + key +' from storage because of version mismatch'); // possible schema diff
                            $log.warn('Did not load ' + key +' from storage because of version mismatch');
                            return null;
                        }

                        if (!importedData.hasOwnProperty('data')) {
                            broadcast(service.events.storageError, 'Did not load ' + key +' from storage because data field is missing'); // possible schema diff
                            $log.warn('Did not load ' + key +' from storage because data field is missing');
                            return null;
                        }

                        return importedData.data;
                    }
                }
                return null;
            }

            function saveToStorage(key, data) {
                if (service.config.enabled) {
                    var exportedData = {
                        version: service.config.version,
                        data: data,
                    };
                    LocalStorageService.set(key, exportedData);
                }
            }

            function clearWips() {
                getWipSummary()
                    .forEach(function(wip) {
                        removeFromStorage(wip.key);
                    });
                removeFromStorage(service.config.storageKey);

                saveToStorage(service.config.storageKey, []);
                broadcast(service.events.wipChanged, 'cleared all wips');
            }

            function findWipByModelNameAndId(modelName, id) {
                return getWipSummary()
                    .filter(function(item) {
                        return item.modelName === modelName && item.id == id;
                    })
                    .shift();
            }

            function findWipByModelName(modelName) {
                return getWipSummary()
                    .filter(function(item) {
                        return item.modelName === modelName;
                    });
            }

            function getWipSummary() {
                return loadFromStorage(service.config.storageKey) || [];
            }

            function removeWip(key) {
                if (!key) {
                    return;
                }

                removeFromStorage(key);

                var updatedWipSummary = getWipSummary()
                    .filter(function(item) {
                        return item.key !== key;
                    });
                saveToStorage(service.config.storageKey, updatedWipSummary);
                broadcast(service.events.wipChanged, 'removed 1 wip model', updatedWipSummary);
            }

            function getWip(key) {
                return loadFromStorage(key);
            }

            function getWipByModelNameAndId(modelName, id) {
                var wip = findWipByModelNameAndId(modelName, id);
                if (!wip) {
                    return null;
                }

                return getWip(wip.key);

            }

            function newGuid() {
                return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
                    var r = Math.random()*16|0, v = c == 'x' ? r : (r&0x3|0x8);
                    return v.toString(16);
                });
            }

            function saveWip(modelName, key, model, description) {
                var _key = key;
                var new_key = false;
                if (!_key) {

                    // first.. try to find this guy

                    var existing_wip = model &&
                        model[modelName] &&
                        model[modelName].id &&
                        findWipByModelNameAndId(modelName, model[modelName].id);
                    if (!!existing_wip) {
                        _key = existing_wip.key;
                    } else {
                        _key = newGuid();
                        new_key = true;
                    }
                }
                var id = null;
                if (model.id) {
                    id = model.id;
                } else if (model[modelName] && model[modelName].id) {
                    id = model[modelName].id;
                }
                var exportData = {
                    modelName: modelName,
                    key: _key, // just in case..
                    model: model,
                    description: description,
                    modified: new Date(),
                };
                if (id) {
                    exportData.id = id;
                }
                saveToStorage(_key, exportData);
                var wips = getWipSummary();
                var exists = wips
                    .some(function(item) {
                        return item.key === _key;
                    });
                if (new_key || !exists) {
                    var summary = {
                        modelName: modelName,
                        id: id,
                        key: _key, // just in case..
                        description: description,
                        modified: new Date(),
                    };

                    wips.unshift(summary);

                }
                saveToStorage(service.config.storageKey, wips);

                broadcast(service.events.wipChanged, 'saved', wips);

                return _key;
            }

            function saveWipSummary() {

            }

            var service = {
                events: {
                    storageError: 'WipServoce.storage.error',
                    wipError: 'WipService.wip.error',
                    storageChanged: 'WipService.storage.changed',
                    wipChanged: 'WipService.wip.changed',
                },
                config: {
                    version: 2,
                    storageKey: 'wip',
                    enabled: false,
                },
                data: [],
                getSummary: getWipSummary,
                get: getWip,
                remove: removeWip,
                save: saveWip,
                getByModelNameAndId: getWipByModelNameAndId,
                getByModelName: findWipByModelName,
            };


            // init
            initStorage();


            return service;
        }

        angular
            .module('app')
            .lazy
            .factory('WipService', [
                '$rootScope',
                '$log',
                'localStorageService',
                WipService
            ]);
    });

}());