");
+ $('#success > .alert-danger').html("");
+ $('#success > .alert-danger').append($("").text("Sorry " + firstName + ", it seems that my mail server is not responding. Please try again later!"));
+ $('#success > .alert-danger').append('
');
+ //clear all fields
+ $('#contactForm').trigger("reset");
+ },
+ complete: function() {
+ setTimeout(function() {
+ $this.prop("disabled", false); // Re-enable submit button when AJAX call is complete
+ }, 1000);
+ }
+ });
+ },
+ filter: function() {
+ return $(this).is(":visible");
+ },
+ });
+
+ $("a[data-toggle=\"tab\"]").click(function(e) {
+ e.preventDefault();
+ $(this).tab("show");
+ });
+});
+
+/*When clicking on Full hide fail/success boxes */
+$('#name').focus(function() {
+ $('#success').html('');
+});
diff --git a/app/assets/javascripts/jqBootstrapValidation.js b/app/assets/javascripts/jqBootstrapValidation.js
new file mode 100644
index 0000000..6f05a2d
--- /dev/null
+++ b/app/assets/javascripts/jqBootstrapValidation.js
@@ -0,0 +1,937 @@
+/* jqBootstrapValidation
+ * A plugin for automating validation on Twitter Bootstrap formatted forms.
+ *
+ * v1.3.6
+ *
+ * License: MIT - see LICENSE file
+ *
+ * http://ReactiveRaven.github.com/jqBootstrapValidation/
+ */
+
+(function($) {
+
+ var createdElements = [];
+
+ var defaults = {
+ options: {
+ prependExistingHelpBlock: false,
+ sniffHtml: true, // sniff for 'required', 'maxlength', etc
+ preventSubmit: true, // stop the form submit event from firing if validation fails
+ submitError: false, // function called if there is an error when trying to submit
+ submitSuccess: false, // function called just before a successful submit event is sent to the server
+ semanticallyStrict: false, // set to true to tidy up generated HTML output
+ autoAdd: {
+ helpBlocks: true
+ },
+ filter: function() {
+ // return $(this).is(":visible"); // only validate elements you can see
+ return true; // validate everything
+ }
+ },
+ methods: {
+ init: function(options) {
+
+ var settings = $.extend(true, {}, defaults);
+
+ settings.options = $.extend(true, settings.options, options);
+
+ var $siblingElements = this;
+
+ var uniqueForms = $.unique(
+ $siblingElements.map(function() {
+ return $(this).parents("form")[0];
+ }).toArray()
+ );
+
+ $(uniqueForms).bind("submit", function(e) {
+ var $form = $(this);
+ var warningsFound = 0;
+ var $inputs = $form.find("input,textarea,select").not("[type=submit],[type=image]").filter(settings.options.filter);
+ $inputs.trigger("submit.validation").trigger("validationLostFocus.validation");
+
+ $inputs.each(function(i, el) {
+ var $this = $(el),
+ $controlGroup = $this.parents(".form-group").first();
+ if (
+ $controlGroup.hasClass("warning")
+ ) {
+ $controlGroup.removeClass("warning").addClass("error");
+ warningsFound++;
+ }
+ });
+
+ $inputs.trigger("validationLostFocus.validation");
+
+ if (warningsFound) {
+ if (settings.options.preventSubmit) {
+ e.preventDefault();
+ }
+ $form.addClass("error");
+ if ($.isFunction(settings.options.submitError)) {
+ settings.options.submitError($form, e, $inputs.jqBootstrapValidation("collectErrors", true));
+ }
+ } else {
+ $form.removeClass("error");
+ if ($.isFunction(settings.options.submitSuccess)) {
+ settings.options.submitSuccess($form, e);
+ }
+ }
+ });
+
+ return this.each(function() {
+
+ // Get references to everything we're interested in
+ var $this = $(this),
+ $controlGroup = $this.parents(".form-group").first(),
+ $helpBlock = $controlGroup.find(".help-block").first(),
+ $form = $this.parents("form").first(),
+ validatorNames = [];
+
+ // create message container if not exists
+ if (!$helpBlock.length && settings.options.autoAdd && settings.options.autoAdd.helpBlocks) {
+ $helpBlock = $('');
+ $controlGroup.find('.controls').append($helpBlock);
+ createdElements.push($helpBlock[0]);
+ }
+
+ // =============================================================
+ // SNIFF HTML FOR VALIDATORS
+ // =============================================================
+
+ // *snort sniff snuffle*
+
+ if (settings.options.sniffHtml) {
+ var message = "";
+ // ---------------------------------------------------------
+ // PATTERN
+ // ---------------------------------------------------------
+ if ($this.attr("pattern") !== undefined) {
+ message = "Not in the expected format";
+ if ($this.data("validationPatternMessage")) {
+ message = $this.data("validationPatternMessage");
+ }
+ $this.data("validationPatternMessage", message);
+ $this.data("validationPatternRegex", $this.attr("pattern"));
+ }
+ // ---------------------------------------------------------
+ // MAX
+ // ---------------------------------------------------------
+ if ($this.attr("max") !== undefined || $this.attr("aria-valuemax") !== undefined) {
+ var max = ($this.attr("max") !== undefined ? $this.attr("max") : $this.attr("aria-valuemax"));
+ message = "Too high: Maximum of '" + max + "'";
+ if ($this.data("validationMaxMessage")) {
+ message = $this.data("validationMaxMessage");
+ }
+ $this.data("validationMaxMessage", message);
+ $this.data("validationMaxMax", max);
+ }
+ // ---------------------------------------------------------
+ // MIN
+ // ---------------------------------------------------------
+ if ($this.attr("min") !== undefined || $this.attr("aria-valuemin") !== undefined) {
+ var min = ($this.attr("min") !== undefined ? $this.attr("min") : $this.attr("aria-valuemin"));
+ message = "Too low: Minimum of '" + min + "'";
+ if ($this.data("validationMinMessage")) {
+ message = $this.data("validationMinMessage");
+ }
+ $this.data("validationMinMessage", message);
+ $this.data("validationMinMin", min);
+ }
+ // ---------------------------------------------------------
+ // MAXLENGTH
+ // ---------------------------------------------------------
+ if ($this.attr("maxlength") !== undefined) {
+ message = "Too long: Maximum of '" + $this.attr("maxlength") + "' characters";
+ if ($this.data("validationMaxlengthMessage")) {
+ message = $this.data("validationMaxlengthMessage");
+ }
+ $this.data("validationMaxlengthMessage", message);
+ $this.data("validationMaxlengthMaxlength", $this.attr("maxlength"));
+ }
+ // ---------------------------------------------------------
+ // MINLENGTH
+ // ---------------------------------------------------------
+ if ($this.attr("minlength") !== undefined) {
+ message = "Too short: Minimum of '" + $this.attr("minlength") + "' characters";
+ if ($this.data("validationMinlengthMessage")) {
+ message = $this.data("validationMinlengthMessage");
+ }
+ $this.data("validationMinlengthMessage", message);
+ $this.data("validationMinlengthMinlength", $this.attr("minlength"));
+ }
+ // ---------------------------------------------------------
+ // REQUIRED
+ // ---------------------------------------------------------
+ if ($this.attr("required") !== undefined || $this.attr("aria-required") !== undefined) {
+ message = settings.builtInValidators.required.message;
+ if ($this.data("validationRequiredMessage")) {
+ message = $this.data("validationRequiredMessage");
+ }
+ $this.data("validationRequiredMessage", message);
+ }
+ // ---------------------------------------------------------
+ // NUMBER
+ // ---------------------------------------------------------
+ if ($this.attr("type") !== undefined && $this.attr("type").toLowerCase() === "number") {
+ message = settings.builtInValidators.number.message;
+ if ($this.data("validationNumberMessage")) {
+ message = $this.data("validationNumberMessage");
+ }
+ $this.data("validationNumberMessage", message);
+ }
+ // ---------------------------------------------------------
+ // EMAIL
+ // ---------------------------------------------------------
+ if ($this.attr("type") !== undefined && $this.attr("type").toLowerCase() === "email") {
+ message = "Not a valid email address";
+ if ($this.data("validationValidemailMessage")) {
+ message = $this.data("validationValidemailMessage");
+ } else if ($this.data("validationEmailMessage")) {
+ message = $this.data("validationEmailMessage");
+ }
+ $this.data("validationValidemailMessage", message);
+ }
+ // ---------------------------------------------------------
+ // MINCHECKED
+ // ---------------------------------------------------------
+ if ($this.attr("minchecked") !== undefined) {
+ message = "Not enough options checked; Minimum of '" + $this.attr("minchecked") + "' required";
+ if ($this.data("validationMincheckedMessage")) {
+ message = $this.data("validationMincheckedMessage");
+ }
+ $this.data("validationMincheckedMessage", message);
+ $this.data("validationMincheckedMinchecked", $this.attr("minchecked"));
+ }
+ // ---------------------------------------------------------
+ // MAXCHECKED
+ // ---------------------------------------------------------
+ if ($this.attr("maxchecked") !== undefined) {
+ message = "Too many options checked; Maximum of '" + $this.attr("maxchecked") + "' required";
+ if ($this.data("validationMaxcheckedMessage")) {
+ message = $this.data("validationMaxcheckedMessage");
+ }
+ $this.data("validationMaxcheckedMessage", message);
+ $this.data("validationMaxcheckedMaxchecked", $this.attr("maxchecked"));
+ }
+ }
+
+ // =============================================================
+ // COLLECT VALIDATOR NAMES
+ // =============================================================
+
+ // Get named validators
+ if ($this.data("validation") !== undefined) {
+ validatorNames = $this.data("validation").split(",");
+ }
+
+ // Get extra ones defined on the element's data attributes
+ $.each($this.data(), function(i, el) {
+ var parts = i.replace(/([A-Z])/g, ",$1").split(",");
+ if (parts[0] === "validation" && parts[1]) {
+ validatorNames.push(parts[1]);
+ }
+ });
+
+ // =============================================================
+ // NORMALISE VALIDATOR NAMES
+ // =============================================================
+
+ var validatorNamesToInspect = validatorNames;
+ var newValidatorNamesToInspect = [];
+
+ do // repeatedly expand 'shortcut' validators into their real validators
+ {
+ // Uppercase only the first letter of each name
+ $.each(validatorNames, function(i, el) {
+ validatorNames[i] = formatValidatorName(el);
+ });
+
+ // Remove duplicate validator names
+ validatorNames = $.unique(validatorNames);
+
+ // Pull out the new validator names from each shortcut
+ newValidatorNamesToInspect = [];
+ $.each(validatorNamesToInspect, function(i, el) {
+ if ($this.data("validation" + el + "Shortcut") !== undefined) {
+ // Are these custom validators?
+ // Pull them out!
+ $.each($this.data("validation" + el + "Shortcut").split(","), function(i2, el2) {
+ newValidatorNamesToInspect.push(el2);
+ });
+ } else if (settings.builtInValidators[el.toLowerCase()]) {
+ // Is this a recognised built-in?
+ // Pull it out!
+ var validator = settings.builtInValidators[el.toLowerCase()];
+ if (validator.type.toLowerCase() === "shortcut") {
+ $.each(validator.shortcut.split(","), function(i, el) {
+ el = formatValidatorName(el);
+ newValidatorNamesToInspect.push(el);
+ validatorNames.push(el);
+ });
+ }
+ }
+ });
+
+ validatorNamesToInspect = newValidatorNamesToInspect;
+
+ } while (validatorNamesToInspect.length > 0)
+
+ // =============================================================
+ // SET UP VALIDATOR ARRAYS
+ // =============================================================
+
+ var validators = {};
+
+ $.each(validatorNames, function(i, el) {
+ // Set up the 'override' message
+ var message = $this.data("validation" + el + "Message");
+ var hasOverrideMessage = (message !== undefined);
+ var foundValidator = false;
+ message =
+ (
+ message ?
+ message :
+ "'" + el + "' validation failed "
+ );
+
+ $.each(
+ settings.validatorTypes,
+ function(validatorType, validatorTemplate) {
+ if (validators[validatorType] === undefined) {
+ validators[validatorType] = [];
+ }
+ if (!foundValidator && $this.data("validation" + el + formatValidatorName(validatorTemplate.name)) !== undefined) {
+ validators[validatorType].push(
+ $.extend(
+ true, {
+ name: formatValidatorName(validatorTemplate.name),
+ message: message
+ },
+ validatorTemplate.init($this, el)
+ )
+ );
+ foundValidator = true;
+ }
+ }
+ );
+
+ if (!foundValidator && settings.builtInValidators[el.toLowerCase()]) {
+
+ var validator = $.extend(true, {}, settings.builtInValidators[el.toLowerCase()]);
+ if (hasOverrideMessage) {
+ validator.message = message;
+ }
+ var validatorType = validator.type.toLowerCase();
+
+ if (validatorType === "shortcut") {
+ foundValidator = true;
+ } else {
+ $.each(
+ settings.validatorTypes,
+ function(validatorTemplateType, validatorTemplate) {
+ if (validators[validatorTemplateType] === undefined) {
+ validators[validatorTemplateType] = [];
+ }
+ if (!foundValidator && validatorType === validatorTemplateType.toLowerCase()) {
+ $this.data("validation" + el + formatValidatorName(validatorTemplate.name), validator[validatorTemplate.name.toLowerCase()]);
+ validators[validatorType].push(
+ $.extend(
+ validator,
+ validatorTemplate.init($this, el)
+ )
+ );
+ foundValidator = true;
+ }
+ }
+ );
+ }
+ }
+
+ if (!foundValidator) {
+ $.error("Cannot find validation info for '" + el + "'");
+ }
+ });
+
+ // =============================================================
+ // STORE FALLBACK VALUES
+ // =============================================================
+
+ $helpBlock.data(
+ "original-contents",
+ (
+ $helpBlock.data("original-contents") ?
+ $helpBlock.data("original-contents") :
+ $helpBlock.html()
+ )
+ );
+
+ $helpBlock.data(
+ "original-role",
+ (
+ $helpBlock.data("original-role") ?
+ $helpBlock.data("original-role") :
+ $helpBlock.attr("role")
+ )
+ );
+
+ $controlGroup.data(
+ "original-classes",
+ (
+ $controlGroup.data("original-clases") ?
+ $controlGroup.data("original-classes") :
+ $controlGroup.attr("class")
+ )
+ );
+
+ $this.data(
+ "original-aria-invalid",
+ (
+ $this.data("original-aria-invalid") ?
+ $this.data("original-aria-invalid") :
+ $this.attr("aria-invalid")
+ )
+ );
+
+ // =============================================================
+ // VALIDATION
+ // =============================================================
+
+ $this.bind(
+ "validation.validation",
+ function(event, params) {
+
+ var value = getValue($this);
+
+ // Get a list of the errors to apply
+ var errorsFound = [];
+
+ $.each(validators, function(validatorType, validatorTypeArray) {
+ if (value || value.length || (params && params.includeEmpty) || (!!settings.validatorTypes[validatorType].blockSubmit && params && !!params.submitting)) {
+ $.each(validatorTypeArray, function(i, validator) {
+ if (settings.validatorTypes[validatorType].validate($this, value, validator)) {
+ errorsFound.push(validator.message);
+ }
+ });
+ }
+ });
+
+ return errorsFound;
+ }
+ );
+
+ $this.bind(
+ "getValidators.validation",
+ function() {
+ return validators;
+ }
+ );
+
+ // =============================================================
+ // WATCH FOR CHANGES
+ // =============================================================
+ $this.bind(
+ "submit.validation",
+ function() {
+ return $this.triggerHandler("change.validation", {
+ submitting: true
+ });
+ }
+ );
+ $this.bind(
+ [
+ "keyup",
+ "focus",
+ "blur",
+ "click",
+ "keydown",
+ "keypress",
+ "change"
+ ].join(".validation ") + ".validation",
+ function(e, params) {
+
+ var value = getValue($this);
+
+ var errorsFound = [];
+
+ $controlGroup.find("input,textarea,select").each(function(i, el) {
+ var oldCount = errorsFound.length;
+ $.each($(el).triggerHandler("validation.validation", params), function(j, message) {
+ errorsFound.push(message);
+ });
+ if (errorsFound.length > oldCount) {
+ $(el).attr("aria-invalid", "true");
+ } else {
+ var original = $this.data("original-aria-invalid");
+ $(el).attr("aria-invalid", (original !== undefined ? original : false));
+ }
+ });
+
+ $form.find("input,select,textarea").not($this).not("[name=\"" + $this.attr("name") + "\"]").trigger("validationLostFocus.validation");
+
+ errorsFound = $.unique(errorsFound.sort());
+
+ // Were there any errors?
+ if (errorsFound.length) {
+ // Better flag it up as a warning.
+ $controlGroup.removeClass("success error").addClass("warning");
+
+ // How many errors did we find?
+ if (settings.options.semanticallyStrict && errorsFound.length === 1) {
+ // Only one? Being strict? Just output it.
+ $helpBlock.html(errorsFound[0] +
+ (settings.options.prependExistingHelpBlock ? $helpBlock.data("original-contents") : ""));
+ } else {
+ // Multiple? Being sloppy? Glue them together into an UL.
+ $helpBlock.html("
" + errorsFound.join("
") + "
" +
+ (settings.options.prependExistingHelpBlock ? $helpBlock.data("original-contents") : ""));
+ }
+ } else {
+ $controlGroup.removeClass("warning error success");
+ if (value.length > 0) {
+ $controlGroup.addClass("success");
+ }
+ $helpBlock.html($helpBlock.data("original-contents"));
+ }
+
+ if (e.type === "blur") {
+ $controlGroup.removeClass("success");
+ }
+ }
+ );
+ $this.bind("validationLostFocus.validation", function() {
+ $controlGroup.removeClass("success");
+ });
+ });
+ },
+ destroy: function() {
+
+ return this.each(
+ function() {
+
+ var
+ $this = $(this),
+ $controlGroup = $this.parents(".form-group").first(),
+ $helpBlock = $controlGroup.find(".help-block").first();
+
+ // remove our events
+ $this.unbind('.validation'); // events are namespaced.
+ // reset help text
+ $helpBlock.html($helpBlock.data("original-contents"));
+ // reset classes
+ $controlGroup.attr("class", $controlGroup.data("original-classes"));
+ // reset aria
+ $this.attr("aria-invalid", $this.data("original-aria-invalid"));
+ // reset role
+ $helpBlock.attr("role", $this.data("original-role"));
+ // remove all elements we created
+ if (createdElements.indexOf($helpBlock[0]) > -1) {
+ $helpBlock.remove();
+ }
+
+ }
+ );
+
+ },
+ collectErrors: function(includeEmpty) {
+
+ var errorMessages = {};
+ this.each(function(i, el) {
+ var $el = $(el);
+ var name = $el.attr("name");
+ var errors = $el.triggerHandler("validation.validation", {
+ includeEmpty: true
+ });
+ errorMessages[name] = $.extend(true, errors, errorMessages[name]);
+ });
+
+ $.each(errorMessages, function(i, el) {
+ if (el.length === 0) {
+ delete errorMessages[i];
+ }
+ });
+
+ return errorMessages;
+
+ },
+ hasErrors: function() {
+
+ var errorMessages = [];
+
+ this.each(function(i, el) {
+ errorMessages = errorMessages.concat(
+ $(el).triggerHandler("getValidators.validation") ? $(el).triggerHandler("validation.validation", {
+ submitting: true
+ }) : []
+ );
+ });
+
+ return (errorMessages.length > 0);
+ },
+ override: function(newDefaults) {
+ defaults = $.extend(true, defaults, newDefaults);
+ }
+ },
+ validatorTypes: {
+ callback: {
+ name: "callback",
+ init: function($this, name) {
+ return {
+ validatorName: name,
+ callback: $this.data("validation" + name + "Callback"),
+ lastValue: $this.val(),
+ lastValid: true,
+ lastFinished: true
+ };
+ },
+ validate: function($this, value, validator) {
+ if (validator.lastValue === value && validator.lastFinished) {
+ return !validator.lastValid;
+ }
+
+ if (validator.lastFinished === true) {
+ validator.lastValue = value;
+ validator.lastValid = true;
+ validator.lastFinished = false;
+
+ var rrjqbvValidator = validator;
+ var rrjqbvThis = $this;
+ executeFunctionByName(
+ validator.callback,
+ window,
+ $this,
+ value,
+ function(data) {
+ if (rrjqbvValidator.lastValue === data.value) {
+ rrjqbvValidator.lastValid = data.valid;
+ if (data.message) {
+ rrjqbvValidator.message = data.message;
+ }
+ rrjqbvValidator.lastFinished = true;
+ rrjqbvThis.data("validation" + rrjqbvValidator.validatorName + "Message", rrjqbvValidator.message);
+ // Timeout is set to avoid problems with the events being considered 'already fired'
+ setTimeout(function() {
+ rrjqbvThis.trigger("change.validation");
+ }, 1); // doesn't need a long timeout, just long enough for the event bubble to burst
+ }
+ }
+ );
+ }
+
+ return false;
+
+ }
+ },
+ ajax: {
+ name: "ajax",
+ init: function($this, name) {
+ return {
+ validatorName: name,
+ url: $this.data("validation" + name + "Ajax"),
+ lastValue: $this.val(),
+ lastValid: true,
+ lastFinished: true
+ };
+ },
+ validate: function($this, value, validator) {
+ if ("" + validator.lastValue === "" + value && validator.lastFinished === true) {
+ return validator.lastValid === false;
+ }
+
+ if (validator.lastFinished === true) {
+ validator.lastValue = value;
+ validator.lastValid = true;
+ validator.lastFinished = false;
+ $.ajax({
+ url: validator.url,
+ data: "value=" + value + "&field=" + $this.attr("name"),
+ dataType: "json",
+ success: function(data) {
+ if ("" + validator.lastValue === "" + data.value) {
+ validator.lastValid = !!(data.valid);
+ if (data.message) {
+ validator.message = data.message;
+ }
+ validator.lastFinished = true;
+ $this.data("validation" + validator.validatorName + "Message", validator.message);
+ // Timeout is set to avoid problems with the events being considered 'already fired'
+ setTimeout(function() {
+ $this.trigger("change.validation");
+ }, 1); // doesn't need a long timeout, just long enough for the event bubble to burst
+ }
+ },
+ failure: function() {
+ validator.lastValid = true;
+ validator.message = "ajax call failed";
+ validator.lastFinished = true;
+ $this.data("validation" + validator.validatorName + "Message", validator.message);
+ // Timeout is set to avoid problems with the events being considered 'already fired'
+ setTimeout(function() {
+ $this.trigger("change.validation");
+ }, 1); // doesn't need a long timeout, just long enough for the event bubble to burst
+ }
+ });
+ }
+
+ return false;
+
+ }
+ },
+ regex: {
+ name: "regex",
+ init: function($this, name) {
+ return {
+ regex: regexFromString($this.data("validation" + name + "Regex"))
+ };
+ },
+ validate: function($this, value, validator) {
+ return (!validator.regex.test(value) && !validator.negative) ||
+ (validator.regex.test(value) && validator.negative);
+ }
+ },
+ required: {
+ name: "required",
+ init: function($this, name) {
+ return {};
+ },
+ validate: function($this, value, validator) {
+ return !!(value.length === 0 && !validator.negative) ||
+ !!(value.length > 0 && validator.negative);
+ },
+ blockSubmit: true
+ },
+ match: {
+ name: "match",
+ init: function($this, name) {
+ var element = $this.parents("form").first().find("[name=\"" + $this.data("validation" + name + "Match") + "\"]").first();
+ element.bind("validation.validation", function() {
+ $this.trigger("change.validation", {
+ submitting: true
+ });
+ });
+ return {
+ "element": element
+ };
+ },
+ validate: function($this, value, validator) {
+ return (value !== validator.element.val() && !validator.negative) ||
+ (value === validator.element.val() && validator.negative);
+ },
+ blockSubmit: true
+ },
+ max: {
+ name: "max",
+ init: function($this, name) {
+ return {
+ max: $this.data("validation" + name + "Max")
+ };
+ },
+ validate: function($this, value, validator) {
+ return (parseFloat(value, 10) > parseFloat(validator.max, 10) && !validator.negative) ||
+ (parseFloat(value, 10) <= parseFloat(validator.max, 10) && validator.negative);
+ }
+ },
+ min: {
+ name: "min",
+ init: function($this, name) {
+ return {
+ min: $this.data("validation" + name + "Min")
+ };
+ },
+ validate: function($this, value, validator) {
+ return (parseFloat(value) < parseFloat(validator.min) && !validator.negative) ||
+ (parseFloat(value) >= parseFloat(validator.min) && validator.negative);
+ }
+ },
+ maxlength: {
+ name: "maxlength",
+ init: function($this, name) {
+ return {
+ maxlength: $this.data("validation" + name + "Maxlength")
+ };
+ },
+ validate: function($this, value, validator) {
+ return ((value.length > validator.maxlength) && !validator.negative) ||
+ ((value.length <= validator.maxlength) && validator.negative);
+ }
+ },
+ minlength: {
+ name: "minlength",
+ init: function($this, name) {
+ return {
+ minlength: $this.data("validation" + name + "Minlength")
+ };
+ },
+ validate: function($this, value, validator) {
+ return ((value.length < validator.minlength) && !validator.negative) ||
+ ((value.length >= validator.minlength) && validator.negative);
+ }
+ },
+ maxchecked: {
+ name: "maxchecked",
+ init: function($this, name) {
+ var elements = $this.parents("form").first().find("[name=\"" + $this.attr("name") + "\"]");
+ elements.bind("click.validation", function() {
+ $this.trigger("change.validation", {
+ includeEmpty: true
+ });
+ });
+ return {
+ maxchecked: $this.data("validation" + name + "Maxchecked"),
+ elements: elements
+ };
+ },
+ validate: function($this, value, validator) {
+ return (validator.elements.filter(":checked").length > validator.maxchecked && !validator.negative) ||
+ (validator.elements.filter(":checked").length <= validator.maxchecked && validator.negative);
+ },
+ blockSubmit: true
+ },
+ minchecked: {
+ name: "minchecked",
+ init: function($this, name) {
+ var elements = $this.parents("form").first().find("[name=\"" + $this.attr("name") + "\"]");
+ elements.bind("click.validation", function() {
+ $this.trigger("change.validation", {
+ includeEmpty: true
+ });
+ });
+ return {
+ minchecked: $this.data("validation" + name + "Minchecked"),
+ elements: elements
+ };
+ },
+ validate: function($this, value, validator) {
+ return (validator.elements.filter(":checked").length < validator.minchecked && !validator.negative) ||
+ (validator.elements.filter(":checked").length >= validator.minchecked && validator.negative);
+ },
+ blockSubmit: true
+ }
+ },
+ builtInValidators: {
+ email: {
+ name: "Email",
+ type: "shortcut",
+ shortcut: "validemail"
+ },
+ validemail: {
+ name: "Validemail",
+ type: "regex",
+ regex: "[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\\.[A-Za-z]{2,4}",
+ message: "Not a valid email address"
+ },
+ passwordagain: {
+ name: "Passwordagain",
+ type: "match",
+ match: "password",
+ message: "Does not match the given password"
+ },
+ positive: {
+ name: "Positive",
+ type: "shortcut",
+ shortcut: "number,positivenumber"
+ },
+ negative: {
+ name: "Negative",
+ type: "shortcut",
+ shortcut: "number,negativenumber"
+ },
+ number: {
+ name: "Number",
+ type: "regex",
+ regex: "([+-]?\\\d+(\\\.\\\d*)?([eE][+-]?[0-9]+)?)?",
+ message: "Must be a number"
+ },
+ integer: {
+ name: "Integer",
+ type: "regex",
+ regex: "[+-]?\\\d+",
+ message: "No decimal places allowed"
+ },
+ positivenumber: {
+ name: "Positivenumber",
+ type: "min",
+ min: 0,
+ message: "Must be a positive number"
+ },
+ negativenumber: {
+ name: "Negativenumber",
+ type: "max",
+ max: 0,
+ message: "Must be a negative number"
+ },
+ required: {
+ name: "Required",
+ type: "required",
+ message: "This is required"
+ },
+ checkone: {
+ name: "Checkone",
+ type: "minchecked",
+ minchecked: 1,
+ message: "Check at least one option"
+ }
+ }
+ };
+
+ var formatValidatorName = function(name) {
+ return name
+ .toLowerCase()
+ .replace(
+ /(^|\s)([a-z])/g,
+ function(m, p1, p2) {
+ return p1 + p2.toUpperCase();
+ }
+ );
+ };
+
+ var getValue = function($this) {
+ // Extract the value we're talking about
+ var value = $this.val();
+ var type = $this.attr("type");
+ if (type === "checkbox") {
+ value = ($this.is(":checked") ? value : "");
+ }
+ if (type === "radio") {
+ value = ($('input[name="' + $this.attr("name") + '"]:checked').length > 0 ? value : "");
+ }
+ return value;
+ };
+
+ function regexFromString(inputstring) {
+ return new RegExp("^" + inputstring + "$");
+ }
+
+ /**
+ * Thanks to Jason Bunting via StackOverflow.com
+ *
+ * http://stackoverflow.com/questions/359788/how-to-execute-a-javascript-function-when-i-have-its-name-as-a-string#answer-359910
+ * Short link: http://tinyurl.com/executeFunctionByName
+ **/
+ function executeFunctionByName(functionName, context /*, args*/ ) {
+ var args = Array.prototype.slice.call(arguments).splice(2);
+ var namespaces = functionName.split(".");
+ var func = namespaces.pop();
+ for (var i = 0; i < namespaces.length; i++) {
+ context = context[namespaces[i]];
+ }
+ return context[func].apply(this, args);
+ }
+
+ $.fn.jqBootstrapValidation = function(method) {
+
+ if (defaults.methods[method]) {
+ return defaults.methods[method].apply(this, Array.prototype.slice.call(arguments, 1));
+ } else if (typeof method === 'object' || !method) {
+ return defaults.methods.init.apply(this, arguments);
+ } else {
+ $.error('Method ' + method + ' does not exist on jQuery.jqBootstrapValidation');
+ return null;
+ }
+
+ };
+
+ $.jqBootstrapValidation = function(options) {
+ $(":input").not("[type=image],[type=submit]").jqBootstrapValidation.apply(this, arguments);
+ };
+
+})(jQuery);
diff --git a/app/assets/javascripts/jquery-sortable.js b/app/assets/javascripts/jquery-sortable.js
new file mode 100644
index 0000000..376880c
--- /dev/null
+++ b/app/assets/javascripts/jquery-sortable.js
@@ -0,0 +1,693 @@
+/* ===================================================
+ * jquery-sortable.js v0.9.13
+ * http://johnny.github.com/jquery-sortable/
+ * ===================================================
+ * Copyright (c) 2012 Jonas von Andrian
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * * The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ========================================================== */
+
+
+!function ( $, window, pluginName, undefined){
+ var containerDefaults = {
+ // If true, items can be dragged from this container
+ drag: true,
+ // If true, items can be droped onto this container
+ drop: true,
+ // Exclude items from being draggable, if the
+ // selector matches the item
+ exclude: "",
+ // If true, search for nested containers within an item.If you nest containers,
+ // either the original selector with which you call the plugin must only match the top containers,
+ // or you need to specify a group (see the bootstrap nav example)
+ nested: true,
+ // If true, the items are assumed to be arranged vertically
+ vertical: true
+ }, // end container defaults
+ groupDefaults = {
+ // This is executed after the placeholder has been moved.
+ // $closestItemOrContainer contains the closest item, the placeholder
+ // has been put at or the closest empty Container, the placeholder has
+ // been appended to.
+ afterMove: function ($placeholder, container, $closestItemOrContainer) {
+ },
+ // The exact css path between the container and its items, e.g. "> tbody"
+ containerPath: "",
+ // The css selector of the containers
+ containerSelector: "ol, ul",
+ // Distance the mouse has to travel to start dragging
+ distance: 0,
+ // Time in milliseconds after mousedown until dragging should start.
+ // This option can be used to prevent unwanted drags when clicking on an element.
+ delay: 0,
+ // The css selector of the drag handle
+ handle: "",
+ // The exact css path between the item and its subcontainers.
+ // It should only match the immediate items of a container.
+ // No item of a subcontainer should be matched. E.g. for ol>div>li the itemPath is "> div"
+ itemPath: "",
+ // The css selector of the items
+ itemSelector: "li",
+ // The class given to "body" while an item is being dragged
+ bodyClass: "dragging",
+ // The class giving to an item while being dragged
+ draggedClass: "dragged",
+ // Check if the dragged item may be inside the container.
+ // Use with care, since the search for a valid container entails a depth first search
+ // and may be quite expensive.
+ isValidTarget: function ($item, container) {
+ return true
+ },
+ // Executed before onDrop if placeholder is detached.
+ // This happens if pullPlaceholder is set to false and the drop occurs outside a container.
+ onCancel: function ($item, container, _super, event) {
+ },
+ // Executed at the beginning of a mouse move event.
+ // The Placeholder has not been moved yet.
+ onDrag: function ($item, position, _super, event) {
+ $item.css(position)
+ },
+ // Called after the drag has been started,
+ // that is the mouse button is being held down and
+ // the mouse is moving.
+ // The container is the closest initialized container.
+ // Therefore it might not be the container, that actually contains the item.
+ onDragStart: function ($item, container, _super, event) {
+ $item.css({
+ height: $item.outerHeight(),
+ width: $item.outerWidth()
+ })
+ $item.addClass(container.group.options.draggedClass)
+ $("body").addClass(container.group.options.bodyClass)
+ },
+ // Called when the mouse button is being released
+ onDrop: function ($item, container, _super, event) {
+ $item.removeClass(container.group.options.draggedClass).removeAttr("style")
+ $("body").removeClass(container.group.options.bodyClass)
+ },
+ // Called on mousedown. If falsy value is returned, the dragging will not start.
+ // Ignore if element clicked is input, select or textarea
+ onMousedown: function ($item, _super, event) {
+ if (!event.target.nodeName.match(/^(input|select|textarea)$/i)) {
+ event.preventDefault()
+ return true
+ }
+ },
+ // The class of the placeholder (must match placeholder option markup)
+ placeholderClass: "placeholder",
+ // Template for the placeholder. Can be any valid jQuery input
+ // e.g. a string, a DOM element.
+ // The placeholder must have the class "placeholder"
+ placeholder: '',
+ // If true, the position of the placeholder is calculated on every mousemove.
+ // If false, it is only calculated when the mouse is above a container.
+ pullPlaceholder: true,
+ // Specifies serialization of the container group.
+ // The pair $parent/$children is either container/items or item/subcontainers.
+ serialize: function ($parent, $children, parentIsContainer) {
+ var result = $.extend({}, $parent.data())
+
+ if(parentIsContainer)
+ return [$children]
+ else if ($children[0]){
+ result.children = $children
+ }
+
+ delete result.subContainers
+ delete result.sortable
+
+ return result
+ },
+ // Set tolerance while dragging. Positive values decrease sensitivity,
+ // negative values increase it.
+ tolerance: 0
+ }, // end group defaults
+ containerGroups = {},
+ groupCounter = 0,
+ emptyBox = {
+ left: 0,
+ top: 0,
+ bottom: 0,
+ right:0
+ },
+ eventNames = {
+ start: "touchstart.sortable mousedown.sortable",
+ drop: "touchend.sortable touchcancel.sortable mouseup.sortable",
+ drag: "touchmove.sortable mousemove.sortable",
+ scroll: "scroll.sortable"
+ },
+ subContainerKey = "subContainers"
+
+ /*
+ * a is Array [left, right, top, bottom]
+ * b is array [left, top]
+ */
+ function d(a,b) {
+ var x = Math.max(0, a[0] - b[0], b[0] - a[1]),
+ y = Math.max(0, a[2] - b[1], b[1] - a[3])
+ return x+y;
+ }
+
+ function setDimensions(array, dimensions, tolerance, useOffset) {
+ var i = array.length,
+ offsetMethod = useOffset ? "offset" : "position"
+ tolerance = tolerance || 0
+
+ while(i--){
+ var el = array[i].el ? array[i].el : $(array[i]),
+ // use fitting method
+ pos = el[offsetMethod]()
+ pos.left += parseInt(el.css('margin-left'), 10)
+ pos.top += parseInt(el.css('margin-top'),10)
+ dimensions[i] = [
+ pos.left - tolerance,
+ pos.left + el.outerWidth() + tolerance,
+ pos.top - tolerance,
+ pos.top + el.outerHeight() + tolerance
+ ]
+ }
+ }
+
+ function getRelativePosition(pointer, element) {
+ var offset = element.offset()
+ return {
+ left: pointer.left - offset.left,
+ top: pointer.top - offset.top
+ }
+ }
+
+ function sortByDistanceDesc(dimensions, pointer, lastPointer) {
+ pointer = [pointer.left, pointer.top]
+ lastPointer = lastPointer && [lastPointer.left, lastPointer.top]
+
+ var dim,
+ i = dimensions.length,
+ distances = []
+
+ while(i--){
+ dim = dimensions[i]
+ distances[i] = [i,d(dim,pointer), lastPointer && d(dim, lastPointer)]
+ }
+ distances = distances.sort(function (a,b) {
+ return b[1] - a[1] || b[2] - a[2] || b[0] - a[0]
+ })
+
+ // last entry is the closest
+ return distances
+ }
+
+ function ContainerGroup(options) {
+ this.options = $.extend({}, groupDefaults, options)
+ this.containers = []
+
+ if(!this.options.rootGroup){
+ this.scrollProxy = $.proxy(this.scroll, this)
+ this.dragProxy = $.proxy(this.drag, this)
+ this.dropProxy = $.proxy(this.drop, this)
+ this.placeholder = $(this.options.placeholder)
+
+ if(!options.isValidTarget)
+ this.options.isValidTarget = undefined
+ }
+ }
+
+ ContainerGroup.get = function (options) {
+ if(!containerGroups[options.group]) {
+ if(options.group === undefined)
+ options.group = groupCounter ++
+
+ containerGroups[options.group] = new ContainerGroup(options)
+ }
+
+ return containerGroups[options.group]
+ }
+
+ ContainerGroup.prototype = {
+ dragInit: function (e, itemContainer) {
+ this.$document = $(itemContainer.el[0].ownerDocument)
+
+ // get item to drag
+ var closestItem = $(e.target).closest(this.options.itemSelector);
+ // using the length of this item, prevents the plugin from being started if there is no handle being clicked on.
+ // this may also be helpful in instantiating multidrag.
+ if (closestItem.length) {
+ this.item = closestItem;
+ this.itemContainer = itemContainer;
+ if (this.item.is(this.options.exclude) || !this.options.onMousedown(this.item, groupDefaults.onMousedown, e)) {
+ return;
+ }
+ this.setPointer(e);
+ this.toggleListeners('on');
+ this.setupDelayTimer();
+ this.dragInitDone = true;
+ }
+ },
+ drag: function (e) {
+ if(!this.dragging){
+ if(!this.distanceMet(e) || !this.delayMet)
+ return
+
+ this.options.onDragStart(this.item, this.itemContainer, groupDefaults.onDragStart, e)
+ this.item.before(this.placeholder)
+ this.dragging = true
+ }
+
+ this.setPointer(e)
+ // place item under the cursor
+ this.options.onDrag(this.item,
+ getRelativePosition(this.pointer, this.item.offsetParent()),
+ groupDefaults.onDrag,
+ e)
+
+ var p = this.getPointer(e),
+ box = this.sameResultBox,
+ t = this.options.tolerance
+
+ if(!box || box.top - t > p.top || box.bottom + t < p.top || box.left - t > p.left || box.right + t < p.left)
+ if(!this.searchValidTarget()){
+ this.placeholder.detach()
+ this.lastAppendedItem = undefined
+ }
+ },
+ drop: function (e) {
+ this.toggleListeners('off')
+
+ this.dragInitDone = false
+
+ if(this.dragging){
+ // processing Drop, check if placeholder is detached
+ if(this.placeholder.closest("html")[0]){
+ this.placeholder.before(this.item).detach()
+ } else {
+ this.options.onCancel(this.item, this.itemContainer, groupDefaults.onCancel, e)
+ }
+ this.options.onDrop(this.item, this.getContainer(this.item), groupDefaults.onDrop, e)
+
+ // cleanup
+ this.clearDimensions()
+ this.clearOffsetParent()
+ this.lastAppendedItem = this.sameResultBox = undefined
+ this.dragging = false
+ }
+ },
+ searchValidTarget: function (pointer, lastPointer) {
+ if(!pointer){
+ pointer = this.relativePointer || this.pointer
+ lastPointer = this.lastRelativePointer || this.lastPointer
+ }
+
+ var distances = sortByDistanceDesc(this.getContainerDimensions(),
+ pointer,
+ lastPointer),
+ i = distances.length
+
+ while(i--){
+ var index = distances[i][0],
+ distance = distances[i][1]
+
+ if(!distance || this.options.pullPlaceholder){
+ var container = this.containers[index]
+ if(!container.disabled){
+ if(!this.$getOffsetParent()){
+ var offsetParent = container.getItemOffsetParent()
+ pointer = getRelativePosition(pointer, offsetParent)
+ lastPointer = getRelativePosition(lastPointer, offsetParent)
+ }
+ if(container.searchValidTarget(pointer, lastPointer))
+ return true
+ }
+ }
+ }
+ if(this.sameResultBox)
+ this.sameResultBox = undefined
+ },
+ movePlaceholder: function (container, item, method, sameResultBox) {
+ var lastAppendedItem = this.lastAppendedItem
+ if(!sameResultBox && lastAppendedItem && lastAppendedItem[0] === item[0])
+ return;
+
+ item[method](this.placeholder)
+ this.lastAppendedItem = item
+ this.sameResultBox = sameResultBox
+ this.options.afterMove(this.placeholder, container, item)
+ },
+ getContainerDimensions: function () {
+ if(!this.containerDimensions)
+ setDimensions(this.containers, this.containerDimensions = [], this.options.tolerance, !this.$getOffsetParent())
+ return this.containerDimensions
+ },
+ getContainer: function (element) {
+ return element.closest(this.options.containerSelector).data(pluginName)
+ },
+ $getOffsetParent: function () {
+ if(this.offsetParent === undefined){
+ var i = this.containers.length - 1,
+ offsetParent = this.containers[i].getItemOffsetParent()
+
+ if(!this.options.rootGroup){
+ while(i--){
+ if(offsetParent[0] != this.containers[i].getItemOffsetParent()[0]){
+ // If every container has the same offset parent,
+ // use position() which is relative to this parent,
+ // otherwise use offset()
+ // compare #setDimensions
+ offsetParent = false
+ break;
+ }
+ }
+ }
+
+ this.offsetParent = offsetParent
+ }
+ return this.offsetParent
+ },
+ setPointer: function (e) {
+ var pointer = this.getPointer(e)
+
+ if(this.$getOffsetParent()){
+ var relativePointer = getRelativePosition(pointer, this.$getOffsetParent())
+ this.lastRelativePointer = this.relativePointer
+ this.relativePointer = relativePointer
+ }
+
+ this.lastPointer = this.pointer
+ this.pointer = pointer
+ },
+ distanceMet: function (e) {
+ var currentPointer = this.getPointer(e)
+ return (Math.max(
+ Math.abs(this.pointer.left - currentPointer.left),
+ Math.abs(this.pointer.top - currentPointer.top)
+ ) >= this.options.distance)
+ },
+ getPointer: function(e) {
+ var o = e.originalEvent || e.originalEvent.touches && e.originalEvent.touches[0]
+ return {
+ left: e.pageX || o.pageX,
+ top: e.pageY || o.pageY
+ }
+ },
+ setupDelayTimer: function () {
+ var that = this
+ this.delayMet = !this.options.delay
+
+ // init delay timer if needed
+ if (!this.delayMet) {
+ clearTimeout(this._mouseDelayTimer);
+ this._mouseDelayTimer = setTimeout(function() {
+ that.delayMet = true
+ }, this.options.delay)
+ }
+ },
+ scroll: function (e) {
+ this.clearDimensions()
+ this.clearOffsetParent() // TODO is this needed?
+ },
+ toggleListeners: function (method) {
+ var that = this,
+ events = ['drag','drop','scroll']
+
+ $.each(events,function (i,event) {
+ that.$document[method](eventNames[event], that[event + 'Proxy'])
+ })
+ },
+ clearOffsetParent: function () {
+ this.offsetParent = undefined
+ },
+ // Recursively clear container and item dimensions
+ clearDimensions: function () {
+ this.traverse(function(object){
+ object._clearDimensions()
+ })
+ },
+ traverse: function(callback) {
+ callback(this)
+ var i = this.containers.length
+ while(i--){
+ this.containers[i].traverse(callback)
+ }
+ },
+ _clearDimensions: function(){
+ this.containerDimensions = undefined
+ },
+ _destroy: function () {
+ containerGroups[this.options.group] = undefined
+ }
+ }
+
+ function Container(element, options) {
+ this.el = element
+ this.options = $.extend( {}, containerDefaults, options)
+
+ this.group = ContainerGroup.get(this.options)
+ this.rootGroup = this.options.rootGroup || this.group
+ this.handle = this.rootGroup.options.handle || this.rootGroup.options.itemSelector
+
+ var itemPath = this.rootGroup.options.itemPath
+ this.target = itemPath ? this.el.find(itemPath) : this.el
+
+ this.target.on(eventNames.start, this.handle, $.proxy(this.dragInit, this))
+
+ if(this.options.drop)
+ this.group.containers.push(this)
+ }
+
+ Container.prototype = {
+ dragInit: function (e) {
+ var rootGroup = this.rootGroup
+
+ if( !this.disabled &&
+ !rootGroup.dragInitDone &&
+ this.options.drag &&
+ this.isValidDrag(e)) {
+ rootGroup.dragInit(e, this)
+ }
+ },
+ isValidDrag: function(e) {
+ return e.which == 1 ||
+ e.type == "touchstart" && e.originalEvent.touches.length == 1
+ },
+ searchValidTarget: function (pointer, lastPointer) {
+ var distances = sortByDistanceDesc(this.getItemDimensions(),
+ pointer,
+ lastPointer),
+ i = distances.length,
+ rootGroup = this.rootGroup,
+ validTarget = !rootGroup.options.isValidTarget ||
+ rootGroup.options.isValidTarget(rootGroup.item, this)
+
+ if(!i && validTarget){
+ rootGroup.movePlaceholder(this, this.target, "append")
+ return true
+ } else
+ while(i--){
+ var index = distances[i][0],
+ distance = distances[i][1]
+ if(!distance && this.hasChildGroup(index)){
+ var found = this.getContainerGroup(index).searchValidTarget(pointer, lastPointer)
+ if(found)
+ return true
+ }
+ else if(validTarget){
+ this.movePlaceholder(index, pointer)
+ return true
+ }
+ }
+ },
+ movePlaceholder: function (index, pointer) {
+ var item = $(this.items[index]),
+ dim = this.itemDimensions[index],
+ method = "after",
+ width = item.outerWidth(),
+ height = item.outerHeight(),
+ offset = item.offset(),
+ sameResultBox = {
+ left: offset.left,
+ right: offset.left + width,
+ top: offset.top,
+ bottom: offset.top + height
+ }
+ if(this.options.vertical){
+ var yCenter = (dim[2] + dim[3]) / 2,
+ inUpperHalf = pointer.top <= yCenter
+ if(inUpperHalf){
+ method = "before"
+ sameResultBox.bottom -= height / 2
+ } else
+ sameResultBox.top += height / 2
+ } else {
+ var xCenter = (dim[0] + dim[1]) / 2,
+ inLeftHalf = pointer.left <= xCenter
+ if(inLeftHalf){
+ method = "before"
+ sameResultBox.right -= width / 2
+ } else
+ sameResultBox.left += width / 2
+ }
+ if(this.hasChildGroup(index))
+ sameResultBox = emptyBox
+ this.rootGroup.movePlaceholder(this, item, method, sameResultBox)
+ },
+ getItemDimensions: function () {
+ if(!this.itemDimensions){
+ this.items = this.$getChildren(this.el, "item").filter(
+ ":not(." + this.group.options.placeholderClass + ", ." + this.group.options.draggedClass + ")"
+ ).get()
+ setDimensions(this.items, this.itemDimensions = [], this.options.tolerance)
+ }
+ return this.itemDimensions
+ },
+ getItemOffsetParent: function () {
+ var offsetParent,
+ el = this.el
+ // Since el might be empty we have to check el itself and
+ // can not do something like el.children().first().offsetParent()
+ if(el.css("position") === "relative" || el.css("position") === "absolute" || el.css("position") === "fixed")
+ offsetParent = el
+ else
+ offsetParent = el.offsetParent()
+ return offsetParent
+ },
+ hasChildGroup: function (index) {
+ return this.options.nested && this.getContainerGroup(index)
+ },
+ getContainerGroup: function (index) {
+ var childGroup = $.data(this.items[index], subContainerKey)
+ if( childGroup === undefined){
+ var childContainers = this.$getChildren(this.items[index], "container")
+ childGroup = false
+
+ if(childContainers[0]){
+ var options = $.extend({}, this.options, {
+ rootGroup: this.rootGroup,
+ group: groupCounter ++
+ })
+ childGroup = childContainers[pluginName](options).data(pluginName).group
+ }
+ $.data(this.items[index], subContainerKey, childGroup)
+ }
+ return childGroup
+ },
+ $getChildren: function (parent, type) {
+ var options = this.rootGroup.options,
+ path = options[type + "Path"],
+ selector = options[type + "Selector"]
+
+ parent = $(parent)
+ if(path)
+ parent = parent.find(path)
+
+ return parent.children(selector)
+ },
+ _serialize: function (parent, isContainer) {
+ var that = this,
+ childType = isContainer ? "item" : "container",
+
+ children = this.$getChildren(parent, childType).not(this.options.exclude).map(function () {
+ return that._serialize($(this), !isContainer)
+ }).get()
+
+ return this.rootGroup.options.serialize(parent, children, isContainer)
+ },
+ traverse: function(callback) {
+ $.each(this.items || [], function(item){
+ var group = $.data(this, subContainerKey)
+ if(group)
+ group.traverse(callback)
+ });
+
+ callback(this)
+ },
+ _clearDimensions: function () {
+ this.itemDimensions = undefined
+ },
+ _destroy: function() {
+ var that = this;
+
+ this.target.off(eventNames.start, this.handle);
+ this.el.removeData(pluginName)
+
+ if(this.options.drop)
+ this.group.containers = $.grep(this.group.containers, function(val){
+ return val != that
+ })
+
+ $.each(this.items || [], function(){
+ $.removeData(this, subContainerKey)
+ })
+ }
+ }
+
+ var API = {
+ enable: function() {
+ this.traverse(function(object){
+ object.disabled = false
+ })
+ },
+ disable: function (){
+ this.traverse(function(object){
+ object.disabled = true
+ })
+ },
+ serialize: function () {
+ return this._serialize(this.el, true)
+ },
+ refresh: function() {
+ this.traverse(function(object){
+ object._clearDimensions()
+ })
+ },
+ destroy: function () {
+ this.traverse(function(object){
+ object._destroy();
+ })
+ }
+ }
+
+ $.extend(Container.prototype, API)
+
+ /**
+ * jQuery API
+ *
+ * Parameters are
+ * either options on init
+ * or a method name followed by arguments to pass to the method
+ */
+ $.fn[pluginName] = function(methodOrOptions) {
+ var args = Array.prototype.slice.call(arguments, 1)
+
+ return this.map(function(){
+ var $t = $(this),
+ object = $t.data(pluginName)
+
+ if(object && API[methodOrOptions])
+ return API[methodOrOptions].apply(object, args) || this
+ else if(!object && (methodOrOptions === undefined ||
+ typeof methodOrOptions === "object"))
+ $t.data(pluginName, new Container($t, methodOrOptions))
+
+ return this
+ });
+ };
+
+}(jQuery, window, 'sortable');
diff --git a/app/assets/javascripts/notify.js b/app/assets/javascripts/notify.js
new file mode 100644
index 0000000..fb9df63
--- /dev/null
+++ b/app/assets/javascripts/notify.js
@@ -0,0 +1,625 @@
+/* Notify.js - http://notifyjs.com/ Copyright (c) 2015 MIT */
+(function (factory) {
+ // UMD start
+ // https://github.com/umdjs/umd/blob/master/jqueryPluginCommonjs.js
+ if (typeof define === 'function' && define.amd) {
+ // AMD. Register as an anonymous module.
+ define(['jquery'], factory);
+ } else if (typeof module === 'object' && module.exports) {
+ // Node/CommonJS
+ module.exports = function( root, jQuery ) {
+ if ( jQuery === undefined ) {
+ // require('jQuery') returns a factory that requires window to
+ // build a jQuery instance, we normalize how we use modules
+ // that require this pattern but the window provided is a noop
+ // if it's defined (how jquery works)
+ if ( typeof window !== 'undefined' ) {
+ jQuery = require('jquery');
+ }
+ else {
+ jQuery = require('jquery')(root);
+ }
+ }
+ factory(jQuery);
+ return jQuery;
+ };
+ } else {
+ // Browser globals
+ factory(jQuery);
+ }
+}(function ($) {
+ //IE8 indexOf polyfill
+ var indexOf = [].indexOf || function(item) {
+ for (var i = 0, l = this.length; i < l; i++) {
+ if (i in this && this[i] === item) {
+ return i;
+ }
+ }
+ return -1;
+ };
+
+ var pluginName = "notify";
+ var pluginClassName = pluginName + "js";
+ var blankFieldName = pluginName + "!blank";
+
+ var positions = {
+ t: "top",
+ m: "middle",
+ b: "bottom",
+ l: "left",
+ c: "center",
+ r: "right"
+ };
+ var hAligns = ["l", "c", "r"];
+ var vAligns = ["t", "m", "b"];
+ var mainPositions = ["t", "b", "l", "r"];
+ var opposites = {
+ t: "b",
+ m: null,
+ b: "t",
+ l: "r",
+ c: null,
+ r: "l"
+ };
+
+ var parsePosition = function(str) {
+ var pos;
+ pos = [];
+ $.each(str.split(/\W+/), function(i, word) {
+ var w;
+ w = word.toLowerCase().charAt(0);
+ if (positions[w]) {
+ return pos.push(w);
+ }
+ });
+ return pos;
+ };
+
+ var styles = {};
+
+ var coreStyle = {
+ name: "core",
+ html: "