infopark_fiona7 1.2.0.2.3 → 1.5.2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9c5f40ca907638fd8408111bd3f4bd2b10fb9fd9
-  data.tar.gz: 98c910149b086995516b632d25ca398cf9f89ba9
+  metadata.gz: 741127529a15e35abbb025c194986fca04edb0da
+  data.tar.gz: 87098673b467a0ed0a93cc5e84f298365397f5b5
 SHA512:
-  metadata.gz: 0fdc4db91f3cb47803a089dbfee7058083caabb32e4d7600c7d0359ab10480bdf8e70d20249f823f4b8255cdd6488c74e50ba4f319de29c4a946f86a61513b8e
-  data.tar.gz: 26a3205d4f7d209cf80c802404cd9cc5a88436ad000a41e37cfa343cbee5e85a34cbcfef3b4c47618634a7974450141806bd897c9f18fc3fdc6c3917692302d6
+  metadata.gz: aa8b4752d37991650a8d51d0bf84e968d2fbe93b9472c4045591c2a5a7ca6a34c8d5e98b1e9a8813c6231de42bc436b7946e1157ec2d4311343203649275f25e
+  data.tar.gz: 5adea82b2c79308ff97ccf118568545b314226081a2acf9ca3bfb4ae8624383e9b5938ad9b717935ed1bfe408b4e368f98d89afed36b71f3de36a41aaa884751

data/Rakefile

@@ -15,7 +15,40 @@ RDoc::Task.new(:rdoc) do |rdoc|
 end
 
 
+namespace "package" do
+  desc "Package javascript"
+  task "js" do
+    puts "Transpiling javascript files"
+    require 'babel/transpiler'
+    Dir["app/**/*"].each do |fname|
+      if /\.es6\.js$/ =~ fname
+        nfname = ::File.join(::File.dirname(fname), ::File.basename(fname, '.es6.js') + '.js')
+        puts "#{fname} -> #{nfname}"
+        ::File.open(nfname, 'w') do |f|
+          f.write Babel::Transpiler.transform(File.read(fname))["code"]
+        end
+      end
+    end
+  end
+end
+
+namespace "clean" do
+  desc "Clean packaged javascript"
+  task "js" do
+    puts "Cleaning transpiled javascript files"
+    Dir["app/**/*"].each do |fname|
+      if /\.es6\.js$/ =~ fname
+        nfname = ::File.join(::File.dirname(fname), ::File.basename(fname, '.es6.js') + '.js')
+        puts "#{nfname}"
+        ::FileUtils.rm(nfname) if ::File.exists?(nfname)
+      end
+    end
+  end
+end
 
+task "build" => ["clean:js", "package:js"] do
+  # dummy, needed for dependencies, the rest is added later by bundler
+end
 
 Bundler::GemHelper.install_tasks
 

data/app/assets/javascripts/fiona7_ui.js

@@ -1,6 +1,13 @@
-//= require scrivito_patches/models/ajax
-//= require scrivito_patches/models/blob
+//= require scrivito_patches/models/api/basic_obj
+//= require scrivito_patches/models/binary_field_element
 //= require scrivito_patches/models/obj
+//= require scrivito_patches/ajax
+//= require scrivito_patches/attribute_serializer
+//= require scrivito_patches/ajax_error_handling
+//= require scrivito_patches/base_obj_path
+//= require scrivito_patches/cms_rest_api
+//= require scrivito_patches/obj_serializer
+//= require scrivito_patches/binary_utils
 //= require_self
 
 (function() {
@@ -87,7 +94,7 @@
           // view loaded
         });
 
-        scrivito.with_dialog_behaviour(view, deferred, {enter: accept, escape: cancel});
+        scrivito.withDialogBehaviour(view, deferred, {enter: accept, escape: cancel});
       },
         function(xhr, text_status, error) {
         });
@@ -226,14 +233,84 @@
   };
   var actions = ["edit", "forward", "reject","commit", "sign", "take"];
 
