Calendar.service.js

/* -*- Mode: javascript; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

(function() {
  'use strict';

  /**
   * @name Calendar
   * @constructor
   * @param {object} futureCalendarData - either an object literal or a promise
   */
  function Calendar(futureCalendarData) {
    // Data is immediately available
    this.init(futureCalendarData);
    if (this.name && !this.id) {
      // Create a new calendar on the server
      var newCalendarData = Calendar.$$resource.create('createFolder', this.name);
      this.$unwrap(newCalendarData);
    }
  }

  /**
   * @memberof Calendar
   * @desc The factory we'll use to register with Angular
   * @returns the Calendar constructor
   */
  Calendar.$factory = ['$q', '$timeout', '$log', 'sgSettings', 'Resource', 'Preferences', 'Component', 'Acl', function($q, $timeout, $log, Settings, Resource, Preferences, Component, Acl) {
    angular.extend(Calendar, {
      $q: $q,
      $timeout: $timeout,
      $log: $log,
      $$resource: new Resource(Settings.activeUser('folderURL') + 'Calendar', Settings.activeUser()),
      $Preferences: Preferences,
      $Component: Component,
      $$Acl: Acl,
      activeUser: Settings.activeUser(),
      $view: null
    });

    return Calendar; // return constructor
  }];

  /**
   * @module SOGo.SchedulerUI
   * @desc Factory registration of Calendar in Angular module.
   */
  try {
    angular.module('SOGo.SchedulerUI');
  }
  catch(e) {
    angular.module('SOGo.SchedulerUI', ['SOGo.Common']);
  }
  angular.module('SOGo.SchedulerUI')
    .value('CalendarSettings', {
      EventDragDayLength:          24 * 4,   // hour quarters
      EventDragHorizontalOffset:   3,        // pixels
      ConflictHTTPErrorCode:       409
    })
    .factory('Calendar', Calendar.$factory);

  /**
   * @memberof Calendar
   * @desc Return the default calendar id according to the user's defaults.
   * @returns a calendar id
   */
  Calendar.$defaultCalendar = function() {
    var defaultCalendar = Calendar.$Preferences.defaults.SOGoDefaultCalendar,
        calendar;

    if (defaultCalendar == 'first') {
      calendar = _.find(Calendar.$findAll(null, true), function(calendar) {
        return calendar.active;
      });
      if (calendar)
        return calendar.id;
    }

    return 'personal';
  };

  /**
   * @memberof Calendar
   * @desc Add a new calendar to the static list of calendars
   * @param {Calendar} calendar - an Calendar object instance
   */
  Calendar.$add = function(calendar) {
    // Insert new calendar at proper index
    var list, sibling;

    if (calendar.isWebCalendar)
      list = this.$webcalendars;
    else if (calendar.isSubscription)
      list = this.$subscriptions;
    else
      list = this.$calendars;

    sibling = _.findIndex(list, function(o, i) {
      return (calendar.id == 'personal' ||
              (o.id != 'personal' && o.name.localeCompare(calendar.name) > 0));
    });
    if (sibling < 0)
      list.push(calendar);
    else
      list.splice(sibling, 0, calendar);

    if (Calendar.$Preferences.settings.Calendar.FoldersOrder)
      // Save list order
      Calendar.saveFoldersOrder(_.flatMap(Calendar.$findAll(), 'id'));
    // Refresh list of calendars to fetch links associated to new calendar
    Calendar.$reloadAll();
  };

  /**
   * @memberof Calendar
   * @desc Set or get the list of calendars. Will instanciate a new Calendar object for each item.
   * @param {object[]} [data] - the metadata of the calendars
   * @param {bool} [writable] - if true, returns only the list of writable calendars
   * @returns the list of calendars
   */
  Calendar.$findAll = function(data, writable) {
    var _this = this;
    if (data) {
      this.$calendars = [];
      this.$subscriptions = [];
      this.$webcalendars = [];
      // Instanciate Calendar objects
      angular.forEach(data, function(o, i) {
        var calendar = new Calendar(o);
        if (calendar.isWebCalendar)
          _this.$webcalendars.push(calendar);
        else if (calendar.isSubscription)
          _this.$subscriptions.push(calendar);
        else
          _this.$calendars.push(calendar);
      });
    }
    else if (angular.isUndefined(this.$calendars)) {
      this.$calendars = [];
      this.$subscriptions = [];
      this.$webcalendars = [];
      return Calendar.$$resource.fetch('calendarslist').then(function(data) {
        return Calendar.$findAll(data.calendars, writable);
      });
    }

    if (writable) {
      return _.union(this.$calendars, _.filter(this.$subscriptions, function(calendar) {
        return calendar.isOwned || calendar.acls.objectCreator;
      }));
    }

    return _.union(this.$calendars, this.$subscriptions, this.$webcalendars);
  };

  /**
   * @memberof Calendar
   * @desc Reload the list of known calendars.
   */
  Calendar.$reloadAll = function() {
    var _this = this;

    Calendar.$$resource.fetch('calendarslist').then(function(data) {
      _.forEach(data.calendars, function(calendarData) {
        var group, calendar;

        if (calendarData.isWebCalendar)
          group = _this.$webcalendars;
        else if (calendarData.owner != Calendar.activeUser.login)
          group = _this.$subscriptions;
        else
          group = _this.$calendars;

        calendar = _.find(group, function(o) { return o.id == calendarData.id; });
        if (calendar)
          calendar.init(calendarData);
      });
    });
  };

  /**
   * @memberof Calendar
   * @desc Find a calendar among local instances (personal calendars, subscriptions and Web calendars).
   * @param {string} id - the calendar ID
   * @returns an object literal of the matching Calendar instance
   */
  Calendar.$get = function(id) {
    var calendar;

    calendar = _.find(Calendar.$calendars, function(o) { return o.id == id; });
    if (!calendar)
      calendar = _.find(Calendar.$subscriptions, function(o) { return o.id == id; });
    if (!calendar)
      calendar = _.find(Calendar.$webcalendars, function(o) { return o.id == id; });

    return calendar;
  };

  /**
   * @memberof Calendar
   * @desc Find a calendar among local instances (personal calendars, subscriptions and Web calendars).
   * @param {string} id - the calendar ID
   * @returns an object literal of the matching Calendar instance
   */
  Calendar.$getIndex = function(id) {
    var i;

    i = _.indexOf(_.map(Calendar.$calendars, 'id'), id);
    if (i < 0)
      i = _.indexOf(_.map(Calendar.$subscriptions, 'id'), id);
    if (i < 0)
      i = _.indexOf(_.map(Calendar.$webcalendars, 'id'), id);

    return i;
  };

  /**
   * @memberOf Calendar
   * @desc Subscribe to another user's calendar and add it to the list of calendars.
   * @param {string} uid - user id
   * @param {string} path - path of folder for specified user
   * @returns a promise of the HTTP query result
   */
  Calendar.$subscribe = function(uid, path) {
    var _this = this;
    return Calendar.$$resource.userResource(uid).fetch(path, 'subscribe').then(function(calendarData) {
      var calendar = new Calendar(angular.extend({ active: 1 }, calendarData));
      if (!_.find(_this.$subscriptions, function(o) {
        return o.id == calendarData.id;
      })) {
        Calendar.$add(calendar);
      }
      return calendar;
    });
  };

  /**
   * @memberOf Calendar
   * @desc Subscribe to a remote Web calendar
   * @param {string} url - URL of .ics file
   * @returns a promise of the HTTP query result
   */
  Calendar.$addWebCalendar = function(url) {
    var _this = this,
        d = Calendar.$q.defer();

    if (_.find(_this.$webcalendars, function(o) {
        return o.urls.webCalendarURL == url;
    })) {
      // Already subscribed
      d.reject();
    }
    else {
      Calendar.$$resource.post(null, 'addWebCalendar', { url: url }).then(function(calendarData) {
        angular.extend(calendarData, {
          isWebCalendar: true,
          isEditable: true,
          isRemote: false,
          owner: Calendar.activeUser.login,
          urls: { webCalendarURL: url }
        });
        var calendar = new Calendar(calendarData);
        Calendar.$$resource.fetch(calendar.id, 'reload').then(function(data) {
          // TODO: show a toast of the reload status
          Calendar.$log.debug(JSON.stringify(data, undefined, 2));
          Calendar.$add(calendar);
          d.resolve();
        }, function(response) {
          if (response.status == 401) {
            // Web calendar requires authentication
            d.resolve(calendar);
          }
          else {
            d.reject();
          }
        });
      }, d.reject);
    }

    return d.promise;
  };

  /**
   * @function reloadWebCalendars
   * @memberof Calendar
   * @desc Reload all Web calendars
   * @return a promise combining the results of all HTTP operations
   */
  Calendar.reloadWebCalendars = function() {
    var promises = [];

    _.forEach(this.$webcalendars, function(calendar) {
      var promise = Calendar.$$resource.fetch(calendar.id, 'reload');
      promise.then(function(data) {
        calendar.$error = false;
      }, function(response) {
        calendar.$error = l(response.statusText);
      });
      promises.push(promise);
    });

    return Calendar.$q.all(promises);
  };

  /**
   * @function $deleteComponents
   * @memberof Calendar
   * @desc Delete multiple components from calendar.
   * @return a promise of the HTTP operation
   */
  Calendar.$deleteComponents = function(components) {
    var _this = this, calendars = {}, promises = [];

    _.forEach(components, function(component) {
      if (!angular.isDefined(calendars[component.pid]))
        calendars[component.pid] = [];
      calendars[component.pid].push(component.id);
    });

    _.forEach(calendars, function(uids, pid) {
      promises.push(Calendar.$$resource.post(pid, 'batchDelete', {uids: uids}));
    });

    return Calendar.$q.all(promises);
  };

  /**
   * @function saveFoldersActivation
   * @memberof Calendar
   * @desc Save to the user's settings the activation state of the calendars
   * @param {string[]} folders - the folders IDs
   * @returns a promise of the HTTP operation
   */
  Calendar.saveFoldersActivation = function(ids) {
    var request = {};

    _.forEach(ids, function(id) {
      var calendar = Calendar.$get(id);
      request[calendar.id] = calendar.active;
    });

    return Calendar.$$resource.post(null, 'saveFoldersActivation', request);
  };

  /**
   * @function saveFoldersOrder
   * @desc Save to the user's settings the current calendars order.
   * @param {string[]} folders - the folders IDs
   * @returns a promise of the HTTP operation
   */
  Calendar.saveFoldersOrder = function(folders) {
    return this.$$resource.post(null, 'saveFoldersOrder', { folders: folders }).then(function() {
      Calendar.$Preferences.settings.Calendar.FoldersOrder = folders;
      if (!folders)
        // Calendars order was reset; reload list
        return Calendar.$$resource.fetch('calendarslist').then(function(data) {
          return Calendar.$findAll(data.calendars);
        });
    });
  };

  /**
   * @function init
   * @memberof Calendar.prototype
   * @desc Extend instance with new data and compute additional attributes.
   * @param {object} data - attributes of calendar
   */
  Calendar.prototype.init = function(data) {
    this.color = this.color || '#AAAAAA';
    this.active = 1;
    angular.extend(this, data);
    if (this.id) {
      this.$acl = new Calendar.$$Acl('Calendar/' + this.id);
    }
    // Add 'isOwned' and 'isSubscription' attributes based on active user (TODO: add it server-side?)
    this.isOwned = Calendar.activeUser.isSuperUser || this.owner == Calendar.activeUser.login;
    this.isSubscription = !this.isRemote && this.owner != Calendar.activeUser.login;
    if (angular.isUndefined(this.$shadowData) || !this.$shadowData.id) {
      // Make a copy of the data for an eventual reset
      this.$shadowData = this.$omit();
    }
  };

  /**
   * @function $id
   * @memberof Calendar.prototype
   * @desc Resolve the calendar id.
   * @returns a promise of the calendar id
   */
  Calendar.prototype.$id = function() {
    var _this = this;

    if (this.id) {
      // Object already unwrapped
      return Calendar.$q.when(this.id);
    }
    else {
      // Wait until object is unwrapped
      return this.$futureCalendarData.then(function(calendar) {
        if (calendar.id)
          return calendar.id;
        else
          return Calendar.$q.reject();
      });
    }
  };

  /**
   * @function getClassName
   * @memberof Calendar.prototype
   * @desc Return the calendar CSS class name based on its ID.
   * @returns a string representing the foreground CSS class name
   */
  Calendar.prototype.getClassName = function(base) {
    if (angular.isUndefined(base))
      base = 'fg';
    return base + '-folder' + this.id;
  };

  /**
   * @function $rename
   * @memberof Calendar.prototype
   * @desc Rename the calendar and keep the list sorted
   * @param {string} name - the new name
   * @returns a promise of the HTTP operation
   */
  Calendar.prototype.$rename = function() {
    var _this = this,
        i,
        calendars;

    if (this.name == this.$shadowData.name) {
      // Name hasn't changed
      return Calendar.$q.when();
    }

    if (this.isWebCalendar)
      calendars = Calendar.$webcalendars;
    else if (this.isSubscription)
      calendars = Calendar.$subscriptions;
    else
      calendars = Calendar.$calendars;

    i = _.indexOf(_.map(calendars, 'id'), this.id);
    if (i > -1) {
      return this.$save().then(function() {
        calendars.splice(i, 1);
        Calendar.$add(_this);
      });
    }
    else {
      return Calendar.$q.reject();
    }
  };

  /**
   * @function $delete
   * @memberof Calendar.prototype
   * @desc Delete the calendar from the server and the static list of calendars.
   * @returns a promise of the HTTP operation
   */
  Calendar.prototype.$delete = function() {
    var _this = this,
        list,
        promise;

    if (this.isSubscription) {
      promise = Calendar.$$resource.fetch(this.id, 'unsubscribe');
      list = Calendar.$subscriptions;
    }
    else {
      promise = Calendar.$$resource.remove(this.id);
      if (this.isWebCalendar)
        list = Calendar.$webcalendars;
      else
        list = Calendar.$calendars;
    }

    return promise.then(function() {
      var i = _.indexOf(_.map(list, 'id'), _this.id);
      list.splice(i, 1);
    });
  };

  /**
   * @function $reset
   * @memberof Calendar.prototype
   * @desc Reset the original state the calendar's data.
   */
  Calendar.prototype.$reset = function() {
    var _this = this;
    angular.forEach(this, function(value, key) {
      if (key != 'constructor' && key[0] != '$') {
        delete _this[key];
      }
    });
    angular.extend(this, this.$shadowData);
    this.$shadowData = this.$omit();
  };

  /**
   * @function $save
   * @memberof Calendar.prototype
   * @desc Save the calendar properties to the server.
   * @returns a promise of the HTTP operation
   */
  Calendar.prototype.$save = function() {
    var _this = this,
        d = Calendar.$q.defer();

    Calendar.$$resource.save(this.id, this.$omit()).then(function(data) {
      // Make a copy of the data for an eventual reset
      _this.$shadowData = _this.$omit();
      return d.resolve(data);
    }, function(data) {
      // Restore previous version
      _this.$reset();
      return d.reject(data);
    });

    return d.promise;
  };

  /**
   * @function setCredentials
   * @memberof Calendar.prototype
   * @desc Set the credentials for a Web calendar that requires authentication
   * @returns a promise of the HTTP operation
   */
  Calendar.prototype.setCredentials = function(username, password) {
    var _this = this,
        d = Calendar.$q.defer();

    Calendar.$$resource.post(this.id, 'set-credentials', { username: username, password: password }).then(function() {
      Calendar.$$resource.fetch(_this.id, 'reload').then(function(data) {
        Calendar.$add(_this);
        d.resolve();
      }, function(response) {
        if (response.status == 401) {
          // Authentication failed
          d.reject(l('Wrong username or password.'));
        }
        else {
          d.reject(response.statusText);
        }
      });
    }, d.reject);

    return d.promise;
  };

  /**
   * @function export
   * @memberof Calendar.prototype
   * @desc Export the calendar
   * @returns a promise of the HTTP operation
   */
  Calendar.prototype.export = function() {
    var options, resource, ownerPaths, realOwnerId, path, index;

    options = {
      type: 'application/octet-stream',
      filename: this.name + '.ics'
    };

    if (this.isSubscription) {
      index = this.urls.webDavICSURL.indexOf('/dav/');
      ownerPaths = this.urls.webDavICSURL.substring(index + 5).split(/\//);
      realOwnerId = ownerPaths[0];
      resource = Calendar.$$resource.userResource(realOwnerId);
      path = ownerPaths.splice(ownerPaths.length - 2).join('/');
    }
    else {
      resource = Calendar.$$resource;
      path = this.id + '.ics';
    }

    return resource.open(path, 'export', null, options);
  };

  /**
   * @function $setActivation
   * @memberof Calendar.prototype
   * @desc Either activate or deactivate the calendar.
   * @returns a promise of the HTTP operation
   */
  Calendar.prototype.$setActivation = function() {
    return Calendar.$$resource.fetch(this.id, (this.active?'':'de') + 'activateFolder');
  };

  /**
   * @function $getComponent
   * @memberof Calendar.prototype
   * @desc Fetch a component attributes from the server.
   * @returns a promise of the HTTP operation
   */
  Calendar.prototype.$getComponent = function(componentId, recurrenceId) {
    return Calendar.$Component.$find(this.id, componentId, recurrenceId);
  };

  /**
   * @function $unwrap
   * @memberof Calendar.prototype
   * @desc Unwrap a promise
   * @param {promise} futureCalendarData - a promise of the Calendar's data
   */
  Calendar.prototype.$unwrap = function(futureCalendarData) {
    var _this = this;

    // Expose and resolve the promise
    this.$futureCalendarData = futureCalendarData.then(function(data) {
      return Calendar.$timeout(function() {
        // Extend Calendar instance with received data
        _this.init(data);
        return _this;
      });
    }, function(data) {
      _this.isError = true;
      if (angular.isObject(data)) {
        Calendar.$timeout(function() {
          angular.extend(_this, data);
        });
      }
    });
  };

  /**
   * @function $omit
   * @memberof Calendar.prototype
   * @desc Return a sanitized object used to send to the server.
   * @return an object literal copy of the Calendar instance
   */
  Calendar.prototype.$omit = function() {
    var calendar = {};
    angular.forEach(this, function(value, key) {
      if (key != 'constructor' &&
          key[0] != '$') {
        calendar[key] = angular.copy(value);
      }
    });
    return calendar;
  };
})();