decidim 0.4.4 → 0.5.0

data/decidim-core/lib/decidim/notifiable.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  # Shared behaviour for notifiable models.
+  module Notifiable
+    extend ActiveSupport::Concern
+
+    included do
+      # Public: Whether the object is notifiable or not.
+      def notifiable?(_context)
+        true
+      end
+
+      # Public: A collection of users to send the notifications.
+      def users_to_notify
+        []
+      end
+    end
+  end
+end

data/decidim-core/lib/decidim/page_finder.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Decidim
+  # A custom implementation for HighVoltage so we can correctly find which page
+  # to render. We need this because we allow rendering pages with content from
+  # the database (with Decidim::Page) but also fallback to a template if it
+  # exists.
+  class PageFinder < HighVoltage::PageFinder
+    DECIDIM_PAGE_TEMPLATE = "decidim_page"
+
+    # Initializes the finder.
+    #
+    # page_id - A String with the id or slug of the page to render.
+    # organization - A Decidim::Organization to look for pages in.
+    def initialize(page_id, organization)
+      @page_id = page_id
+      @organization = organization
+    end
+
+    # Finds a Decidim::Page by slug.
+    #
+    # Returns a Decidim::Page or nil.
+    def page
+      @page ||= organization.static_pages.where(slug: page_id).first
+    end
+
+    private
+
+    attr_reader :organization
+
+    # Overwrite HighVoltage::PageFinder method to return a specific template
+    # when we need to render a Decidim::Page.
+    #
+    # Returns a String.
+    def clean_path
+      return super unless page.present?
+
+      DECIDIM_PAGE_TEMPLATE
+    end
+
+    # Overwrite HighVoltage::PageFinder method to not allow rendering the
+    # template used to render Decidim::Pages without a page.
+    #
+    # Returns a Boolean.
+    def invalid_page_id?(id)
+      super || id == DECIDIM_PAGE_TEMPLATE
+    end
+  end
+end

data/decidim-core/lib/decidim/publicable.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  # This concern contains the logic related to publication and promotion.
+  module Publicable
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # Public: Scope to return only published records.
+      #
+      # Returns an ActiveRecord::Relation.
+      def published
+        where.not(published_at: nil)
+      end
+
+      # Public: Scope to return only unpublished records.
+      #
+      # Returns an ActiveRecord::Relation.
+      def unpublished
+        where(published_at: nil)
+      end
+    end
+
+    # Public: Checks whether the record has been published or not.
+    #
+    # Returns true if published, false otherwise.
+    def published?
+      published_at.present?
+    end
+
+    #
+    # Public: Publishes this feature
+    #
+    # Returns true if the record was properly saved, false otherwise.
+    def publish!
+      update_attribute(:published_at, Time.current)
+    end
+
+    #
+    # Public: Unpublishes this feature
+    #
+    # Returns true if the record was properly saved, false otherwise.
+    def unpublish!
+      update_attribute(:published_at, nil)
+    end
+  end
+end

data/decidim-core/lib/decidim/query_extensions.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Decidim
+  # This module's job is to extend the API with custom fields related to
+  # decidim-core.
+  module QueryExtensions
+    # Public: Extends a type with `decidim-core`'s fields.
+    #
+    # type - A GraphQL::BaseType to extend.
+    #
+    # Returns nothing.
+    def self.extend!(type)
+      type.define do
+        field :processes do
+          type !types[ProcessType]
+          description "Lists all processes."
+
+          resolve lambda { |_obj, _args, ctx|
+            OrganizationPublishedParticipatoryProcesses.new(ctx[:current_organization])
+          }
+        end
+
+        field :session do
+          type SessionType
+          description "Return's information about the logged in user"
+
+          resolve lambda { |_obj, _args, ctx|
+            ctx[:current_user]
+          }
+        end
+
+        field :decidim, DecidimType, "Decidim's framework properties." do
+          resolve ->(_obj, _args, _ctx) { Decidim }
+        end
+      end
+    end
+  end
+end

