scrivito_content_browser 0.40.0 → 0.41.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 806c9ab13407327ead8d9aee15d1ba67fa1bd1e5
-  data.tar.gz: 5f64eb899c7c6fbfdeb2d7419e2c25414cb9bc2d
+  metadata.gz: 7452d19d9b78a7bd3b272a23b2c2c989e03eee49
+  data.tar.gz: 7bf2b9950f63a2af06184671a81bbc0d89846ab2
 SHA512:
-  metadata.gz: aedebe19185a7faf9a3914ea2647a2739216953a21d3f5fb70b2b8841ed84999ba699b6a4019815fe619ea169a0afbd50bdc5661ac37ec3b7567d5f50de29981
-  data.tar.gz: 5726ffe674b422a8e2af44b288b27f0703a92dcc731c95fdd16de7081051bfebbbbff396b892810f49eaebeb117d0915395554d129466f441da9e4baee9babc5
+  metadata.gz: 6f5f6e66085b4c2c662276be0c745e8e77346373e75be7fa1d8640cc1b2938e122ea4c94d0c958ab8324df8d3b58273aed6e78521bc8f609b90ab6dd57f339f4
+  data.tar.gz: 9ade6519c8cf712c250537037e52409d46fd1ab5df5184f96096f46ca265c931388051f3d52616b18bfc4ef7ecaad38290c408c40d966af68d29fb42165e0698

data/app/assets/javascripts/dist/scrivito_content_browser_pkg.js

@@ -22,56 +22,78 @@
       components: {},
       models: {},
       base_query: null,
-      _center: function(domElement) {
-        if (domElement) {
+      _center: function() {
+        var domElement, domElements, _i, _len, _results;
+        domElements = $(".scrivito-content-browser");
+        _results = [];
+        for (_i = 0, _len = domElements.length; _i < _len; _i++) {
+          domElement = domElements[_i];
           domElement = $(domElement);
-          return domElement.css({
+          _results.push(domElement.css({
             marginLeft: -domElement.innerWidth() / 2,
             marginTop: -domElement.innerHeight() / 2,
             left: '50%'
-          });
+          }));
         }
+        return _results;
       },
       _loadModal: function() {
-        this.overlay = $('<div></div>').addClass('editing-overlay show').appendTo($('body'));
-        this.modal = $('<div></div>').addClass('scrivito-content-browser show').attr('id', 'scrivito-content-browser').appendTo($('body'));
-        this._center(this.modal);
-        return $(window).resize((function(_this) {
-          return function() {
-            return _this._center(_this.modal);
-          };
-        })(this));
+        $('<div></div>').addClass('editing-overlay show').appendTo($('body'));
+        $('<div></div>').addClass('scrivito-content-browser show').appendTo($('body'));
+        return this._center();
       },
       _buildFilter: function(filter_definition) {
         return new models.Filter(filter_definition);
       },
-      _startReact: function() {
+      _startReact: function(options, promise) {
         var baseQuery, filter, filterConfig;
-        filterConfig = this.options.filters || this.filters;
-        baseQuery = this.options.base_query || this.base_query;
+        filterConfig = options.filters || this.filters;
+        baseQuery = options.base_query || this.base_query;
         filter = this._buildFilter(filterConfig);
         return this._reactApp = React.render(React.createElement(ui.App, {
           "initialFilter": filter,
           "baseQuery": baseQuery,
-          "container": this
-        }), document.getElementById('scrivito-content-browser'));
+          "promise": promise,
+          "options": options
+        }), this._getLastContentBrowserElement());
+      },
+      _getLastElementByClassName: function(className) {
+        var elements;
+        elements = document.getElementsByClassName(className);
+        return _.last(elements);
+      },
+      _getLastOverlayElement: function() {
+        return this._getLastElementByClassName('editing-overlay show');
+      },
+      _getLastContentBrowserElement: function() {
+        return this._getLastElementByClassName('scrivito-content-browser show');
       },
       close: function() {
-        this.overlay.remove();
-        return this.modal.remove();
+        this._getLastOverlayElement().remove();
+        return this._getLastContentBrowserElement().remove();
       },
       open: function(options) {
+        var promise;
         if (options == null) {
           options = {};
         }
         if (!options.hasOwnProperty('base_preset')) {
           options.base_preset = this.base_preset;
         }
-        this.options = options;
+        promise = $.Deferred();
         this._loadModal();
-        this._startReact();
-        this._promise = $.Deferred();
-        return this._promise;
+        this._startReact(options, promise);
+        $(window).resize((function(_this) {
+          return function() {
+            return _this._center();
+          };
+        })(this));
+        promise.always((function(_this) {
+          return function() {
+            return _this.close();
+          };
+        })(this));
+        return promise;
       }
     };
   })();
