test_hyrax 0.0.1.alpha

data/app/assets/javascripts/hyrax/permissions/grant.es6

@@ -0,0 +1,24 @@
+export class Grant {
+  /**
+   * Initialize the Grant 
+   * @param {Agent} agent the agent the grant applies to
+   * @param {String} access the access level to grant
+   * @param {String} accessLabel the access level to display 
+   */
+  constructor(agent, access, accessLabel) {
+    this.agent = agent
+    this.access = access
+    this.accessLabel = accessLabel
+    this.index = 0
+  }
+
+  get name() {
+    return this.agent.name
+  }
+
+  get type() {
+    return this.agent.type
+  }
+}
+
+

data/app/assets/javascripts/hyrax/permissions/group.es6

@@ -0,0 +1,10 @@
+export class Group {
+  /**
+   * Initialize the Group 
+   * @param {String} name the name of the agent
+   */
+  constructor(name) {
+    this.type = 'group'
+    this.name = name
+  }
+}

data/app/assets/javascripts/hyrax/permissions/group_controls.es6

@@ -0,0 +1,73 @@
+import { Group } from './group'
+import { Grant } from './grant'
+export class GroupControls {
+  /**
+   * Initialize the registry
+   * @param {jQuery} element the jquery selector for the permissions container
+   * @param {Registry} registry the permissions registry
+   */
+  constructor(element, registry) {
+    this.element = element
+    this.registry = registry
+    this.groupField = this.element.find("#new_group_name_skel")
+    this.permissionField = this.element.find("#new_group_permission_skel")
+
+    // add button for new group
+    $('#add_new_group_skel').on('click', (e) => this.addNewGroup(e));
+  }
+
+  addNewGroup(e) {
+    e.preventDefault()
+    if (!this.groupValid()) {
+      return this.groupField.focus();
+    }
+
+    var group_name = this.groupField.val();
+    var access = this.permissionField.val();
+    var access_label = this.selectedPermission().text();
+
+    if (!this.registry.isPermissionDuplicate(this.groupName())) {
+      return this.addError("This group already has a permission.")
+    }
+
+    let agent = new Group(group_name)
+    let grant = new Grant(agent, access, access_label)
+    this.registry.addPermission(grant);
+    this.reset();
+  }
+  // clear out the elements to add more
+  reset() {
+    this.registry.reset();
+    this.groupField.val('');
+    this.permissionField.val('none');
+  }
+
+  groupName() {
+    return this.groupField.val()
+  }
+
+  addError(message) {
+    this.registry.addError(message);
+    this.groupField.val('').focus()
+  }
+
+  groupValid() {
+    return this.selectedGroupValid() && this.permissionValid()
+  }
+
+  selectedGroupValid() {
+    return this.selectedGroup().index() != 0
+  }
+
+  selectedGroup() {
+    return this.groupField.find(':selected')
+  }
+
+  permissionValid() {
+    return this.selectedPermission().index() != 0
+  }
+
+  selectedPermission() {
+    return this.permissionField.find(':selected')
+  }
+}

data/app/assets/javascripts/hyrax/permissions/person.es6

@@ -0,0 +1,11 @@
+export class Person {
+  /**
+   * Initialize the Person 
+   * @param {String} name the name of the agent
+   */
+  constructor(name) {
+    this.type = 'person'
+    this.name = name
+  }
+}
+

data/app/assets/javascripts/hyrax/permissions/registry.es6