data/decidim-core/lib/decidim/reportable.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  # A concern with the features needed when you want a model to be reportable
+  module Reportable
+    extend ActiveSupport::Concern
+
+    included do
+      has_one :moderation, as: :reportable, foreign_key: "decidim_reportable_id", foreign_type: "decidim_reportable_type", class_name: "Decidim::Moderation"
+      has_many :reports, through: :moderation
+
+      scope :reported, -> { left_outer_joins(:moderation).where(Decidim::Moderation.arel_table[:report_count].gt(0)) }
+      scope :hidden, -> { left_outer_joins(:moderation).where.not(Decidim::Moderation.arel_table[:hidden_at].eq nil) }
+      scope :not_hidden, -> { left_outer_joins(:moderation).where(Decidim::Moderation.arel_table[:hidden_at].eq nil) }
+
+      # Public: Check if the user has reported the reportable.
+      #
+      # Returns Boolean.
+      def reported_by?(user)
+        reports.where(user: user).any?
+      end
+
+      # Public: Checks if the reportable is hidden or not.
+      #
+      # Returns Boolean.
+      def hidden?
+        moderation&.hidden_at&.present?
+      end
+
+      # Public: Checks if the reportable has been reported or not.
+      #
+      # Returns Boolean.
+      def reported?
+        moderation&.report_count&.positive?
+      end
+
+      # Public: The reported content url
+      #
+      # Returns String
+      def reported_content_url
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/decidim-core/lib/decidim/resource_manifest.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Decidim
+  # Features inside a component can expose different Resources, these resources
+  # will be used to be linked between each other and other possible features.
+  #
+  # This class sets a scheme to expose these resources. It shouldn't be
+  # used directly, you should use `register_resource` inside a feature.
+  #
+  # Example:
+  #   feature.register_resource do |resource|
+  #     resource.model_class = Decidim::MyEngine::MyModel
+  #     resource.template    = "decidim/myengine/myengine/linked_models"
+  #   end
+  #
+  class ResourceManifest
+    include ActiveModel::Model
+    include Virtus.model
+
+    # The name of the resource we are exposing.
+    attribute :name, String
+
+    # The parent feature manifest
+    attribute :feature_manifest, Decidim::FeatureManifest
+
+    # The ActiveRecord class name of the model we're exposing
+    attribute :model_class_name, String
+
+    # The name of the named Rails route to create the url to the resource.
+    # When not explicitly set, it will use the model name.
+    attribute :route_name, String
+
+    # The template to use to render the collection of a resource.
+    attribute :template, String
+
+    validates :feature_manifest, :model_class_name, :route_name, presence: true
+
+    # Finds an ActiveRecord::Relation of the resource `model_class`, scoped to the
+    # given feature. This way you can find resources from another engine without
+    # actually coupling both engines.
+    #
+    # feature - a Decidim::Feature
+    #
+    # Returns an ActiveRecord::Relation.
+    def resource_scope(feature)
+      feature_ids = Decidim::Feature.where(participatory_process: feature.participatory_process, manifest_name: feature_manifest.name).pluck(:id)
+      return model_class.none if feature_ids.empty?
+
+      model_class.where(feature: feature_ids)
+    end
+
+    # Finds the current class with the given `model_class_name`
+    # in order to avoid problems with Rails' autoloading.
+    #
+    # Returns a class.
+    def model_class
+      model_class_name.constantize
+    end
+
+    # The name of the resource we are exposing.
+    #
+    # Returns a String.
+    def name
+      super || model_class_name.demodulize.underscore.pluralize.to_sym
+    end
+
+    # The name of the named Rails route to create the url to the resource.
+    #
+    # Returns a String.
+    def route_name
+      super || model_class_name.demodulize.underscore
+    end
+  end
+end

data/decidim-core/lib/decidim/resourceable.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  # A concern with the features needed when you want a model to be able to create
+  # links from it to another resource.
+  module Resourceable
+    extend ActiveSupport::Concern
+
+    included do
+      # An association with all the links that point to this model.
+      has_many :resource_links_to, as: :to, class_name: "Decidim::ResourceLink"
+
+      # An association with all the links that are originated from this model.
+      has_many :resource_links_from, as: :from, class_name: "Decidim::ResourceLink"
+
+      # Finds all the linked resources to or from this model for a given resource
+      # name and link name.
+      #
+      # resource_name - The String name of the resource manifest exposed by a feature.
+      # link_name     - The String name of the link between this model and the target resource.
+      #
+      # Returns an ActiveRecord::Relation.
+      def linked_resources(resource_name, link_name)
+        scope = sibling_scope(resource_name)
+
+        from = scope
+               .joins(:resource_links_from)
+               .where(decidim_resource_links: { name: link_name, to_id: id, to_type: self.class.name })
+
+        to = scope
+             .joins(:resource_links_to)
+             .where(decidim_resource_links: { name: link_name, from_id: id, from_type: self.class.name })
+
+        scope.where(id: from).or(scope.where(id: to)).distinct
+      end
+
+      # Builds an ActiveRecord::Relation in order to load all the resources
+      # that are in the same parent as this model.
+      #
+      # resource_name - The String name of the resource manifest exposed by a feature.
+      #
+      # Returns an ActiveRecord::Relation.
+      def sibling_scope(resource_name)
+        manifest = Decidim.find_resource_manifest(resource_name)
+        return self.class.none unless manifest
+
+        scope = manifest.resource_scope(feature)
+        scope = scope.where("#{self.class.table_name}.id != ?", id) if manifest.model_class == self.class
+
+        scope
+      end
+
+      # Links the given resources to this model, replaces any previous links with the same name.
+      #
+      # resources - An Array or ActiveRecord::Base object to link to.
+      # link_name - The String name to use as the name between the resources.
+      # data      - An optional Hash to add to the link.
+      #
+      # Returns nothing.
+      def link_resources(resources, link_name, data = {})
+        transaction do
+          resource_links_from.where(name: link_name).delete_all
+          Array.wrap(resources).each do |resource|
+            Decidim::ResourceLink.create!(
+              from: self,
+              to: resource,
+              name: link_name,
+              data: data
+            )
+          end
+        end
+      end
+    end
+
+    class_methods do
+      # Finds the name of the classes that have been linked to this model for the given
+      # `feature`.
+      #
+      # feature - a Decidim::Feature instance where the links will be scoped to.
+      #
+      # Returns an Array of Strings.
+      def linked_classes_for(feature)
+        scope = where(feature: feature)
+
+        from = scope
+               .joins(:resource_links_from)
+               .where(decidim_resource_links: { from_type: name })
+
+        to = scope
+             .joins(:resource_links_to)
+             .where(decidim_resource_links: { to_type: name })
+
+        ResourceLink
+          .where(from: from)
+          .or(ResourceLink.where(to: to))
+          .pluck(:from_type, :to_type)
+          .flatten
+          .uniq
+          .reject { |k| k == name }
+      end
+
+      # Finds the resource manifest for the model.
+      #
+      # Returns a Decidim::ResourceManifest
+      def resource_manifest
+        Decidim.find_resource_manifest(self)
+      end
+    end
+  end
+end

