sufia 7.2.0 → 7.3.0.rc1

data/app/assets/javascripts/sufia/admin/admin_set/participants.es6

@@ -0,0 +1,9 @@
+export default class {
+  constructor(elem) {
+    this.user = elem.find('#user-participants-form input[type=text]')
+  }
+
+  setup() {
+    this.user.userSearch();
+  }
+}

data/app/assets/javascripts/sufia/admin/admin_set/visibility.es6

@@ -0,0 +1,134 @@
+export default class {
+  constructor(element) {
+    this.element = element
+  }
+
+  setup() {
+    // Watch for changes to "release_period" radio inputs
+    let releasePeriodInput = this.element.find("input[type='radio'][name$='[release_period]']")
+    $(releasePeriodInput).on('change', () => { this.releasePeriodSelected() })
+    this.releasePeriodSelected()
+
+    // Watch for changes to "release_varies" radio inputs
+    let releaseVariesInput = this.element.find("input[type='radio'][name$='[release_varies]']")
+    $(releaseVariesInput).on('change', () => { this.releaseVariesSelected() })
+    this.releaseVariesSelected()
+  }
+
+  // Based on the "release_period" radio selected, enable/disable other options
+  releasePeriodSelected() {
+    let selected = this.element.find("input[type='radio'][name$='[release_period]']:checked")
+    
+    switch(selected.val()) {
+      // If "No Delay" (now) selected
+      case "now":
+        this.disableReleaseVariesOptions()
+        this.disableReleaseFixedDate()
+        this.enableVisibilityRestricted()
+        break;
+
+      // If "Varies" ("") selected
+      case "":
+        this.enableReleaseVariesRadio()
+        this.disableReleaseFixedDate()
+        this.disableVisibilityRestricted()
+        // Also check if a release "Varies" sub-option previously selected
+        this.releaseVariesSelected()
+        break;
+
+      // If "Fixed" selected
+      case "fixed":
+        this.disableReleaseVariesOptions()
+        this.enableReleaseFixedDate()
+        this.disableVisibilityRestricted()
+        break;
+
+      // Nothing selected
+      default:
+        this.disableReleaseVariesOptions()
+        this.disableReleaseFixedDate()
+        this.disableVisibilityRestricted()
+    }
+  }
+
+  // Based on the "release_varies" radio selected, enable/disable other options
+  releaseVariesSelected() {
+    let selected = this.element.find("input[type='radio'][name$='[release_varies]']:checked")
+
+    switch(selected.val()) {
+      // If before specific date selected
+      case "before":
+        this.enableReleaseVariesDate();
+        this.disableReleaseVariesSelect();
+        break;
+
+      // If embargo option selected
+      case "embargo":
+        this.disableReleaseVariesDate();
+        this.enableReleaseVariesSelect();
+        break;
+
+      // Nothing selected
+      default:
+        this.disableReleaseVariesDate();
+        this.disableReleaseVariesSelect();
+    }
+  }
+
+  // Disable ALL sub-options under "Varies"
+  disableReleaseVariesOptions() {
+    this.disableReleaseVariesRadio()
+    this.disableReleaseVariesSelect()
+    this.disableReleaseVariesDate()
+  }
+
+  // Disable all radio inputs under the release "Varies" option
+  disableReleaseVariesRadio() {
+    this.element.find("#release-varies input[type='radio'][name$='[release_varies]']").prop("disabled", true)
+  }
+
+  // Enable all radio inputs under the release "Varies" option
+  enableReleaseVariesRadio() {
+    this.element.find("#release-varies input[type='radio'][name$='[release_varies]']").prop("disabled", false)
+  }
+
+  // Disable selectbox next to release "Varies" embargo option
+  disableReleaseVariesSelect() {
+    this.element.find("#release-varies select[name$='[release_embargo]']").prop("disabled", true)
+  }
+
+  // Enable selectbox next to release "Varies" embargo option
+  enableReleaseVariesSelect() {
+    this.element.find("#release-varies select[name$='[release_embargo]']").prop("disabled", false)
+  }
+
+  // Disable date input field next to release "Varies" before option
+  disableReleaseVariesDate() {
+    this.element.find("#release-varies input[type='date'][name$='[release_date]']").prop("disabled", true)
+  }
+
+  // Enable date input field next to release "Varies" before option
+  enableReleaseVariesDate() {
+    this.element.find("#release-varies input[type='date'][name$='[release_date]']").prop("disabled", false)
+  }
+
+  // Disable date input field next to release "Fixed" option
+  disableReleaseFixedDate() {
+    this.element.find("#release-fixed input[type='date'][name$='[release_date]']").prop("disabled", true)
+  }
+
+  // Enable date input field next to release "Fixed" option
+  enableReleaseFixedDate() {
+    this.element.find("#release-fixed input[type='date'][name$='[release_date]']").prop("disabled", false)
+  }
+
+  // Disable visibility "Restricted" option (not valid for embargoes)
+  disableVisibilityRestricted() {
+    this.element.find("input[type='radio'][name$='[visibility]'][value='restricted']").prop("disabled", true)
+  }
+
+  // Enable visibility "Restricted" option
+  enableVisibilityRestricted() {
+    this.element.find("input[type='radio'][name$='[visibility]'][value='restricted']").prop("disabled", false)
+  }
+}