@@ -0,0 +1,110 @@
+import { RegistryEntry } from './registry_entry'
+export class Registry {
+  /**
+   * Initialize the registry
+   * @param {jQuery} element the jquery selector for the permissions container
+   * @param {String} object_name the name of the object, for constructing form fields (e.g. 'generic_work')
+   * @param {String} template_id the the identifier of the template for the added elements
+   */
+  constructor(element, object_name, template_id) {
+    this.object_name = object_name
+    this.template_id = template_id
+    this.error = $('#permissions_error')
+    this.errorMessage = $('#permissions_error_text')
+    this.items = []
+
+    // the remove button is only on preexisting grants
+    $('.remove_perm').on('click', (evt) => this.removePermission(evt))
+
+  }
+
+  addError(message) {
+    this.errorMessage.html(message);
+    this.error.removeClass('hidden');
+  }
+
+  reset() {
+    this.error.addClass('hidden');
+  }
+
+  removePermission(evt) {
+     evt.preventDefault();
+     let button = $(evt.target);
+     let container = button.closest('tr');
+     container.addClass('hidden'); // do not show the block
+     this.addDestroyField(container, button.attr('data-index'));
+     this.showPermissionNote();
+  }
+
+  addPermission(grant) {
+    this.showPermissionNote()
+    grant.index = this.nextIndex()
+    this.items.push(new RegistryEntry(grant, this, $('#file_permissions'), this.template_id))
+  }
+
+  nextIndex() {
+      return $('#file_permissions').parent().children().size() - 1;
+  }
+
+  showPermissionNote() {
+     $('#save_perm_note').removeClass('hidden');
+  }
+
+  addDestroyField(element, index) {
+      $('<input>').attr({
+          type: 'hidden',
+          name: `${this.fieldPrefix(index)}[_destroy]`,
+          value: 'true'
+      }).appendTo(element);
+  }
+
+  fieldPrefix(counter) {
+    return `${this.object_name}[permissions_attributes][${counter}]`
+  }
+
+  /*
+   * make sure the permission being applied is not for a user/group
+   * that already has a permission.
+   */
+  isPermissionDuplicate(user_or_group_name) {
+    let s = `[${user_or_group_name}]`;
+    var patt = new RegExp(this.preg_quote(s), 'gi');
+    var perms_input = $(`input[name^='${this.object_name}[permissions]']`);
+    var perms_sel = $(`select[name^='${this.object_name}[permissions]']`);
+    var flag = 1;
+    perms_input.each(function(index, form_input) {
+	// if the name is already being used - return false (not valid)
+	if (patt.test(form_input.name)) {
+	  flag = 0;
+	}
+      });
+    if (flag) {
+      perms_sel.each(function(index, form_input) {
+	// if the name is already being used - return false (not valid)
+	if (patt.test(form_input.name)) {
+	  flag = 0;
+	}
+      });
+    }
+    // putting a return false inside the each block
+    // was not working.  Not sure why would seem better
+    // rather than setting this flag var
+    return (flag ? true : false);
+  }
+
+  // http://kevin.vanzonneveld.net
+  // +   original by: booeyOH
+  // +   improved by: Ates Goral (http://magnetiq.com)
+  // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
+  // +   bugfixed by: Onno Marsman
+  // *     example 1: preg_quote("$40");
+  // *     returns 1: '\$40'
+  // *     example 2: preg_quote("*RRRING* Hello?");
+  // *     returns 2: '\*RRRING\* Hello\?'
+  // *     example 3: preg_quote("\\.+*?[^]$(){}=!<>|:");
+  // *     returns 3: '\\\.\+\*\?\[\^\]\$\(\)\{\}\=\!\<\>\|\:'
+
+  preg_quote( str ) {
+    return (str+'').replace(/([\\\.\+\*\?\[\^\]\$\(\)\{\}\=\!\<\>\|\:])/g, "\\$1");
+  }
+}

data/app/assets/javascripts/hyrax/permissions/registry_entry.es6

@@ -0,0 +1,45 @@
+export class RegistryEntry {
+  /**
+   * Initialize the registry
+   * @param {Grant} grant the grant to display on the form
+   * @param {Registry} registry the registry that holds this registry entry.
+   */
+  constructor(grant, registry, element, template) {
+    this.grant = grant
+    this.registry = registry
+    this.element = element
+
+    let row = this.createPermissionRow(grant, template);
+    this.addHiddenPermField(row, grant);
+    row.effect("highlight", {}, 3000);
+  }
+
+  createPermissionRow(grant, template_id) {
+    let row = $(tmpl(template_id, grant));
+    this.element.after(row);
+    row.find('button').click(function () {
+      row.remove();
+    });
+
+    return row;
+  }
+
+  addHiddenPermField(element, grant) {
+      var prefix = this.registry.fieldPrefix(grant.index);
+      $('<input>').attr({
+          type: 'hidden',
+          name: prefix + '[type]',
+          value: grant.type
+      }).appendTo(element);
+      $('<input>').attr({
+          type: 'hidden',
+          name: prefix + '[name]',
+          value: grant.name
+      }).appendTo(element);
+      $('<input>').attr({
+          type: 'hidden',
+          name: prefix + '[access]',
+          value: grant.access
+      }).appendTo(element);
+  }
+}