data/decidim-core/lib/decidim/scopable.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  # This concern contains the logic related to scopes.
+  module Scopable
+    extend ActiveSupport::Concern
+
+    included do
+      belongs_to :scope,
+                 foreign_key: "decidim_scope_id",
+                 class_name: "Decidim::Scope",
+                 optional: true
+    end
+
+    # Gets the children scopes of the object's scope.
+    #
+    # If it's global, returns the organization's top scopes.
+    #
+    # Returns an ActiveRecord::Relation.
+    def subscopes
+      scope ? scope.children : organization.top_scopes
+    end
+
+    # Whether the resource has subscopes or not.
+    #
+    # Returns a boolean.
+    def has_subscopes?
+      scopes_enabled && subscopes.any?
+    end
+  end
+end

data/decidim-core/lib/decidim/settings_manifest.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Decidim
+  # This class serves as a DSL that enables specifying an arbitrary settings
+  # to a feature, so the admin panel can show a standarized UI to configure them.
+  #
+  class SettingsManifest
+    attr_reader :attributes
+
+    # Initializes a SettingsManifest.
+    def initialize
+      @attributes = {}
+    end
+
+    # Public: Adds a new attribute field to the SettingsManifest.
+    #
+    # name - The name of the attribute to inject.
+    # options - A set of options to configure the attribute.
+    #           :type - The type of the attribute as found in Attribute::TYPES
+    #           :default - The default value of this settings field.
+    #
+    # Returns nothing.
+    def attribute(name, options = {})
+      attribute = Attribute.new(options)
+      attribute.validate!
+      @attributes[name.to_sym] = attribute
+
+      @schema = nil
+    end
+
+    # Public: Creates a model Class that sanitizes, coerces and filters data to
+    # the right types given a hash of serialized information.
+    #
+    # Returns a Class.
+    def schema
+      return @schema if @schema
+
+      manifest = self
+
+      @schema = Class.new do
+        include Virtus.model
+        include ActiveModel::Validations
+        include TranslatableAttributes
+
+        cattr_accessor :manifest
+
+        def self.model_name
+          ActiveModel::Name.new(self, nil, "Settings")
+        end
+
+        def manifest
+          self.class.manifest
+        end
+
+        def ==(other)
+          other.attributes == attributes
+        end
+
+        manifest.attributes.each do |name, attribute|
+          if attribute.translated?
+            translatable_attribute name, attribute.type_class, default: attribute.default_value
+            validates name, translatable_presence: true
+          else
+            attribute name, attribute.type_class, default: attribute.default_value
+            validates name, presence: true
+          end
+        end
+      end
+
+      @schema.manifest = self
+      @schema
+    end
+
+    # Semi-private: Attributes are an abstraction used by SettingsManifest
+    # to encapsulate behavior related to each individual settings field. Shouldn't
+    # be used from the outside.
+    class Attribute
+      include Virtus.model
+      include ActiveModel::Validations
+
+      TYPES = {
+        boolean: { klass: Boolean, default: false },
+        integer: { klass: Integer, default: 0 },
+        string: { klass: String, default: nil },
+        text: { klass: String, default: nil }
+      }.freeze
+
+      attribute :type, Symbol, default: :boolean
+      attribute :default
+      attribute :translated, Boolean, default: false
+      attribute :editor, Boolean, default: false
+
+      validates :type, inclusion: { in: TYPES.keys }
+
+      def type_class
+        TYPES[type][:klass]
+      end
+
+      def default_value
+        default || TYPES[type][:default]
+      end
+    end
+  end
+end