+  var releaseAction = function (objId) {
+    open_release_dialog(objId).done(function(objIds, comment) {
+      scrivito.withSavingOverlay(scrivito.ajax('PUT', 'objs/release', {data: {objs: objIds, comment: comment}}).then(function() {
+        scrivito.reload();
+      }));
+    });
+  };
+
+  var workflowAction = function (action, objId) {
+    open_confirmation_dialog(action, dialog_icons[action]).done(function(comment) {
+      scrivito.withSavingOverlay(scrivito.ajax('PUT', 'objs/workflow/'+action, {data: {id: objId, comment: comment}}).then(function() {
+        if (action == 'edit' || action == 'take') {
+          if (!scrivito.editing_context.is_editing_mode()) {
+            return scrivito.withSavingOverlay(
+              scrivito.change_editing_context({display_mode: 'editing', workspace_id: 'rtc'}));
+          } else {
+            return scrivito.withSavingOverlay(scrivito.reload());
+          }
+        } else {
+          return  scrivito.withSavingOverlay(scrivito.reload());
+        }
+      }));
+    });
+  };
+
   scrivito.gui.on('document', function(cms_document) {
     var page_config      = (cms_document.page_config() || {})['current_page'] || {};
     var obj              = cms_document.page();
     var buttons          = page_config['buttons'] || [];
     var workflow_enabled = page_config['workflow'];
 
+
     if (cms_document.browser_window().name !== 'scrivito_application') {
       // TODO: add special handling for scrivito_details_dialog and scrivito_inspector
+      var button;
+
+      // enable workflow buttons
+      $.each(buttons, function (idx, action) {
+        // release is handled differently
+        if (action === 'release') {
+          return;
+        }
+
+        // find the workflow button
+        button = $('[data-fiona7-private-workflow-button="' + action + '"]', cms_document.browser_window().document);
+
+        // enable given workflow button
+        button.removeAttr('disabled');
+        button.removeClass('disabled');
+        button.click(function () {
+          workflowAction(action, obj.id());
+        });
+
+      });
+
+      // remove redundant buttons
+      $.each(actions, function (idx, action) {
+        if (buttons.indexOf(action) === -1) {
+          $('[data-fiona7-private-workflow-button="' + action + '"]', cms_document.browser_window().document).remove();
+        }
+      });
+
+      // conditionally enable release button
+      // find the release button
+      button = $('[data-fiona7-private-workflow-button="release"]', cms_document.browser_window().document);
+      if (obj.modification()) {
+        if (obj.has_restriction()) {
+          // release impossibru
+          button.attr('title', obj.restriction_messages().join("; "));
+        } else {
+          button.removeAttr('disabled');
+          button.removeClass('disabled');
+          button.click(function () {
+            releaseAction(obj.id());
+          });
+        }
+      }
+
       return;
     }
 
@@ -260,11 +337,7 @@
       },
 
       execute: function() {
-        open_release_dialog(obj.id()).done(function(objIds, comment) {
-          scrivito.with_saving_overlay(scrivito.ajax('PUT', 'objs/release', {data: {objs: objIds, comment: comment}}).then(function() {
-            scrivito.reload();
-          }));
-        });
+        return releaseAction(obj.id());
       }
     });
     /* TODO: enforce permissions */
@@ -291,21 +364,7 @@
         },
 
         execute: function() {
-          open_confirmation_dialog(action, dialog_icons[action]).done(function(comment) {
-            scrivito.with_saving_overlay(scrivito.ajax('PUT', 'objs/workflow/'+action, {data: {id: obj.id(), comment: comment}}).then(function() {
-              if (action == 'edit' || action == 'take') {
-
-                if (!scrivito.editing_context.is_editing_mode()) {
-                  return scrivito.with_saving_overlay(
-                    scrivito.change_editing_context({display_mode: 'editing', workspace_id: 'rtc'}));
-                } else {
-                  return scrivito.with_saving_overlay(scrivito.reload());
-                }
-              } else {
-                return  scrivito.with_saving_overlay(scrivito.reload());
-              }
-            }));
-          });
+          return workflowAction(action, obj.id());
         }
       });
     });

data/app/assets/javascripts/scrivito_patches/ajax.js

@@ -0,0 +1,222 @@
+(function() {
+  var handle_task = function(task) {
+    switch (task.status) {
+      case 'success':
+        return $.Deferred().resolve(task.result);
+      case 'error':
+        return $.Deferred().reject({
+          message: task.message,
+          code: task.code
+        });
+      case 'open':
+        return scrivito.wait(2).then(function() {
+          return single_ajax('GET', 'tasks/' + task.id).then(function(data) {
+            return handle_task(data);
+          });
+        });
+      default:
+        throw { message: "Invalid task (unknown status)", task: task };
+    }
+  };
+
+  // -- PATCH BEGINS HERE --
+  var ajax_with_form_data_required = function(params) {
+    var objParams = params && params.obj;
+    var result = false;
+    var k;
+
+    if (!objParams) {
+      return result;
+    }
+
+    for (k in objParams) {
+      if (objParams.hasOwnProperty(k)) {
+        result = scrivito.BinaryUtils.isFile(objParams[k]) || scrivito.BinaryUtils.isBlob(objParams[k]) || scrivito.BinaryUtils.isBlobWithName(objParams[k]);
+        if (result) {
+          return result;
+        }
+      }
+    }
+    return result;
+  };
+
+  var params_to_form_data = function(params) {
+    var objParams = params && params.obj || {};
+    var fd = new FormData();
+
+    var k, attr, value, widgetId, widgetValue, widgetAttr, i, l, t;
+
+    for (k in objParams) {
+      if (objParams.hasOwnProperty(k)) {
+
+        attr = k;
+        value = objParams[k];
+
+        if (attr === '_widget_pool') {
+          for (w in value) {
+            if (value.hasOwnProperty(w)) {
+              for (widgetAttr in value[w]) {
+                if (value[w].hasOwnProperty(widgetAttr)) {
+                  widgetValue = value[w][widgetAttr];
+
+                  if (widgetValue.pop) {
+                    // value is an array
+                    for (i=0; i < widgetValue.length; ++i) {
+                      fd.append("obj[" + attr + "][" + w + "][" + widgetAttr + "][]", widgetValue[i]);
+                    }
+                  } else if (scrivito.BinaryUtils.isFile(widgetValue) || scrivito.BinaryUtils.isBlob(widgetValue)) {
+                    // upload
+                    fd.append("obj[" + attr + "][" + w + "][" + widgetAttr + "]", widgetValue);
+                  } else if (scrivito.BinaryUtils.isBlobWithName(widgetValue)) {
+                    fd.append("obj[" + attr + "][" + w + "][" + widgetAttr + "]", widgetValue.blob_to_upload, widgetValue.filename);
+                  } else if (typeof value === 'object') {
+                    // blob/copy rename
+                    for (l in widgetValue) {
+                      if (widgetValue.hasOwnProperty(l)) {
+                        fd.append("obj[" + attr + "][" + w + "][" + widgetAttr + "][" + l + "]", widgetValue[l]);
+                      }
+                    }
+                  } else if (typeof value !== 'undefined') {
+                    fd.append("obj[" + attr + "][" + w + "][" + widgetAttr + "]", widgetValue);
+                  }
+                }
+              }
+            }
+          }
+        } else if (value.pop) {
+          // value is an array
+          for (i=0; i < value.length; ++i) {
+            fd.append("obj[" + attr + "][]", value[i]);
+          }
+        } else if (scrivito.BinaryUtils.isFile(value) || scrivito.BinaryUtils.isBlob(value)) {
+          // upload
+          fd.append("obj[" + attr + "]", value);
+        } else if (scrivito.BinaryUtils.isBlobWithName(value)) {
+          fd.append("obj[" + attr + "]", value.blob_to_upload, value.filename);
+        } else if (typeof value === 'object') {
+          // blob/copy rename
+          for (l in value) {
+            if (value.hasOwnProperty(l)) {
+              fd.append("obj[" + attr + "][" + l + "]", value[l]);
+            }
+          }
+        } else if (typeof value !== 'undefined') {
+          fd.append("obj[" + attr + "]", value);
+        }
+      }
+    }
+
+    return fd;
+  };
+
+  var single_ajax_with_form_data = function(type, path, options) {
+    var base_url = window.location.protocol + '//' + window.location.host + '/__scrivito/';
+    if (options && options.data) {
+      options.data = params_to_form_data(options.data);
+    }
+    return $.ajax(base_url + path, _.extend({
+      type: type,
+      contentType: false,
+      processData: false,
+      cache: false // Don't cache GET requests.
+    }, options || {})).then(
+      function(result, text_status, xhr) {
+        return $.Deferred().resolve(result);
+      }, function(xhr, text_status, xhr_error) {
+        try {
+          return $.Deferred().reject(JSON.parse(xhr.responseText));
+        } catch (SyntaxError) {
+          return $.Deferred().reject(xhr_error);
+        }
+      }
+    );
+  };
+  // -- PATCH ENDS HERE --
+
+  var single_ajax = function(type, path, options) {
+    // -- PATCH BEGINS HERE --
+    if (ajax_with_form_data_required(options && options.data || {})) {
+      return single_ajax_with_form_data(type, path, options);
+    }
+    // -- PATCH ENDS HERE --
+    var base_url = window.location.protocol + '//' + window.location.host + '/__scrivito/';
+    if (options && options.data) {
+      options.data = JSON.stringify(options.data);
+    }
+    return $.ajax(base_url + path, _.extend({
+      type: type,
+      dataType: 'json',
+      contentType: 'application/json; charset=utf-8',
+      cache: false // Don't cache GET requests.
+    }, options || {})).then(
+      function(result, text_status, xhr) {
+        return $.Deferred().resolve(result);
+      }, function(xhr, text_status, xhr_error) {
+        try {
+          return $.Deferred().reject(JSON.parse(xhr.responseText));
+        } catch (SyntaxError) {
+          return $.Deferred().reject(xhr_error);
+        }
+      }
+    );
+  };
+
+  _.extend(scrivito, {
+    silent_ajax: function(type, path, options) {
+      var is_write_request = type === 'PUT' || type === 'POST' || type === 'DELETE';
+      var skip_write_monitor = options && options.skip_write_monitor;
+
+      if (is_write_request) {
+        options = options || {};
+        options.timeout = 120000; // miliseconds // <-- PATCH HERE
+
+        if (!skip_write_monitor) {
+          scrivito.write_monitor.start_write();
+        }
+      }
+
+      var ajax_promise = single_ajax(type, path, options).then(function(result) {
+        if (result && result.task && _.size(result) === 1) {
+          return handle_task(result.task);
+        } else {
+          return $.Deferred().resolve(result);
+        }
+      });
+
+      if (is_write_request && !skip_write_monitor) {
+        ajax_promise.always(function() {
+          scrivito.write_monitor.end_write();
+        });
+      }
+
+      return ajax_promise;
+    },
+
+    ajax: function(type, path, options) {
+      return scrivito.silent_ajax(type, path, options).fail(function(error) {
+        scrivito.display_ajax_error(error);
+      });
+    },
+
+    display_ajax_error: function(error) {
+      var message, message_for_editor;
+
+      // -- PATCH BEGINS HERE --
+      if (_.isObject(error)) {
+        if (error.message) {
+          return scrivito.alertDialog(error.message);
+        } else {
+          return scrivito.alertDialog(scrivito.t('ajax_error.communication'));
+        }
+      } else if (_.contains(['abort', 'parsererror', 'timeout'], error)) {
+        message = scrivito.t('ajax_error.communication');
+      } else {
+        message = scrivito.t('ajax_error', error);
+      }
+      scrivito.logError(message);
+      scrivito.errorDialog(message_for_editor || scrivito.t('ajax_error.message_for_editor'),
+          [error.timestamp, message]);
+      // -- PATCH ENDS HERE --
+    }
+  });
+}());

