decidim 0.0.1 → 0.0.2

data/decidim-dev/lib/decidim/dev/test/rspec_support/phantomjs_polyfills/promise.js

@@ -0,0 +1,233 @@
+(function (root) {
+
+  // Store setTimeout reference so promise-polyfill will be unaffected by
+  // other code modifying setTimeout (like sinon.useFakeTimers())
+  var setTimeoutFunc = setTimeout;
+
+  function noop() {}
+  
+  // Polyfill for Function.prototype.bind
+  function bind(fn, thisArg) {
+    return function () {
+      fn.apply(thisArg, arguments);
+    };
+  }
+
+  function Promise(fn) {
+    if (typeof this !== 'object') throw new TypeError('Promises must be constructed via new');
+    if (typeof fn !== 'function') throw new TypeError('not a function');
+    this._state = 0;
+    this._handled = false;
+    this._value = undefined;
+    this._deferreds = [];
+
+    doResolve(fn, this);
+  }
+
+  function handle(self, deferred) {
+    while (self._state === 3) {
+      self = self._value;
+    }
+    if (self._state === 0) {
+      self._deferreds.push(deferred);
+      return;
+    }
+    self._handled = true;
+    Promise._immediateFn(function () {
+      var cb = self._state === 1 ? deferred.onFulfilled : deferred.onRejected;
+      if (cb === null) {
+        (self._state === 1 ? resolve : reject)(deferred.promise, self._value);
+        return;
+      }
+      var ret;
+      try {
+        ret = cb(self._value);
+      } catch (e) {
+        reject(deferred.promise, e);
+        return;
+      }
+      resolve(deferred.promise, ret);
+    });
+  }
+
+  function resolve(self, newValue) {
+    try {
+      // Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure
+      if (newValue === self) throw new TypeError('A promise cannot be resolved with itself.');
+      if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {
+        var then = newValue.then;
+        if (newValue instanceof Promise) {
+          self._state = 3;
+          self._value = newValue;
+          finale(self);
+          return;
+        } else if (typeof then === 'function') {
+          doResolve(bind(then, newValue), self);
+          return;
+        }
+      }
+      self._state = 1;
+      self._value = newValue;
+      finale(self);
+    } catch (e) {
+      reject(self, e);
+    }
+  }
+
+  function reject(self, newValue) {
+    self._state = 2;
+    self._value = newValue;
+    finale(self);
+  }
+
+  function finale(self) {
+    if (self._state === 2 && self._deferreds.length === 0) {
+      Promise._immediateFn(function() {
+        if (!self._handled) {
+          Promise._unhandledRejectionFn(self._value);
+        }
+      });
+    }
+
+    for (var i = 0, len = self._deferreds.length; i < len; i++) {
+      handle(self, self._deferreds[i]);
+    }
+    self._deferreds = null;
+  }
+
+  function Handler(onFulfilled, onRejected, promise) {
+    this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;
+    this.onRejected = typeof onRejected === 'function' ? onRejected : null;
+    this.promise = promise;
+  }
+
+  /**
+   * Take a potentially misbehaving resolver function and make sure
+   * onFulfilled and onRejected are only called once.
+   *
+   * Makes no guarantees about asynchrony.
+   */
+  function doResolve(fn, self) {
+    var done = false;
+    try {
+      fn(function (value) {
+        if (done) return;
+        done = true;
+        resolve(self, value);
+      }, function (reason) {
+        if (done) return;
+        done = true;
+        reject(self, reason);
+      });
+    } catch (ex) {
+      if (done) return;
+      done = true;
+      reject(self, ex);
+    }
+  }
+
+  Promise.prototype['catch'] = function (onRejected) {
+    return this.then(null, onRejected);
+  };
+
+  Promise.prototype.then = function (onFulfilled, onRejected) {
+    var prom = new (this.constructor)(noop);
+
+    handle(this, new Handler(onFulfilled, onRejected, prom));
+    return prom;
+  };
+
+  Promise.all = function (arr) {
+    var args = Array.prototype.slice.call(arr);
+
+    return new Promise(function (resolve, reject) {
+      if (args.length === 0) return resolve([]);
+      var remaining = args.length;
+
+      function res(i, val) {
+        try {
+          if (val && (typeof val === 'object' || typeof val === 'function')) {
+            var then = val.then;
+            if (typeof then === 'function') {
+              then.call(val, function (val) {
+                res(i, val);
+              }, reject);
+              return;
+            }
+          }
+          args[i] = val;
+          if (--remaining === 0) {
+            resolve(args);
+          }
+        } catch (ex) {
+          reject(ex);
+        }
+      }
+
+      for (var i = 0; i < args.length; i++) {
+        res(i, args[i]);
+      }
+    });
+  };
+
+  Promise.resolve = function (value) {
+    if (value && typeof value === 'object' && value.constructor === Promise) {
+      return value;
+    }
+
+    return new Promise(function (resolve) {
+      resolve(value);
+    });
+  };
+
+  Promise.reject = function (value) {
+    return new Promise(function (resolve, reject) {
+      reject(value);
+    });
+  };
+
+  Promise.race = function (values) {
+    return new Promise(function (resolve, reject) {
+      for (var i = 0, len = values.length; i < len; i++) {
+        values[i].then(resolve, reject);
+      }
+    });
+  };
+
+  // Use polyfill for setImmediate for performance gains
+  Promise._immediateFn = (typeof setImmediate === 'function' && function (fn) { setImmediate(fn); }) ||
+    function (fn) {
+      setTimeoutFunc(fn, 0);
+    };
+
+  Promise._unhandledRejectionFn = function _unhandledRejectionFn(err) {
+    if (typeof console !== 'undefined' && console) {
+      console.warn('Possible Unhandled Promise Rejection:', err); // eslint-disable-line no-console
+    }
+  };
+
+  /**
+   * Set the immediate function to execute callbacks
+   * @param fn {function} Function to execute
+   * @deprecated
+   */
+  Promise._setImmediateFn = function _setImmediateFn(fn) {
+    Promise._immediateFn = fn;
+  };
+
+  /**
+   * Change the function to execute on unhandled rejection
+   * @param {function} fn Function to execute on unhandled rejection
+   * @deprecated
+   */
+  Promise._setUnhandledRejectionFn = function _setUnhandledRejectionFn(fn) {
+    Promise._unhandledRejectionFn = fn;
+  };
+  
+  if (typeof module !== 'undefined' && module.exports) {
+    module.exports = Promise;
+  } else if (!root.Promise) {
+    root.Promise = Promise;
+  }
+
+})(this);