data/app/assets/javascripts/sufia/admin/admin_set_controls.es6

@@ -0,0 +1,11 @@
+export default class {
+  constructor(elem) {
+    let Participants = require('sufia/admin/admin_set/participants');
+    let participants = new Participants(elem.find('#participants'))
+    participants.setup();
+
+    let Visibility = require('sufia/admin/admin_set/visibility');
+    let visibilityTab = new Visibility(elem.find('#visibility'));
+    visibilityTab.setup();
+  }
+}

data/app/assets/javascripts/sufia/app.js

@@ -9,13 +9,24 @@ Sufia = {
         this.permissions();
         this.notifications();
         this.transfers();
-        this.relationships_table();
-        this.file_manager_init();
+        this.relationshipsTable();
+        this.fileManager();
+        this.selectWorkType();
         this.datatable();
+        this.admin();
+    },
+
+    admin: function() {
+      var AdminSetControls = require('sufia/admin/admin_set_controls');
+      var controls = new AdminSetControls($('#admin-set-controls'));
     },
 
     datatable: function () {
-        $('.datatable').DataTable();
+        // This keeps the datatable from being added to a table that already has it.
+        // This is a problem when turbolinks is active.
+        if ($('.dataTables_wrapper').size() === 0) {
+            $('.datatable').DataTable();
+        }
     },
 
     autocomplete: function () {
@@ -50,8 +61,12 @@ Sufia = {
 
     permissions: function () {
         var perm = require('sufia/permissions/control');
+        // On the edit work page
         new perm.PermissionsControl($("#share"), 'tmpl-work-grant');
+        // On the edit fileset page
         new perm.PermissionsControl($("#permission"), 'tmpl-file-set-grant');
+        // On the batch edit page
+        new perm.PermissionsControl($("#form_permissions"), 'tmpl-work-grant');
     },
 
     notifications: function () {
@@ -67,14 +82,21 @@ Sufia = {
         $("#proxy_deposit_request_transfer_to").userSearch();
     },
 
-    relationships_table: function () {
+    relationshipsTable: function () {
         var rel = require('sufia/relationships/table');
         $('table.relationships-ajax-enabled').each(function () {
             new rel.RelationshipsTable($(this));
         });
     },
 
-    file_manager_init: function () {
+    selectWorkType: function () {
+        var selectWork = require('sufia/select_work_type');
+        $("[data-behavior=select-work]").each(function () {
+            new selectWork($(this))
+        });
+    },
+
+    fileManager: function () {
         var fm = require('curation_concerns/file_manager');
         var file_manager = new fm
     },

data/app/assets/javascripts/sufia/autocomplete.es6

@@ -16,6 +16,11 @@ export class Autocomplete {
             case "based_near":
               this.autocompleteLocation(selector);
               break;
+            case "work":
+              var user = selector.data('user');
+              var id = selector.data('id');
+              this.autocompleteWork(selector, user, id);
+              break;
           }
       });
   }
@@ -48,4 +53,14 @@ export class Autocomplete {
       var lang = require('sufia/autocomplete/language');
       new lang.Language(field, field.data('autocomplete-url'))
   }
+
+  autocompleteWork(field, user, id) {
+    var work = require('sufia/autocomplete/work')
+    new work.Work(
+      field,
+      field.data('autocomplete-url'),
+      user,
+      id
+    )
+  }
 }

data/app/assets/javascripts/sufia/autocomplete/work.es6

@@ -0,0 +1,29 @@
+export class Work {
+  // Autocomplete for finding possible related works (child and parent).
+  constructor(element, url, user, id) {
+    this.url = url;
+    this.user = user;
+    this.work_id = id;
+    element.autocomplete(this.options());
+  }
+
+  options() {
+    return {
+      minLength: 2,
+      source: ( request, response ) => {
+        $.getJSON(this.url, {
+          q: request.term,
+          id: this.work_id,
+          user: this.user
+        }, response );
+      },
+      focus: function() {
+        // prevent value inserted on focus
+        return false;
+      },
+      complete: function(event) {
+        $('.ui-autocomplete-loading').removeClass("ui-autocomplete-loading");
+      }
+    };
+  }
+}

data/app/assets/javascripts/sufia/dashboard_actions.js

@@ -10,17 +10,15 @@ Blacklight.onLoad(function() {
   });
 
   function show_details(item) {
-    var button = $(this);
-    //button.id format: "expand_NNNNNNNNNN"
     var array = item.id.split("expand_");
     if (array.length > 1) {
       var docId = array[1];
       $("#detail_" + docId + " .expanded-details").slideToggle();
-      button.toggleClass('glyphicon-chevron-right glyphicon-chevron-down');
+      $(item).toggleClass('glyphicon-chevron-right glyphicon-chevron-down');
     }
   }
 
-        // show/hide more information on the dashboard when clicking
+  // show/hide more information on the dashboard when clicking
   // plus/minus
   $('.glyphicon-chevron-right').on('click', function() {
     show_details(this);

data/app/assets/javascripts/sufia/save_work/save_work_control.es6

@@ -54,7 +54,19 @@ export class SaveWorkControl {
   }
 
   /**
-   * Is the form for a new object (vs edit an exisiting object)
+   * Keep the form from being submitted while uploads are running
+   *
+   */
+  preventSubmitIfUploading() {
+    this.form.on('submit', (evt) => {
+      if (this.uploads.inProgress) {
+        evt.preventDefault()
+      }
+    })
+  }
+
+  /**
+   * Is the form for a new object (vs edit an existing object)
    */
   get isNew() {
     return this.form.attr('id').startsWith('new')
@@ -80,6 +92,7 @@ export class SaveWorkControl {
     new VisibilityComponent(this.element.find('.visibility'))
     this.preventSubmitUnlessValid()
     this.preventSubmitIfAlreadyInProgress()
+    this.preventSubmitIfUploading()
     $('.multi_value.form-group', this.form).bind('managed_field:add', () => this.formChanged())
     $('.multi_value.form-group', this.form).bind('managed_field:remove', () => this.formChanged())
     this.formChanged()
@@ -136,4 +149,3 @@ export class SaveWorkControl {
     return this.depositAgreement.isAccepted
   }
 }
-

data/app/assets/javascripts/sufia/save_work/uploaded_files.es6

@@ -1,8 +1,9 @@
 export class UploadedFiles {
-  // Monitors the form and runs the callback if any files are added
+  // Monitors the form and runs the callback when files are added
   constructor(form, callback) {
     this.form = form
-    $('#fileupload').bind('fileuploadcompleted', callback)
+    this.element = $('#fileupload')
+    this.element.bind('fileuploadcompleted', callback)
   }
 
   get hasFileRequirement() {
@@ -10,6 +11,10 @@ export class UploadedFiles {
     return fileRequirement.size() > 0
   }
 
+  get inProgress() {
+    return this.element.fileupload('active') > 0
+  }
+
   get hasFiles() {
     let fileField = this.form.find('input[name="uploaded_files[]"]')
     return fileField.size() > 0

data/app/assets/javascripts/sufia/save_work/visibility_component.es6

@@ -1,27 +1,268 @@
 export class VisibilityComponent {
   constructor(element) {
     this.element = element
+    this.form = element.closest('form')
     $('.collapse').collapse({ toggle: false })
     element.find("[type='radio']").on('change', () => { this.showForm() })
     this.showForm()
+    this.limitByAdminSet()
   }
 
   showForm() {
-    this.collapseAll()
     this.openSelected()
   }
 
+  // Collapse all Visibility sub-options
   collapseAll() {
     $('.collapse').collapse('hide');
   }
 
+  // Open the selected Visibility's sub-options, collapsing all others
   openSelected() {
     let selected = this.element.find("[type='radio']:checked")
 
     let target = selected.data('target')
-    if (!target) {
-      return
+
+    if(target) {
+      // Show the target suboption and hide all others
+      $('.collapse' + target).collapse('show');
+      $('.collapse:not(' + target + ')').collapse('hide');
+    }
+    else {
+      this.collapseAll()
+    }
+  }
+
+  // Limit visibility options based on selected AdminSet (if enabled)
+  limitByAdminSet() {
+    let adminSetInput = this.form.find('select[id$="_admin_set_id"]')
+    if(adminSetInput) {
+      $(adminSetInput).on('change', () => { this.restrictToVisibility(adminSetInput.find(":selected")) })
+      this.restrictToVisibility(adminSetInput.find(":selected"))
+    }
+  }
+
+  // Restrict visibility and/or release date to match the AdminSet requirements (if any)
+  restrictToVisibility(selected) {
+    // visibility requirement is in HTML5 'data-visibility' attr
+    let visibility = selected.data('visibility')
+    // release date requirement is in HTML5 'data-release-date' attr
+    let release_date = selected.data('release-date')
+    // if release_date is flexible (i.e. before date), then 'data-release-before-date' attr will be true
+    let release_before = selected.data('release-before-date')
+
+    // Restrictions require either a visibility requirement or a release_date requirement (or both)
+    if(visibility || release_date) {
+      this.applyRestrictions(visibility, release_date, release_before)
+    }
+    else {
+      this.enableAllOptions()
+    }
+  }
+
+  // Apply visibility/release restrictions based on selected AdminSet
+  applyRestrictions(visibility, release_date, release_before)
+  {
+     // If immediate release required and visibility specified
+     if(this.isToday(release_date) && visibility) {
+       // Select required visibility
+       this.selectVisibility(visibility)
+     }
+     else if(this.isToday(release_date)) {
+       // No visibility required, but must be released today. Disable embargo & lease.
+       this.disableEmbargoAndLease();
+     }
+     // Otherwise if future date and release_before==true, must be released between today and release_date
+     else if(release_date && release_before) {
+       this.enableReleaseNowOrEmbargo(visibility, release_date, release_before)
+     }
+     // Otherwise if future date and release_before==false, this is a required embargo (must be released on specific future date)
+     else if(release_date) {
+       this.requireEmbargo(visibility, release_date)
+     }
+     // If nothing above matched, then there's no release date required. So, release now or embargo is fine
+     else {
+       this.enableReleaseNowOrEmbargo(visibility, release_date, release_before)
+     }
+  }
+
+  // Select given visibility option. All others disabled.
+  selectVisibility(visibility) {
+    this.element.find("[type='radio'][value='" + visibility + "']").prop("checked", true).prop("disabled", false)
+    this.element.find("[type='radio'][value!='" + visibility + "']").prop("disabled", true)
+    // Ensure required option is opened in form
+    this.showForm()
+  }
+
+  // Allow for immediate release or embargo, based on visibility settings (if any)
+  enableReleaseNowOrEmbargo(visibility, release_date, release_before) {
+    if(visibility) {
+      // Enable ONLY the allowable visibility options (specified visibility or embargo)
+      this.enableVisibilityOptions([visibility, "embargo"])
+    }
+    else {
+      // Allow all visibility options EXCEPT lease
+      this.disableVisibilityOptions(["lease"])
+    }
+
+    // Limit valid embargo release dates
+    this.restrictEmbargoDate(release_date, release_before)
+
+    // Select Visibility after embargo (if any)
+    this.selectVisibilityAfterEmbargo(visibility)
+  }
+
+  // Require a specific embargo date (and possibly also specific visibility)
+  requireEmbargo(visibility, release_date) {
+    // This a required embargo date
+    this.selectVisibility("embargo")
+
+    // Limit valid embargo release dates
+    this.restrictEmbargoDate(release_date, false)
+
+    // Select Visibility after embargo (if any)
+    this.selectVisibilityAfterEmbargo(visibility)
+  }
+
+  // Disable Embargo and Lease options. Work must be released immediately
+  disableEmbargoAndLease() {
+    this.disableVisibilityOptions(["embargo","lease"])
+  }
+
+  // Enable one or more visibility option (based on array of passed in options),
+  // disabling all other options
+  enableVisibilityOptions(options) {
+    let matchEnabled = this.getMatcherForVisibilities(options)
+    let matchDisabled = this.getMatcherForNotVisibilities(options)
+
+    // Enable all that match "matchEnabled" (if any), and disable those matching "matchDisabled"
+    if(matchEnabled) {
+      this.element.find(matchEnabled).prop("disabled", false)
+    }
+    this.element.find(matchDisabled).prop("disabled", true)
+  }
+
+  // Disable one or more visibility option (based on array of passed in options),
+  // disabling all other options
+  disableVisibilityOptions(options) {
+    let matchDisabled = this.getMatcherForVisibilities(options)
+    let matchEnabled = this.getMatcherForNotVisibilities(options)
+
+    // Disable those matching "matchDisabled" (if any), and enable all that match "matchEnabled"
+    if(matchDisabled) {
+      this.element.find(matchDisabled).prop("disabled", true)
+    }
+    this.element.find(matchEnabled).prop("disabled", false)
+  }
+
+  // Create a jQuery matcher which will match for all the specified options
+  // (expects an array of options).
+  // This creates a logical OR matcher, whose format looks like:
+  // "[type='radio'][value='one'],[type='radio'][value='two']"
+  getMatcherForVisibilities(options) {
+    let initialMatcher = "[type='radio']"
+    let matcher = ""
+    // Loop through specified visibility options, creating a logical OR matcher
+    for(let i = 0; i < options.length; i++) {
+      if(i > 0) {
+        matcher += ","
+      }
+      matcher += initialMatcher + "[value='" + options[i] + "']"
     }
-    $(target).collapse('show');
+    return matcher
+  }
+
+  // Create a jQuery matcher which will match all options EXCEPT the specified options
+  // (expects an array of options).
+  // This creates a logical AND NOT matcher, whose format looks like:
+  // "[type='radio'][value!='one'][value!='two']"
+  getMatcherForNotVisibilities(options) {
+    let initialMatcher = "[type='radio']"
+    let matcher = initialMatcher
+    // Loop through specified visibility options, creating a logical AND NOT matcher
+    for(let i = 0; i < options.length; i++) {
+      matcher += "[value!='" + options[i] + "']"
+    }
+    return matcher
+  }
+
+  // Based on release_date/release_before, limit valid options for embargo date
+  // * release_date is a date of format YYYY-MM-DD
+  // * release_before is true if dates before release_date are allowabled, false otherwise.
+  restrictEmbargoDate(release_date, release_before) {
+    let embargoDateInput = this.getEmbargoDateInput()
+    // Dates before today are not valid
+    embargoDateInput.prop("min", this.getToday());
+
+    if(release_date) {
+      // Dates AFTER release_date are not valid
+      embargoDateInput.prop("max", release_date);
+    }
+    else {
+      embargoDateInput.prop("max", "");
+    }
+
+    // If release before dates are NOT allowed, set exact embargo date and disable field
+    if(release_date && !release_before) {
+      embargoDateInput.val(release_date)
+      embargoDateInput.prop("disabled", true)
+    }
+    else {
+      embargoDateInput.prop("disabled", false)
+    }
+  }
+
+  // Based on embargo visibility, select required visibility (if any)
+  selectVisibilityAfterEmbargo(visibility) {
+    let visibilityInput = this.getVisibilityAfterEmbargoInput()
+    // If a visibility is required, select it and disable field
+    if(visibility) {
+      visibilityInput.find("option[value='" + visibility + "']").prop("selected", true)
+      visibilityInput.prop("disabled", true)
+    }
+    else {
+      visibilityInput.prop("disabled", false)
+    }
+  }
+
+  // Ensure all visibility options are enabled
+  enableAllOptions() {
+    this.element.find("[type='radio']").prop("disabled", false)
+    this.getEmbargoDateInput().prop("disabled", false)
+    this.getVisibilityAfterEmbargoInput().prop("disabled", false)
+  }
+
+  // Get input field corresponding to embargo date
+  getEmbargoDateInput() {
+    return this.element.find("[type='date'][id$='_embargo_release_date']")
+  }
+
+  // Get input field corresponding to visibility after embargo expires
+  getVisibilityAfterEmbargoInput() {
+    return this.element.find("select[id$='_visibility_after_embargo']")
+  }
+
+  // Get today's date in YYYY-MM-DD format
+  getToday() {
+    let today = new Date()
+    let dd = today.getDate()
+    let mm = today.getMonth() + 1  // January is month 0
+    let yyyy = today.getFullYear()
+
+    // prepend zeros as needed
+    if(dd < 10) {
+      dd = '0' + dd
+    }
+    if(mm < 10) {
+      mm = '0' + mm
+    }
+    return yyyy + '-' + mm + '-' + dd
+  }
+
+  // Return true if datestring represents today's date
+  isToday(dateString) {
+    let today = new Date(this.getToday())
+    let date =  new Date(dateString)
+    return date.getTime() === today.getTime()
   }
 }