test_hyrax 0.0.1.alpha

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

@@ -0,0 +1,79 @@
+export class RelationshipsTableRow {
+  /**
+   * Inititializes a new table row class
+   * @param {jQuery} $table the table which this row is related to
+   */
+  constructor($table){
+    this.table = $table;
+    this.element = null;
+  }
+
+  /**
+   * The title element
+   * @returns {jQuery} the title element
+   */
+  get title() { return this.element.find("a.title:first"); }
+
+  /**
+   * The input field
+   * @returns {jQuery} the input field
+   */
+  get input() { return this.element.find("input.related_works_ids:first"); }
+
+  /**
+   * The "Add" button
+   * @returns {jQuery} the add button element
+   */
+  get addButton() { return this.element.find(".btn-add-row"); }
+
+  /**
+   * The "Remove" button
+   * @returns {jQuery} the remove button element
+   */
+  get removeButton() { return this.element.find(".btn-remove-row"); }
+
+  /**
+   * The "Edit" button
+   * @returns {jQuery} the edit button element
+   */
+  get editButton() { return this.element.find("a.edit:first"); }
+
+  /**
+   * Clone the row, set the element in this instance of the class, and reset the proper styles for this row. Insert
+   * this new row before the row passed in.. leaving the passed in row styled as-is, the caller of this method is responsible
+   * for properly handling adjustment to the passed in row
+   * @param {jQuery} $row the row to be cloned
+   */
+  clone($row){
+    this.element = $row.clone();
+    this.addButton.addClass("hidden");
+    this.removeButton.removeClass("hidden");
+    this.element.insertBefore($row);
+  }
+
+  /**
+   * Make an ajax call to the supplied url.
+   * After a row is cloned, this method could be called to refresh the row with more details (title, appropriate links, etc)
+   * based on the details returned from the server.
+   * @param {String} query_url the url to be called for querying details from the server
+   */
+  callAjaxQuery(query_url) {
+    let $this = this;
+    $.getJSON(query_url, function (data) {
+      // Set the cloned input to have the proper name and value for posting the
+      // form to the server, and hide it.
+      $this.input.removeClass("new-form-control")
+        .addClass("hidden")
+        .val(data.id);
+
+      // Set the linkified title and show.
+      $this.title.text(data.title[0])
+        .attr("href", query_url)
+        .removeClass("hidden");
+
+      // Set the edit button link and show.
+      $this.editButton.attr("href", query_url + "/edit")
+        .removeClass("hidden");
+    });
+  }
+}

data/app/assets/javascripts/hyrax/save_work.es6

@@ -0,0 +1,6 @@
+//= require hyrax/save_work/save_work_control
+//= require hyrax/save_work/required_fields
+//= require hyrax/save_work/uploaded_files
+//= require hyrax/save_work/checklist_item
+//= require hyrax/save_work/deposit_agreement
+//= require hyrax/save_work/visibility_component

data/app/assets/javascripts/hyrax/save_work/checklist_item.es6

@@ -0,0 +1,15 @@
+export class ChecklistItem {
+  constructor(element) {
+    this.element = element
+  }
+
+  check() {
+    this.element.removeClass('incomplete')
+    this.element.addClass('complete')
+  }
+
+  uncheck() {
+    this.element.removeClass('complete')
+    this.element.addClass('incomplete')
+  }
+}

data/app/assets/javascripts/hyrax/save_work/deposit_agreement.es6

@@ -0,0 +1,39 @@
+export class DepositAgreement {
+  // Monitors the form and runs the callback if any files are added
+  constructor(form, callback) {
+    this.agreementCheckbox = form.find('input#agreement')
+
+    // If true, require the accept checkbox to be checked.
+    // Tracks whether the user needs to accept again to the depositor
+    // agreement. Once the user has manually agreed once she does not
+    // need to agree again regardless on how many files are being added.
+    this.isActiveAgreement = this.agreementCheckbox.size() > 0
+    if (this.isActiveAgreement) {
+      this.setupActiveAgreement(callback)
+      this.mustAgreeAgain = this.isAccepted
+    }
+    else {
+      this.mustAgreeAgain = false
+    }
+  }
+
+  setupActiveAgreement(callback) {
+    this.agreementCheckbox.on('change', callback)
+  }
+
+  setNotAccepted() {
+    this.agreementCheckbox.prop("checked", false)
+    this.mustAgreeAgain = false
+  }
+
+  setAccepted() {
+    this.agreementCheckbox.prop("checked", true)
+  }
+
+  /**
+   * return true if it's a passive agreement or if the checkbox has been checked
+   */
+  get isAccepted() {
+    return !this.isActiveAgreement || this.agreementCheckbox[0].checked
+  }
+}

data/app/assets/javascripts/hyrax/save_work/required_fields.es6

@@ -0,0 +1,23 @@
+export class RequiredFields {
+  // Monitors the form and runs the callback if any of the required fields change
+  constructor(form, callback) {
+    this.form = form
+    this.callback = callback
+    this.reload()
+  }
+
+  get areComplete() {
+    return this.requiredFields.filter((n, elem) => { return this.isValuePresent(elem) } ).length == 0
+  }
+
+  isValuePresent(elem) {
+    return ($(elem).val() === null) || ($(elem).val().length < 1)
+  }
+
+  // Reassign requiredFields because fields may have been added or removed.
+  reload() {
+    // ":input" matches all input, select or textarea fields.
+    this.requiredFields = this.form.find(':input[required]')
+    this.requiredFields.change(this.callback)
+  }
+}

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