data/app/assets/javascripts/hyrax/permissions/user_controls.es6

@@ -0,0 +1,81 @@
+import { Person } from './person'
+import { Grant } from './grant'
+export class UserControls {
+  /**
+   * Initialize the registry
+   * @param {jQuery} element the jquery selector for the permissions container
+   * @param {Registry} registry the permissions registry
+   */
+  constructor(element, registry) {
+    this.element = element
+    this.registry = registry
+    this.depositor = $('#file_owner').data('depositor')
+    this.userField = this.element.find("#new_user_name_skel")
+    this.permissionField = this.element.find("#new_user_permission_skel")
+
+    // Attach the user search select2 box to the permission form
+    this.userField.userSearch()
+
+    // add button for new user
+    $('#add_new_user_skel').on('click', (e) => this.addNewUser(e));
+  }
+
+  addNewUser(e) {
+    e.preventDefault();
+
+    if (!this.userValid()) {
+      return this.userField.focus();
+    }
+
+    if (this.selectedUserIsDepositor()) {
+      return this.addError("Cannot change depositor permissions.")
+    }
+
+    if (!this.registry.isPermissionDuplicate(this.userName())) {
+      return this.addError("This user already has a permission.")
+    }
+
+    var access = this.permissionField.val();
+    var access_label = this.selectedPermission().text();
+    let agent = new Person(this.userName())
+    let grant = new Grant(agent, access, access_label)
+    this.registry.addPermission(grant);
+    this.reset();
+  }
+
+  // clear out the elements to add more
+  reset() {
+    this.registry.reset();
+    this.userField.select2('val', '');
+    this.permissionField.val('none');
+  }
+
+  userName() {
+    return this.userField.val()
+  }
+
+  addError(message) {
+    this.registry.addError(message);
+    this.userField.val('').focus()
+  }
+
+  selectedUserIsDepositor() {
+    return this.userName() == this.depositor
+  }
+
+  userValid() {
+    return this.userNameValid() && this.permissionValid()
+  }
+
+  userNameValid() {
+    return this.userName() != ""
+  }
+
+  permissionValid() {
+    return this.selectedPermission().index() != 0
+  }
+
+  selectedPermission() {
+    return this.permissionField.find(':selected')
+  }
+}

data/app/assets/javascripts/hyrax/proxy_rights.js

@@ -0,0 +1,68 @@
+(function( $ ){
+
+  $.fn.proxyRights = function( options ) {
+
+    // Create some defaults, extending them with any options that were provided
+    var settings = $.extend( { }, options);
+
+    var $container = this;
+
+    function addContributor(name, user_key, grantor) {
+      data = {name: name, user_key: user_key}
+
+      $.ajax({
+        type: "POST",
+        url: '/users/'+grantor+'/depositors',
+        dataType: 'json',
+        data: {grantee_id: user_key},
+        success: function (data) {
+          if (data.name !== undefined) {
+            row = rowTemplate(data);
+            $('#authorizedProxies tbody', $container).append(row);
+            if (settings.afterAdd)
+              settings.afterAdd(this, cloneElem);
+          }
+        }
+      })
+      return false;
+    }
+
+    function removeContributor(event) {
+      event.preventDefault();
+      $.ajax({
+        url: $(this).closest('a').prop('href'),
+        type: "post",
+        dataType: "json",
+        data: {"_method":"delete"}
+      });
+      $(this).closest('tr').remove();
+      return false;
+    }
+
+    function rowTemplate (data) {
+      return '<tr>'+
+                '<td class="depositor-name">'+data.name+'</td>'+
+                '<td><a class="remove-proxy-button" data-method="delete" href="'+data.delete_path+'" rel="nofollow">'+
+                  '<i class="glyphicon glyphicon-remove"></i></a>'+
+                '</td>'+
+              '</tr>'
+    }
+
+    $("#user").userSearch();
+    $("#user").on("change", function() {
+      // Remove the choice from the select2 widget and put it in the table.
+      obj = $("#user").select2("data")
+      grantor = $('#user').data('grantor')
+      $("#user").select2("val", '')
+      addContributor(obj.text, obj.user_key, grantor);
+    });
+
+    $('body').on('click', 'a.remove-proxy-button', removeContributor);
+
+  };
+
+})( jQuery );
+
+Blacklight.onLoad(function() {
+  $('.proxy-rights').proxyRights();
+});