data/decidim-dev/lib/generators/decidim/dummy_generator.rb

@@ -49,8 +49,8 @@ module Decidim
         end
       end
 
-      def bullet
-        template "bullet.rb", "#{dummy_path}/config/initializers/bullet.rb"
+      def decidim_dev
+        template "decidim_dev.rb", "#{dummy_path}/config/initializers/decidim_dev.rb"
       end
 
       private

data/decidim-dev/lib/generators/decidim/templates/decidim_dev.rb

@@ -0,0 +1,2 @@
+# frozen_string_literal: true
+require "decidim/dev"

data/decidim-meetings/Rakefile

@@ -1,2 +1,2 @@
 # frozen_string_literal: true
-require "decidim/common_rake"
+require "decidim/dev/common_rake"

data/decidim-meetings/app/assets/images/decidim/meetings/icon.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 36.02 36.02"><path d="M693.07,543.84a18,18,0,1,1,18-18A18,18,0,0,1,693.07,543.84Zm0-34a16,16,0,1,0,16,16A16,16,0,0,0,693.07,509.83Z" transform="translate(-675.07 -507.83)"/><path d="M693.07,526.93a4.1,4.1,0,1,1,4.1-4.1A4.1,4.1,0,0,1,693.07,526.93Zm0-6.19a2.1,2.1,0,1,0,2.1,2.1A2.1,2.1,0,0,0,693.07,520.74Z" transform="translate(-675.07 -507.83)"/><path d="M693.07,536.65a1,1,0,0,1-.67-0.26c-0.29-.26-7.11-6.5-7.11-14a7.78,7.78,0,0,1,15.57,0c0,7.46-6.82,13.71-7.11,14A1,1,0,0,1,693.07,536.65Zm0-20a5.79,5.79,0,0,0-5.78,5.78c0,5.29,4.13,10.11,5.78,11.82,1.65-1.72,5.78-6.54,5.78-11.82A5.79,5.79,0,0,0,693.07,516.64Z" transform="translate(-675.07 -507.83)"/></svg>

data/decidim-meetings/app/commands/decidim/meetings/admin/create_meeting.rb

