source: main/trunk/greenstone3/web/interfaces/oran/js/annotator/pkg/annotator.permissions.min.js@ 24771

(function() {
  var __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; }, __hasProp = Object.prototype.hasOwnProperty, __extends = function(child, parent) {
    for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; }
    function ctor() { this.constructor = child; }
    ctor.prototype = parent.prototype;
    child.prototype = new ctor;
    child.__super__ = parent.prototype;
    return child;
  };
  Annotator.Plugin.Permissions = (function() {
    __extends(Permissions, Annotator.Plugin);
    Permissions.prototype.events = {
      'beforeAnnotationCreated': 'addFieldsToAnnotation'
    };
    Permissions.prototype.options = {
      showViewPermissionsCheckbox: true,
      showEditPermissionsCheckbox: true,
      userId: function(user) {
        return user;
      },
      userString: function(user) {
        return user;
      },
      userAuthorize: function(user, token) {
        return this.userId(user) === token;
      },
      user: '',
      permissions: {
        'read': [],
        'update': [],
        'delete': [],
        'admin': []
      }
    };
    function Permissions(element, options) {
      this.updateViewer = __bind(this.updateViewer, this);
      this.updateAnnotationPermissions = __bind(this.updateAnnotationPermissions, this);
      this.updatePermissionsField = __bind(this.updatePermissionsField, this);
      this.addFieldsToAnnotation = __bind(this.addFieldsToAnnotation, this);      Permissions.__super__.constructor.apply(this, arguments);
      if (this.options.user) {
        this.setUser(this.options.user);
        delete this.options.user;
      }
    }
    Permissions.prototype.pluginInit = function() {
      var createCallback, self;
      if (!Annotator.supported()) {
        return;
      }
      self = this;
      createCallback = function(method, type) {
        return function(field, annotation) {
          return self[method].call(self, type, field, annotation);
        };
      };
      if (this.options.showViewPermissionsCheckbox === true) {
        this.annotator.editor.addField({
          type: 'checkbox',
          label: 'Allow anyone to <strong>view</strong> this annotation',
          load: createCallback('updatePermissionsField', 'read'),
          submit: createCallback('updateAnnotationPermissions', 'read')
        });
      }
      if (this.options.showEditPermissionsCheckbox === true) {
        this.annotator.editor.addField({
          type: 'checkbox',
          label: 'Allow anyone to <strong>edit</strong> this annotation',
          load: createCallback('updatePermissionsField', 'update'),
          submit: createCallback('updateAnnotationPermissions', 'update')
        });
      }
      this.annotator.viewer.addField({
        load: this.updateViewer
      });
      if (this.annotator.plugins.Filter) {
        return this.annotator.plugins.Filter.addFilter({
          label: 'User',
          property: 'user',
          isFiltered: __bind(function(input, user) {
            var keyword, _i, _len, _ref;
            user = this.options.userString(user);
            if (!(input && user)) {
              return false;
            }
            _ref = input.split(/\s*/);
            for (_i = 0, _len = _ref.length; _i < _len; _i++) {
              keyword = _ref[_i];
              if (user.indexOf(keyword) === -1) {
                return false;
              }
            }
            return true;
          }, this)
        });
      }
    };
    Permissions.prototype.setUser = function(user) {
      return this.user = user;
    };
    Permissions.prototype.addFieldsToAnnotation = function(annotation) {
      if (annotation) {
        annotation.permissions = this.options.permissions;
        if (this.user) {
          return annotation.user = this.user;
        }
      }
    };
    Permissions.prototype.authorize = function(action, annotation, user) {
      var token, tokens, _i, _len;
      if (user === void 0) {
        user = this.user;
      }
      if (annotation.permissions) {
        tokens = annotation.permissions[action] || [];
        if (tokens.length === 0) {
          return true;
        }
        for (_i = 0, _len = tokens.length; _i < _len; _i++) {
          token = tokens[_i];
          if (this.options.userAuthorize.call(this.options, user, token)) {
            return true;
          }
        }
        return false;
      } else if (annotation.user) {
        return user && this.options.userId(user) === annotation.user;
      }
      return true;
    };
    Permissions.prototype.updatePermissionsField = function(action, field, annotation) {
      var dummy, input;
      field = $(field).show();
      input = field.find('input').removeAttr('disabled');
      if (!this.authorize('admin', annotation)) {
        field.hide();
      }
      if (this.authorize(action, annotation || {}, null)) {
        input.attr('checked', 'checked');
        dummy = {
          permissions: this.options.permissions
        };
        if (this.authorize(action, dummy, null)) {
          return input.attr('enabled', 'enabled');
        }
      } else {
        return input.removeAttr('checked');
      }
    };
    Permissions.prototype.updateAnnotationPermissions = function(type, field, annotation) {
      var dataKey, permissions;
      if (!annotation.permissions) {
        annotation.permissions = this.options.permissions;
      }
      dataKey = type + '-permissions';
      if ($(field).find('input').is(':checked')) {
        $.data(annotation, dataKey, annotation.permissions[type]);
        return annotation.permissions[type] = [];
      } else {
        permissions = $.data(annotation, dataKey);
        if (permissions) {
          return annotation.permissions[type] = permissions;
        }
      }
    };
    Permissions.prototype.updateViewer = function(field, annotation, controls) {
      var user, username;
      field = $(field);
      username = this.options.userString(annotation.user);
      if (annotation.user && username && typeof username === 'string') {
        user = Annotator.$.escape(this.options.userString(annotation.user));
        field.html(user).addClass('annotator-user');
      } else {
        field.remove();
      }
      if (annotation.permissions) {
        if (!this.authorize('update', annotation)) {
          controls.hideEdit();
        }
        if (!this.authorize('delete', annotation)) {
          return controls.hideDelete();
        }
      } else if (annotation.user && !this.authorize(null, annotation)) {
        controls.hideEdit();
        return controls.hideDelete();
      }
    };
    return Permissions;
  })();
}).call(this);