data/app/assets/javascripts/hyrax/relationships.js

@@ -0,0 +1,2 @@
+//= require hyrax/relationships/table
+//= require hyrax/relationships/table_row

data/app/assets/javascripts/hyrax/relationships/table.es6

@@ -0,0 +1,206 @@
+import { RelationshipsTableRow } from './table_row'
+
+export class RelationshipsTable {
+
+  /**
+   * Initializes the class in the context of an individual table element
+   * @param {jQuery} element the table element that this class represents
+   */
+  constructor(element) {
+    this.$element = element;
+    this.form_action = this.$element.parents("form").attr("action");
+    this.query_url = this.$element.data('query-url');
+    this.existing_related_works_values = this.$element.find("input.related_works_ids:not(.new-form-control)").map(function(i, e){ return e.value; });
+
+    // TODO: Fall back to just cloning rows and removing rows for form posting
+    if (!this.query_url)
+      return;
+
+    this.bindAddButton();
+    this.bindRemoveButton();
+    this.bindKeyEvents();
+  }
+
+  /**
+   * Handle click events by the "Add" button in the table, setting a warning
+   * message if the input is empty or calling the server to handle the request
+   */
+  bindAddButton() {
+    let $this = this;
+
+    $this.$element.on("click", ".btn-add-row", function(event) {
+      let $row = $(this).parents("tr:first");
+      let $input = $row.find("input.new-form-control");
+
+      // Display an error when the input field is empty, or if the work ID is already related,
+      // otherwise clone the row and set appropriate styles
+      if ($input.val() == "") {
+        $this.setWarningMessage($row, "ID cannot be empty.");
+      } else if ($.inArray($input.val(), $this.existing_related_works_values) > -1) {
+        $this.setWarningMessage($row, "Work is already related.");
+      } else {
+
+        let query_url = $this.query_url.replace('$id', $input.val());
+        $this.hideWarningMessage($row);
+        $this.callAjax({
+          row: $row,
+          table: $this.$element,
+          input: $input,
+          url: $this.form_action,
+          query_url: query_url,
+          on_error: $this.handleError,
+          on_success: $this.handleAddRowSuccess
+        });
+      }
+    });
+  }
+
+  /**
+   * Find and fire off the click event for the "Add" button
+   * @param {jQuery} $row the row containing the add button to click
+   */
+  clickAddbutton($row) {
+    $row.find(".btn-add-row").click();
+  }
+
+  /**
+   * Handle click events by the "Remove" buttons in the table, and calling the
+   * server to handle the request
+   */
+  bindRemoveButton() {
+    let $this = this;
+
+    $this.$element.on("click", ".btn-remove-row", function(event) {
+      let $row = $(this).parents("tr:first");
+      let $input = $row.find("input.related_works_ids:first");
+
+      // Track which input is attemping to be removed, to provide an easy way
+      // for the ajax call to exclude it when making the call to the server
+      $input.addClass("removing");
+      $this.callAjax({
+        row: $row,
+        table: $this.$element,
+        input: $input,
+        url: $this.form_action,
+        on_error: $this.handleError,
+        on_success: $this.handleRemoveRowSuccess
+      });
+    });
+  }
+
+  /**
+   * Handle keyup and keypress events at the form level to prevent the ENTER key
+   * from submitting the form. ENTER key within a relationships table should
+   * click the "Add" button instead. ESC key should clear the input and hide the
+   * error message.
+   */
+  bindKeyEvents() {
+    let $this = this;
+    let $form = this.$element.parents("form");
+
+    $form.on("keyup keypress", "input.related_works_ids", function(event) {
+      let $row = $(this).parents("tr:first");
+      let key_code = event.keyCode || event.which;
+
+      // ENTER key was pressed, wait for keyup to click the Add button
+      if (key_code === 13) {
+        if (event.type == "keyup") {
+          $this.clickAddbutton($row);
+        }
+        event.preventDefault();
+        return false;
+      }
+
+      // ESC key was pressed, clear the input field and hide the error
+      if (key_code === 27 && event.type == "keyup") {
+        $(this).val("");
+        $this.hideWarningMessage($row);
+      }
+    });
+  }
+
+  /**
+   * Set the warning message related to the appropriate row in the table
+   * @param {jQuery} $row the row containing the warning message to display
+   * @param {String} message the warning message text to set
+   */
+  setWarningMessage($row, message) {
+    $row.find(".message.has-warning").text(message).removeClass("hidden");
+  }
+
+  /**
+   * Hide the warning message on the appropriate row
+   * @param {jQuery} $row the row containing the warning message to hide
+   */
+  hideWarningMessage($row){
+    $row.find(".message").addClass("hidden");
+  }
+
+  /**
+   * Call the server, then call the appropriate callbacks to handle success and errors
+   * @param {Object} args the table, row, input, url, and callbacks
+   */
+  callAjax(args) {
+    let $this = this;
+    // Send only the IDs in this table that aren't in the midst of being "removed"
+    let data = args.table.find("input.related_works_ids:not('.removing')").serialize();
+    $.ajax({
+        type: 'patch',
+        url: args.url,
+        dataType: 'json',
+        data: data
+      })
+      .done(function(json) {
+        args.on_success($this, args, json);
+      })
+      .fail(function(jqxhr, status, err) {
+        args.on_error($this, args, jqxhr, status, err);
+      });
+  }
+
+  /**
+   * Set a warning message to alert the user on an error
+   * @param {jQuery} $this the RelationshipsTable class instance
+   * @param {Object} args the table, row, input, url, and callbacks
+   * @param {Object} jqxhr the jQuery XHR response object
+   * @param {String} status the HTTP error status
+   * @param {String} err the HTTP error
+   */
+  handleError($this, args, jqxhr, status, err) {
+    args.row.find('input.removing').removeClass('removing');
+    let message = jqxhr.statusText;
+    if(jqxhr.responseJSON){
+      message = jqxhr.responseJSON.description;
+    }
+    $this.setWarningMessage(args.row, message);
+  }
+
+  /**
+   * Remove the row when the API returns this type of success
+   * @param {jQuery} $this the RelationshipsTable class instance
+   * @param {Object} args the table, row, input, url, and callbacks
+   * @param {String} json the returned JSON string
+   */
+  handleRemoveRowSuccess($this, args, json) {
+    args.row.remove();
+  }
+
+  /**
+   * Add a new row to the table, query the server for details about the work to
+   * set the title and link for the new work that was added. Hide the input
+   * field and display the title and edit button
+   * @param {jQuery} $this the RelationshipsTable class instance
+   * @param {Object} args the table, row, input, url, and callbacks
+   * @param {String} json the returned JSON string
+   */
+  handleAddRowSuccess($this, args, json) {
+    let new_row = new RelationshipsTableRow(args.table);
+    new_row.clone(args.row);
+    new_row.callAjaxQuery(args.query_url);
+
+    // finally, empty the "add" row input value
+    args.row.find("input.new-form-control").val("");
+    // synch the related_works_values to include the new work relationship
+    $this.existing_related_works_values = $this.$element.find("input.related_works_ids:not(.new-form-control)").map(function(i, e){ return e.value; });
+  }
+}