@@ -23,6 +23,8 @@ module Decidim
 
         def create_meeting
           Meeting.create!(
+            scope: @form.scope,
+            category: @form.category,
             title: @form.title,
             short_description: @form.short_description,
             description: @form.description,

data/decidim-meetings/app/commands/decidim/meetings/admin/update_meeting.rb

@@ -28,6 +28,8 @@ module Decidim
 
         def update_meeting
           @meeting.update_attributes!(
+            scope: @form.scope,
+            category: @form.category,
             title: @form.title,
             short_description: @form.short_description,
             description: @form.description,

data/decidim-meetings/app/controllers/decidim/meetings/meetings_controller.rb

@@ -2,23 +2,47 @@
 
 module Decidim
   module Meetings
-    # This controller is the abstract class from which all other controllers of
-    # this engine inherit.
-    #
-    # Note that it inherits from `Decidim::Features::BaseController`, which
-    # override its layout and provide all kinds of useful methods.
+    # Exposes the meeting resource so users can view them
     class MeetingsController < Decidim::Meetings::ApplicationController
+      include FilterResource
+
       helper_method :meetings, :meeting
 
+      def index; end
+
       private
 
       def meetings
-        @meetings ||= Meeting.where(decidim_feature_id: current_feature.id).order(start_time: :asc)
+        @meetings ||= search.results
       end
 
       def meeting
         @meeting ||= meetings.find(params[:id])
       end
+
+      def search_klass
+        MeetingSearch
+      end
+
+      def default_search_params
+        {
+          page: params[:page],
+          per_page: 12
+        }
+      end
+
+      def default_filter_params
+        {
+          order_start_time: "asc",
+          search_text: "",
+          scope_id: "",
+          category_id: ""
+        }
+      end
+
+      def context_params
+        { feature: current_feature, organization: current_organization }
+      end
     end
   end
 end

data/decidim-meetings/app/forms/decidim/meetings/admin/meeting_form.rb

@@ -14,6 +14,8 @@ module Decidim
         attribute :address, String
         attribute :start_time, DateTime
         attribute :end_time, DateTime
+        attribute :decidim_scope_id, Integer
+        attribute :decidim_category_id, Integer
 
         validates :title, translatable_presence: true
         validates :short_description, translatable_presence: true
@@ -24,6 +26,18 @@ module Decidim
         validates :end_time, presence: true, date: { after: :start_time }
 
         validates :current_feature, presence: true
+        validates :scope, presence: true, if: ->(form) { form.decidim_scope_id.present? }
+        validates :category, presence: true, if: ->(form) { form.decidim_category_id.present? }
+
+        def scope
+          return unless current_feature
+          @scope ||= current_feature.scopes.where(id: decidim_scope_id).first
+        end
+
+        def category
+          return unless current_feature
+          @category ||= current_feature.categories.where(id: decidim_category_id).first
+        end
       end
     end
   end

data/decidim-meetings/app/helpers/decidim/meetings/application_helper.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+module Decidim
+  module Meetings
+    # Custom helpers, scoped to the meetings engine.
+    #
+    module ApplicationHelper
+      include PaginateHelper
+    end
+  end
+end

data/decidim-meetings/app/models/decidim/meetings/meeting.rb

@@ -5,8 +5,25 @@ module Decidim
     # title, description and any other useful information to render a custom meeting.
     class Meeting < Meetings::ApplicationRecord
       belongs_to :feature, foreign_key: "decidim_feature_id", class_name: Decidim::Feature
-
+      belongs_to :scope, foreign_key: "decidim_scope_id", class_name: Decidim::Scope
+      belongs_to :category, foreign_key: "decidim_category_id", class_name: Decidim::Category
+      has_one :organization, through: :feature
       validates :title, presence: true
+
+      validate :scope_belongs_to_organization
+      validate :category_belongs_to_organization
+
+      private
+
+      def scope_belongs_to_organization
+        return unless scope
+        errors.add(:scope, :invalid) unless feature.scopes.where(id: scope.id).exists?
+      end
+
+      def category_belongs_to_organization
+        return unless category
+        errors.add(:category, :invalid) unless feature.categories.where(id: category.id).exists?
+      end
     end
   end
 end

data/decidim-meetings/app/services/decidim/meetings/meeting_search.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+module Decidim
+  module Meetings
+    # This class handles search and filtering of meetings. Needs a
+    # `current_feature` param with a `Decidim::Feature` in order to
+    # find the meetings.
+    class MeetingSearch < ResourceSearch
+      # Public: Initializes the service.
+      # feature     - A Decidim::Feature to get the meetings from.
+      # page        - The page number to paginate the results.
+      # per_page    - The number of proposals to return per page.
+      def initialize(options = {})
+        super(Meeting.all, options)
+      end
+
+      # Handle the search_text filter
+      def search_search_text
+        query
+          .where(localized_search_text_in(:title), text: "%#{search_text}%")
+          .or(query.where(localized_search_text_in(:description), text: "%#{search_text}%"))
+          .or(query.where(localized_search_text_in(:short_description), text: "%#{search_text}%"))
+      end
+
+      # Handle the order_start_time filter
+      def search_order_start_time
+        query.order(start_time: order_start_time)
+      end
+
+      # Handle the scope_id filter
+      def search_scope_id
+        query.where(decidim_scope_id: scope_id)
+      end
+
+      private
+
+      # Internal: builds the needed query to search for a text in the organization's
+      # available locales. Note that it is intended to be used as follows:
+      #
+      # Example:
+      #   Resource.where(localized_search_text_for(:title, text: "my_query"))
+      #
+      # The Hash with the `:text` key is required or it won't work.
+      def localized_search_text_in(field)
+        options[:organization].available_locales.map { |l| "#{field} ->> '#{l}' ILIKE :text" }.join(" OR ")
+      end
+    end
+  end
+end