@@ -132,7 +154,7 @@
 
   OptionFilterMixin = {
     mixins: [OptionFilterLabelRenderMixin],
-    optionLabelToogleClick: function() {
+    optionLabelToggleClick: function() {
       return this.props.filter.toggleActive();
     },
     activeClassName: function() {
@@ -230,6 +252,137 @@
 
   })();
 
+  models.ActiveFilterNodeCollector = (function() {
+    function ActiveFilterNodeCollector(filter) {
+      this._filter = filter;
+    }
+
+    ActiveFilterNodeCollector.prototype.findActiveFilterItems = function() {
+      var filterItems, treeFilterItem;
+      filterItems = this._findActiveAdditionalFilters();
+      treeFilterItem = this._findActiveTreeFilterItem();
+      if (treeFilterItem) {
+        filterItems.unshift(treeFilterItem);
+      }
+      return filterItems;
+    };
+
+    ActiveFilterNodeCollector.prototype._findActiveTreeFilterItem = function() {
+      var activeConfig, subFilter, treeFilter, _i, _j, _len, _len1, _ref, _ref1;
+      _ref = this._filter.getTreeFilters();
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        treeFilter = _ref[_i];
+        _ref1 = treeFilter.subFilters;
+        for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
+          subFilter = _ref1[_j];
+          activeConfig = this._findActiveSubFilterItem(subFilter);
+          if (activeConfig) {
+            activeConfig.parents.push(treeFilter.config);
+            return new models.ActiveNodeConfig(activeConfig.parents, [activeConfig.node]);
+          }
+        }
+      }
+    };
+
+    ActiveFilterNodeCollector.prototype._findActiveAdditionalFilters = function() {
+      var activeChildren, activeFilters, additionalFilter, _i, _len, _ref;
+      activeFilters = [];
+      _ref = this._filter.additionalFilters;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        additionalFilter = _ref[_i];
+        activeChildren = _.filter(additionalFilter.children, function(child) {
+          return child.isActive();
+        });
+        if (activeChildren.length > 0) {
+          activeFilters.push(new models.ActiveNodeConfig([additionalFilter], activeChildren));
+        }
+      }
+      return activeFilters;
+    };
+
+    ActiveFilterNodeCollector.prototype._findActiveSubFilterItem = function(filterNode) {
+      var activeConfig, childNode, _i, _len, _ref;
+      if (filterNode.isActive()) {
+        return {
+          node: filterNode,
+          parents: []
+        };
+      } else {
+        _ref = filterNode.children;
+        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+          childNode = _ref[_i];
+          activeConfig = this._findActiveSubFilterItem(childNode);
+          if (activeConfig) {
+            activeConfig.parents.push(filterNode);
+            return activeConfig;
+          }
+        }
+      }
+    };
+
+    return ActiveFilterNodeCollector;
+
+  })();
+
+  models.ActiveNodeConfig = (function() {
+    function ActiveNodeConfig(parents, nodes) {
+      this._parents = parents;
+      this._activeNodes = nodes;
+    }
+
+    ActiveNodeConfig.prototype.activeNodes = function() {
+      return this._activeNodes;
+    };
+
+    ActiveNodeConfig.prototype.values = function() {
+      return _.flatten(_.map(this._activeNodes, this._valueForNode));
+    };
+
+    ActiveNodeConfig.prototype.query = function() {
+      return this._filter().type !== 'checkbox' && this._activeNodes[0].query;
+    };
+
+    ActiveNodeConfig.prototype.hasQuery = function() {
+      return !!this.query();
+    };
+
+    ActiveNodeConfig.prototype.field = function() {
+      return this._findConfig('field');
+    };
+
+    ActiveNodeConfig.prototype.hasField = function() {
+      return !!this.field();
+    };
+
+    ActiveNodeConfig.prototype.operator = function() {
+      return this._findConfig('operator') || 'equals';
+    };
+
+    ActiveNodeConfig.prototype._valueForNode = function(node) {
+      return node.value || node.name;
+    };
+
+    ActiveNodeConfig.prototype._findConfig = function(attrName) {
+      var activeNode, parentWithAttribute;
+      activeNode = this._activeNodes[0];
+      if (this._filter().type !== 'checkbox' && activeNode[attrName]) {
+        return activeNode[attrName];
+      } else {
+        parentWithAttribute = _.find(this._parents, function(node) {
+          return node[attrName];
+        });
+        return parentWithAttribute && parentWithAttribute[attrName];
+      }
+    };
+
+    ActiveNodeConfig.prototype._filter = function() {
+      return _.last(this._parents);
+    };
+
+    return ActiveNodeConfig;
+
+  })();
+
   models.CheckboxFilter = (function(_super) {
     __extends(CheckboxFilter, _super);
 
@@ -263,7 +416,7 @@
 
     function CheckboxOption(filter, name, filterDefinition) {
       CheckboxOption.__super__.constructor.call(this, filter, name, filterDefinition);
-      this.value = filterDefinition.value;
+      this.value = filterDefinition.value, this.preset = filterDefinition.preset;
       this.active = filterDefinition.selected;
     }
 
@@ -635,9 +788,95 @@
 
   })();
 