data/app/assets/javascripts/scrivito_patches/ajax_error_handling.js

@@ -0,0 +1,24 @@
+'use strict';
+
+(function () {
+  _.extend(scrivito, {
+    handleAjaxError: function handleAjaxError(error) {
+      var message = undefined;
+
+      // -- PATCH BEGINS HERE --
+      if (typeof error === 'object' && error.message) {
+        scrivito.alertDialog(error.message);
+      } else {
+        message = scrivito.t('ajax_error.communication');
+        scrivito.errorDialog(scrivito.t('ajax_error.message_for_editor'), [message]);
+      }
+      // -- PATCH ENDS HERE --
+
+      scrivito.logError(error);
+    },
+
+    withAjaxErrorHandling: function withAjaxErrorHandling(promise) {
+      return promise['catch'](scrivito.handleAjaxError);
+    }
+  });
+})();

data/app/assets/javascripts/scrivito_patches/attribute_serializer.js

@@ -0,0 +1,259 @@
+'use strict';
+
+(function () {
+  scrivito.AttributeSerializer = {
+    serialize: function serialize(objClass, attributes) {
+      return _.mapObject(attributes, function (value, name) {
+        if (scrivito.Attribute.isSystemAttribute(name)) {
+          return value;
+        }
+
+        var attribute = objClass && objClass.attribute(name);
+
+        if (!attribute) {
+          throw new scrivito.ScrivitoError('Attribute "' + name + '" is not defined for obj class "' + objClass.name + '".');
+        }
+
+        return [serializeAttributeType(attribute.type, name), serializeAttributeValue(attribute, value, name)];
+      });
+    }
+  };
+
+  function serializeAttributeType(type, name) {
+    switch (type) {
+      case 'enum':
+        return 'string';
+      case 'float':
+      case 'integer':
+        return 'number';
+      case 'multienum':
+        return 'stringlist';
+      case 'binary':
+      case 'date':
+      case 'html':
+      case 'link':
+      case 'linklist':
+      case 'reference':
+      case 'referencelist':
+      case 'string':
+      case 'stringlist':
+      case 'widgetlist':
+        return type;
+      default:
+        throw new scrivito.ScrivitoError('Attribute "' + name + '" is of unsupported type "' + type + '".');
+    }
+  }
+
+  function serializeAttributeValue(attribute, value, name) {
+    if (value === null) {
+      return value;
+    }
+
+    switch (attribute.type) {
+      case 'binary':
+        return serializeBinaryAttributeValue(value, name);
+      case 'date':
+        return serializeDateAttributeValue(value, name);
+      case 'enum':
+        return serializeEnumAttributeValue(attribute, value, name);
+      case 'float':
+        return serializeFloatAttributeValue(value, name);
+      case 'integer':
+        return serializeIntegerAttributeValue(value, name);
+      case 'link':
+        return serializeLinkAttributeValue(value, name);
+      case 'linklist':
+        return serializeLinklistAttributeValue(value, name);
+      case 'multienum':
+        return serializeMultienumAttributeValue(attribute, value, name);
+      case 'reference':
+        return serializeReferenceAttributeValue(value, name);
+      case 'referencelist':
+        return serializeReferencelistAttributeValue(value, name);
+      case 'widgetlist':
+        return serializeWidgetlistAttributeValue(value);
+      default:
+        return value;
+    }
+  }
+
+  function invalidAttributeValue(value, name, expected) {
+    throw new scrivito.ScrivitoError('Unexpected value ' + scrivito.prettyPrint(value) + ' for' + (' attribute "' + name + '". Expected: ' + expected));
+  }
+
+  function serializeBinaryAttributeValue(_x, _x2) {
+    var _again = true;
+
+    _function: while (_again) {
+      var value = _x,
+          name = _x2;
+      _again = false;
+
+      // -- PATCH BEGINS HERE --
+      if (value instanceof scrivito.Binary) {
+        return { id: value.id };
+      } else if (value === null) {
+        return null;
+      } else if (value instanceof scrivito.UploadedBlob) {
+        _x = value.copy();
+        _x2 = name;
+        _again = true;
+        continue _function;
+      } else if (value instanceof scrivito.FutureBinary) {
+        var futureBinary = value;
+
+        if (futureBinary.idToCopy) {
+          var blob = {
+            id_to_copy: futureBinary.idToCopy
+          };
+          if (futureBinary.filename) blob.filename = futureBinary.filename;
+          if (futureBinary.contentType) blob.content_type = futureBinary.contentType;
+
+          return blob;
+        } else if (futureBinary.source) {
+          return { blob_to_upload: futureBinary.source, filename: futureBinary.filename };
+        }
+      } else if (scrivito.BinaryUtils.isFile(value) || scrivito.BinaryUtils.isBlob(value)) {
+        return value;
+      } else if (typeof value === 'object' && value.id_to_copy) {
+        return value;
+      } else {
+        invalidAttributeValue(value, name, 'A Binary.');
+      }
+      // -- PATCH ENDS HERE --
+    }
+  }
+
+  function serializeDateAttributeValue(value, name) {
+    if (_.isDate(value)) {
+      return scrivito.types.formatDateToString(value);
+    }
+    if (scrivito.types.isValidDateString(value)) {
+      return value;
+    }
+
+    invalidAttributeValue(value, name, 'A Date.');
+  }
+
+  function serializeEnumAttributeValue(attribute, value, name) {
+    var validValues = attribute.validValues();
+    if (!_.contains(validValues, value)) {
+      var e = 'Valid attribute values are contained in its "validValues" array [' + validValues + '].';
+      invalidAttributeValue(value, name, e);
+    }
+    return value;
+  }
+
+  function serializeFloatAttributeValue(value, name) {
+    if (!scrivito.types.isValidFloat(value)) {
+      var invalidValue = value;
+      if (_.isNumber(value)) {
+        invalidValue = String(value);
+      }
+      invalidAttributeValue(invalidValue, name, 'A Number, that is #isFinite().');
+    }
+    return value;
+  }
+
+  function serializeIntegerAttributeValue(value, name) {
+    if (!scrivito.types.isValidInteger(value)) {
+      invalidAttributeValue(value, name, 'A Number, that is #isSafeInteger().');
+    }
+    return value;
+  }
+
+  function serializeLinkAttributeValue(value, name) {
+    if (!validLinkObject(value)) {
+      invalidAttributeValue(value, name, 'A scrivito.Link instance.');
+    }
+
+    return convertLinkToCmsApi(value);
+  }
+
+  function serializeLinklistAttributeValue(value, name) {
+    if (!Array.isArray(value) || !_.all(value, validLinkObject)) {
+      invalidAttributeValue(value, name, 'An array of scrivito.Link instances.');
+    }
+
+    return _.map(value, convertLinkToCmsApi);
+  }
+
+  function validLinkObject(value) {
+    if (value instanceof scrivito.Link) {
+      return true;
+    }
+
+    // check if value is backend compatible
+    if (!_.isObject(value)) {
+      return false;
+    }
+    var invalidKeys = _.without(_.keys(value), 'fragment', 'obj_id', 'query', 'target', 'title', 'url');
+    return _.isEmpty(invalidKeys);
+  }
+
+  function convertLinkToCmsApi(value) {
+    var backendLink = {
+      fragment: value.fragment,
+      query: value.query,
+      target: value.target,
+      title: value.title,
+      url: value.url
+    };
+    backendLink.obj_id = value.objId || value.obj_id;
+
+    return _.mapObject(backendLink, function (v) {
+      return v || null;
+    });
+  }
+
+  function serializeMultienumAttributeValue(attribute, value, name) {
+    var validValues = attribute.validValues();
+    var errorMessage = 'An array with values from ' + scrivito.prettyPrint(validValues) + '.';
+
+    if (!Array.isArray(value) || !_.all(value, _.isString)) {
+      invalidAttributeValue(value, name, errorMessage);
+    }
+
+    var forbiddenValues = _.difference(value, validValues);
+    if (forbiddenValues.length) {
+      var e = errorMessage + ' Forbidden values: ' + scrivito.prettyPrint(forbiddenValues) + '.';
+      invalidAttributeValue(value, name, e);
+    }
+    return value;
+  }
+
+  function serializeReferenceAttributeValue(value, name) {
+    if (!isValidReference(value)) {
+      invalidAttributeValue(value, name, 'A BasicObj or a String ID.');
+    }
+    return serializeSingleReferenceValue(value);
+  }
+
+  function serializeReferencelistAttributeValue(value, name) {
+    if (!isValidReferencelistValue(value)) {
+      invalidAttributeValue(value, name, 'An array with BasicObjs or String IDs.');
+    }
+    return _.map(value, serializeSingleReferenceValue);
+  }
+
+  function serializeSingleReferenceValue(value) {
+    if (value instanceof scrivito.BasicObj) {
+      return value.id;
+    }
+    return value;
+  }
+
+  function isValidReference(value) {
+    return _.isString(value) || value instanceof scrivito.BasicObj;
+  }
+
+  function isValidReferencelistValue(value) {
+    return _.isArray(value) && _.every(value, function (v) {
+      return isValidReference(v);
+    });
+  }
+
+  function serializeWidgetlistAttributeValue(value) {
+    return _.pluck(value, 'id');
+  }
+})();