@@ -0,0 +1,139 @@
+import { RequiredFields } from './required_fields'
+import { ChecklistItem } from './checklist_item'
+import { UploadedFiles } from './uploaded_files'
+import { DepositAgreement } from './deposit_agreement'
+import { VisibilityComponent } from './visibility_component'
+
+/**
+ * Polyfill String.prototype.startsWith()
+ */
+if (!String.prototype.startsWith) {
+    String.prototype.startsWith = function(searchString, position){
+      position = position || 0;
+      return this.substr(position, searchString.length) === searchString;
+  };
+}
+
+export class SaveWorkControl {
+  /**
+   * Initialize the save controls
+   * @param {jQuery} element the jquery selector for the save panel
+   */
+  constructor(element) {
+    if (element.size() == 0) {
+      return
+    }
+    this.element = element
+    this.form = element.closest('form')
+    element.data('save_work_control', this)
+    this.activate();
+  }
+
+  /**
+   * Keep the form from submitting (if the return key is pressed)
+   * unless the form is valid.
+   *
+   * This seems to occur when focus is on one of the visibility buttons
+   */
+  preventSubmitUnlessValid() {
+    this.form.on('submit', (evt) => {
+      if (!this.isValid())
+        evt.preventDefault();
+    })
+  }
+
+  /**
+   * Keep the form from being submitted many times.
+   *
+   */
+  preventSubmitIfAlreadyInProgress() {
+    this.form.on('submit', (evt) => {
+      if (this.isValid())
+        this.saveButton.prop("disabled", true);
+    })
+  }
+
+  /**
+   * Is the form for a new object (vs edit an exisiting object)
+   */
+  get isNew() {
+    return this.form.attr('id').startsWith('new')
+  }
+
+
+  /*
+   * Call this when the form has been rendered
+   */
+  activate() {
+    if (!this.form) {
+      return
+    }
+    this.requiredFields = new RequiredFields(this.form, () => this.formStateChanged())
+    this.uploads = new UploadedFiles(this.form, () => this.formStateChanged())
+
+    this.saveButton = this.element.find(':submit')
+
+    this.depositAgreement = new DepositAgreement(this.form, () => this.formStateChanged())
+
+    this.requiredMetadata = new ChecklistItem(this.element.find('#required-metadata'))
+    this.requiredFiles = new ChecklistItem(this.element.find('#required-files'))
+    new VisibilityComponent(this.element.find('.visibility'))
+    this.preventSubmitUnlessValid()
+    this.preventSubmitIfAlreadyInProgress()
+    $('.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()
+  }
+
+  // Called when a file has been uploaded, the deposit agreement is clicked or a form field has had text entered.
+  formStateChanged() {
+    this.saveButton.prop("disabled", !this.isValid());
+  }
+
+  // called when a new field has been added to the form.
+  formChanged() {
+    this.requiredFields.reload();
+    this.formStateChanged();
+  }
+
+  isValid() {
+    // avoid short circuit evaluation. The checkboxes should be independent.
+    let metadataValid = this.validateMetadata()
+    let filesValid = this.validateFiles()
+    let agreementValid = this.validateAgreement(filesValid)
+    return metadataValid && filesValid && agreementValid
+  }
+
+  // sets the metadata indicator to complete/incomplete
+  validateMetadata() {
+    if (this.requiredFields.areComplete) {
+      this.requiredMetadata.check()
+      return true
+    }
+    this.requiredMetadata.uncheck()
+    return false
+  }
+
+  // sets the files indicator to complete/incomplete
+  validateFiles() {
+    if (!this.uploads.hasFileRequirement) {
+      return true
+    }
+    if (!this.isNew || this.uploads.hasFiles) {
+      this.requiredFiles.check()
+      return true
+    }
+    this.requiredFiles.uncheck()
+    return false
+  }
+
+  validateAgreement(filesValid) {
+    if (filesValid && this.uploads.hasNewFiles && this.depositAgreement.mustAgreeAgain) {
+      // Force the user to agree again
+      this.depositAgreement.setNotAccepted()
+      return false
+    }
+    return this.depositAgreement.isAccepted
+  }
+}
+

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

@@ -0,0 +1,23 @@
+export class UploadedFiles {
+  // Monitors the form and runs the callback if any files are added
+  constructor(form, callback) {
+    this.form = form
+    $('#fileupload').bind('fileuploadstop', callback)
+  }
+
+  get hasFileRequirement() {
+    let fileRequirement = this.form.find('li#required-files')
+    return fileRequirement.size() > 0
+  }
+
+  get hasFiles() {
+    let fileField = this.form.find('input[name="uploaded_files[]"]')
+    return fileField.size() > 0
+  }
+
+  get hasNewFiles() {
+    // In a future release hasFiles will include files already on the work plus new files,
+    // but hasNewFiles() will include only the files added in this browser window.
+    return this.hasFiles
+  }
+}

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

@@ -0,0 +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.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) {
+      // 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] + "']"
+    }
+    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()
+  }
+}