+  models.PresetBuilder = (function() {
+    var Preset;
+
+    Preset = (function() {
+      function Preset() {
+        this._errors = {};
+        this._values = {};
+        this._titles = {};
+      }
+
+      Preset.prototype.isValid = function() {
+        return _.keys(this.errors()).length === 0;
+      };
+
+      Preset.prototype.values = function() {
+        if (this.isValid()) {
+          return this._values;
+        } else {
+          throw new Error('#values can not be called on an invalid Preset');
+        }
+      };
+
+      Preset.prototype.errors = function() {
+        return this._errors;
+      };
+
+      Preset.prototype._addValue = function(key, value, title) {
+        if (this._values.hasOwnProperty(key)) {
+          return this._addError(key, this._titles[key], title);
+        } else {
+          this._values[key] = value;
+          return this._titles[key] = title;
+        }
+      };
+
+      Preset.prototype._addError = function(key, previouslySetValue, newValue) {
+        if (this._errors[key]) {
+          return this._errors[key].push(newValue);
+        } else {
+          return this._errors[key] = [previouslySetValue, newValue];
+        }
+      };
+
+      return Preset;
+
+    })();
+
+    function PresetBuilder(filter) {
+      this._collector = new models.ActiveFilterNodeCollector(filter);
+    }
+
+    PresetBuilder.prototype.generatePreset = function() {
+      var activeNodeConfigs, presetCollection;
+      presetCollection = new Preset();
+      activeNodeConfigs = this._collector.findActiveFilterItems();
+      _.each(activeNodeConfigs, (function(_this) {
+        return function(activeNodeConfig) {
+          var nodesWithPreset;
+          nodesWithPreset = _this._nodesWithPreset(activeNodeConfig);
+          return _.each(nodesWithPreset, function(filterNode) {
+            return _this._addPresetsForFilterNode(filterNode, presetCollection);
+          });
+        };
+      })(this));
+      return presetCollection;
+    };
+
+    PresetBuilder.prototype._nodesWithPreset = function(config) {
+      return _.select(config.activeNodes(), function(node) {
+        return node.preset;
+      });
+    };
+
+    PresetBuilder.prototype._addPresetsForFilterNode = function(node, presetCollection) {
+      return _.each(node.preset, function(value, key) {
+        if (value !== void 0) {
+          return presetCollection._addValue(key, value, node.title);
+        }
+      });
+    };
+
+    return PresetBuilder;
+
+  })();
+
   models.QueryBuilder = (function() {
     function QueryBuilder(filter, baseQuery) {
       this.filter = filter;
+      this._collector = new models.ActiveFilterNodeCollector(this.filter);
       if (baseQuery) {
         this._baseQuery = models.QueryBuilder.prepareQuery(baseQuery);
       }
@@ -646,56 +885,25 @@
     QueryBuilder.prototype.searchRequest = function() {
       var query;
       query = this._baseQuery;
-      query = this._addTreeFilterQuery(query);
-      query = this._addSearchTerm(query);
-      return this._addAdditionalFilters(query);
+      query = this._addFilterQueries(query);
+      return query = this._addSearchTermQuery(query);
     };
 
-    QueryBuilder.prototype._addAdditionalFilters = function(query) {
-      var activeChildren, combinedQuery, filter, searchQuery, _i, _len, _ref;
-      combinedQuery = query;
-      _ref = this.filter.additionalFilters;
+    QueryBuilder.prototype._addFilterQueries = function(baseQuery) {
+      var activeConfig, combinedQuery, searchQuery, _i, _len, _ref;
+      combinedQuery = baseQuery;
+      _ref = this._collector.findActiveFilterItems();
       for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-        filter = _ref[_i];
-        activeChildren = _.filter(filter.children, function(child) {
-          return child.isActive();
-        });
-        if (activeChildren.length > 0) {
-          searchQuery = this._buildActiveChildrenSearchQuery(activeChildren, filter);
-          if (searchQuery != null) {
-            combinedQuery = this._addOrCreateQuery(combinedQuery, searchQuery);
-          }
+        activeConfig = _ref[_i];
+        searchQuery = this._buildActiveChildrenSearchQuery(activeConfig);
+        if (searchQuery) {
+          combinedQuery = this._addOrCreateQuery(combinedQuery, searchQuery);
         }
       }
       return combinedQuery;
     };
 
-    QueryBuilder.prototype._buildActiveChildrenSearchQuery = function(activeChildren, filter) {
-      if (filter.type === 'checkbox') {
-        return this._buildFOVQuery(filter, activeChildren);
-      } else {
-        return this._buildRadioQuery(filter, activeChildren[0]);
-      }
-    };
-
-    QueryBuilder.prototype._buildRadioQuery = function(filter, activeChild) {
-      if (activeChild.query) {
-        return activeChild.query;
-      } else {
-        return this._buildFOVQuery(filter, [activeChild]);
-      }
-    };
-
-    QueryBuilder.prototype._buildFOVQuery = function(config, activeNodes) {
-      var operator, values;
-      values = _.flatten(_.map(activeNodes, function(node) {
-        return node.value || node.name;
-      }));
-      operator = config.operator || 'equals';
-      return scrivito.obj_where(config.field, operator, values);
-    };
-
-    QueryBuilder.prototype._addSearchTerm = function(query) {
+    QueryBuilder.prototype._addSearchTermQuery = function(query) {
       var searchQuery;
       if (this.filter.searchTerm && this.filter.searchTerm.length > 0) {
         searchQuery = scrivito.obj_where('*', 'contains_prefix', this.filter.searchTerm);
@@ -705,69 +913,17 @@
       }
     };
 
-    QueryBuilder.prototype._createQueryByActiveConfig = function(activeConfig) {
-      var field, operator;
-      if (activeConfig.node.query) {
-        return activeConfig.node.query;
+    QueryBuilder.prototype._buildActiveChildrenSearchQuery = function(activeConfig) {
+      if (activeConfig.hasQuery()) {
+        return activeConfig.query();
       } else {
-        field = this._findField(activeConfig);
-        if (field) {
-          operator = this._findOperator(activeConfig);
-          return this._buildFOVQuery({
-            field: field,
-            operator: operator
-          }, [activeConfig.node]);
-        }
+        return this._buildFOVQuery(activeConfig);
       }
     };
 
-    QueryBuilder.prototype._addTreeFilterQuery = function(baseQuery) {
-      var activeConfig, configuredQuery;
-      activeConfig = this._findActiveTreeFilterItem();
-      if (activeConfig) {
-        configuredQuery = this._createQueryByActiveConfig(activeConfig);
-        if (configuredQuery) {
-          return this._addOrCreateQuery(baseQuery, configuredQuery);
-        }
-      } else {
-        return baseQuery;
-      }
-    };
-
-    QueryBuilder.prototype._findActiveTreeFilterItem = function() {
-      var activeConfig, subFilter, treeFilter, _i, _j, _len, _len1, _ref, _ref1;
-      _ref = this.filter.getTreeFilters();
-      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-        treeFilter = _ref[_i];
-        _ref1 = treeFilter.subFilters;
-        for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
-          subFilter = _ref1[_j];
-          activeConfig = this._findActiveSubFilterItem(subFilter);
-          if (activeConfig) {
-            activeConfig.parents.push(treeFilter.config);
-            return activeConfig;
-          }
-        }
-      }
-    };
-
-    QueryBuilder.prototype._findActiveSubFilterItem = function(filterNode) {
-      var activeConfig, childNode, _i, _len, _ref;
-      if (filterNode.isActive()) {
-        return {
-          node: filterNode,
-          parents: []
-        };
-      } else {
-        _ref = filterNode.children;
-        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-          childNode = _ref[_i];
-          activeConfig = this._findActiveSubFilterItem(childNode);
-          if (activeConfig) {
-            activeConfig.parents.push(filterNode);
-            return activeConfig;
-          }
-        }
+    QueryBuilder.prototype._buildFOVQuery = function(activeConfig) {
+      if (activeConfig.hasField()) {
+        return scrivito.obj_where(activeConfig.field(), activeConfig.operator(), activeConfig.values());
       }
     };
 
@@ -779,26 +935,6 @@
       }
     };
 
-    QueryBuilder.prototype._findOperator = function(config) {
-      return this._findAttributeInConfig('operator', config);
-    };
-
-    QueryBuilder.prototype._findField = function(config) {
-      return this._findAttributeInConfig('field', config);
-    };
-
-    QueryBuilder.prototype._findAttributeInConfig = function(attributeName, config) {
-      var parentWithAttribute;
-      if (config.node[attributeName]) {
-        return config.node[attributeName];
-      } else {
-        parentWithAttribute = _.find(config.parents, function(node) {
-          return node[attributeName];
-        });
-        return parentWithAttribute && parentWithAttribute[attributeName];
-      }
-    };
-
     return QueryBuilder;
 
   })();
@@ -847,7 +983,7 @@
     function RadioOption(group, name, filterDefinition) {
       this.group = group;
       RadioOption.__super__.constructor.call(this, this.group.filter, name, filterDefinition);
-      this.value = filterDefinition.value, this.query = filterDefinition.query;
+      this.value = filterDefinition.value, this.query = filterDefinition.query, this.preset = filterDefinition.preset;
       this.active = filterDefinition.selected;
     }
 
@@ -870,7 +1006,7 @@
       var childrenDefinition;
       TreeFilter.__super__.constructor.call(this, filter, name, filterDefinition);
       this.type = 'tree';
-      this.icon = filterDefinition.icon, this.query = filterDefinition.query, this.expanded = filterDefinition.expanded, this.value = filterDefinition.value, this.field = filterDefinition.field, this.operator = filterDefinition.operator;
+      this.icon = filterDefinition.icon, this.query = filterDefinition.query, this.expanded = filterDefinition.expanded, this.value = filterDefinition.value, this.field = filterDefinition.field, this.operator = filterDefinition.operator, this.preset = filterDefinition.preset;
       this.active = filterDefinition.selected;
       childrenDefinition = filterDefinition.options || [];
       this.children = _.map(childrenDefinition, function(definition, name) {
@@ -890,7 +1026,7 @@
       return !!this.active;
     };
 
-    TreeFilter.prototype.toogleActive = function() {
+    TreeFilter.prototype.toggleActive = function() {
       if (this.isActive()) {
         this.active = false;
       } else {
@@ -920,12 +1056,12 @@
   models.UploadSet = (function(_super) {
     __extends(UploadSet, _super);
 
-    function UploadSet(preset) {
-      if (preset == null) {
-        preset = {};
+    function UploadSet(basePreset) {
+      if (basePreset == null) {
+        basePreset = {};
       }
       UploadSet.__super__.constructor.call(this);
-      this._preset = preset;
+      this._basePreset = basePreset;
       this._uploads = [];
     }
 
@@ -933,10 +1069,14 @@
       return this._uploads;
     };
 
-    UploadSet.prototype.addFiles = function(files) {
+    UploadSet.prototype.addFiles = function(files, presets) {
+      if (presets == null) {
+        presets = {};
+      }
+      presets = _.extend(_.clone(this._basePreset), presets);
       _.each(files, (function(_this) {
         return function(file) {
-          return _this._uploads.unshift(new models.ObjUpload(_this, file, _this._preset));
+          return _this._uploads.unshift(new models.ObjUpload(_this, file, presets));
         };
       })(this));
       return this.changed();
@@ -1028,9 +1168,9 @@
     },
     getInitialState: function() {
       var basePreset, initialSelection, selectionMode;
-      initialSelection = this.props.container.options.selection || [];
-      selectionMode = this.props.container.options.selection_mode;
-      basePreset = this.props.container.options.base_preset;
+      initialSelection = this.props.options.selection || [];
+      selectionMode = this.props.options.selection_mode;
+      basePreset = this.props.options.base_preset;
       return {
         filter: this.props.initialFilter,
         objs: [],
@@ -1059,11 +1199,12 @@
         "objCollection": this.state.objCollection,
         "viewMode": this.state.viewMode,
         "uploadSet": this.state.uploadSet,
-        "inspector": this.state.inspector
+        "inspector": this.state.inspector,
+        "filter": this.state.filter
       })), React.createElement(ui.Inspector, {
         "inspector": this.state.inspector
       })), React.createElement(ui.Footer, {
-        "container": this.props.container,
+        "promise": this.props.promise,
         "objCollection": this.state.objCollection
       }));
     }
@@ -1202,7 +1343,7 @@
     render: function() {
       return React.createElement("li", {
         "className": this.activeClassName(),
-        "onClick": this.optionLabelToogleClick
+        "onClick": this.optionLabelToggleClick
       }, React.createElement("div", {
         "className": "scrivito-content-browser-hierarchy-checkbox"
       }), this.renderOptionFilterTitle());
@@ -1248,7 +1389,7 @@
   ui.Filter.RadioOptionFilter = React.createClass({
     displayName: 'RadioOptionFilter',
     mixins: [OptionFilterMixin],
-    labelToogleClick: function() {
+    labelToggleClick: function() {
       if (!this.props.filter.isActive()) {
         return this.props.filter.setActive();
       }
@@ -1256,7 +1397,7 @@
     render: function() {
       return React.createElement("li", {
         "className": this.activeClassName(),
-        "onClick": this.labelToogleClick
+        "onClick": this.labelToggleClick
       }, React.createElement("div", {
         "className": "scrivito-content-browser-hierarchy-radio"
       }), this.renderOptionFilterTitle());
@@ -1326,8 +1467,8 @@
       }
       return _results;
     },
-    labelToogleClick: function() {
-      return this.props.filter.toogleActive();
+    labelToggleClick: function() {
+      return this.props.filter.toggleActive();
     },
     render: function() {
       var labelClasses;
@@ -1336,7 +1477,7 @@
         "className": labelClasses
       }, (!this.props.filter.isLeaf() ? this.renderArrowTag() : void 0), React.createElement("div", {
         "className": "scrivito-content-browser-hierarchy-label",
-        "onClick": this.labelToogleClick
+        "onClick": this.labelToggleClick
       }, this.renderIconTag(), React.createElement("span", null, this.props.filter.title)), (!this.props.filter.isLeaf() ? React.createElement("ul", null, this.renderSubTrees()) : void 0));
     }
   });
@@ -1347,12 +1488,10 @@
       return this.props.objCollection.selectedObjs().length;
     },
     cancelClick: function() {
-      this.props.container._promise.reject();
-      return this.props.container.close();
+      return this.props.promise.reject();
     },
     doneClick: function() {
-      this.props.container._promise.resolve(this.props.objCollection.selectedObjs());
-      return this.props.container.close();
+      return this.props.promise.resolve(this.props.objCollection.selectedObjs());
     },
     deleteClick: function() {
       return this.props.objCollection.destroySelectedObjs();
@@ -1422,7 +1561,7 @@
       });
     },
     uploadFiles: function(event) {
-      var dataTransfer, files;
+      var dataTransfer, files, message, preset;
       this.changeDragState(false)(event);
       dataTransfer = event.dataTransfer;
       if (dataTransfer == null) {
@@ -1430,9 +1569,23 @@
       }
       files = dataTransfer.files;
       if (files.length > 0) {
-        return this.props.uploadSet.addFiles(files);
+        preset = this.buildPreset();
+        if (preset.isValid()) {
+          return this.props.uploadSet.addFiles(files, preset.values());
+        } else {
+          message = 'The selected filter options cannot be applied to the file(s) you wanted to upload. Please select only one of the following options, then try again:\n';
+          _.each(preset.errors(), function(values, field) {
+            return message += "\n" + field + ": " + (values.join(', '));
+          });
+          return alert(message);
+        }
       }
     },
+    buildPreset: function() {
+      var presetBuilder;
+      presetBuilder = new models.PresetBuilder(this.props.filter);
+      return presetBuilder.generatePreset();
+    },
     changeDragState: function(toValue) {
       return (function(_this) {
         return function(event) {

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scrivito_content_browser
 version: !ruby/object:Gem::Version
-  version: 0.40.0
+  version: 0.41.0.rc1
 platform: ruby
 authors:
 - Scrivito
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-26 00:00:00.000000000 Z
+date: 2015-02-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: coffee-rails
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.40.0
+        version: 0.41.0.rc1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.40.0
+        version: 0.41.0.rc1
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement