decidim-core 0.19.1 → 0.23.0

data/lib/decidim/acts_as_author.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Decidim
+  # This concern contains the logic related to being an author.
+  #
+  # it mainly declares abstract methods to be implemented by artifacts
+  # including it in its inheritance hierarchy.
+  #
+  module ActsAsAuthor
+    extend ActiveSupport::Concern
+
+    included do
+      # Authors of Authorables must provide its presenters.
+      #
+      # Return: The presenter for the current author.
+      def presenter
+        raise NotImlementedError, "Authors must return an instance of its Presenter via this method."
+      end
+    end
+  end
+end

data/lib/decidim/amendable.rb

@@ -127,16 +127,16 @@ module Decidim
     # Returns the emendations of an amendable that are visible to the user
     # based on the component's amendments settings and filtering out the "drafts".
     def visible_emendations_for(user)
-      pubslished_emendations = emendations.published
-      return pubslished_emendations unless component.settings.amendments_enabled
+      published_emendations = emendations.published
+      return published_emendations unless component.settings.amendments_enabled
 
       case component.current_settings.amendments_visibility
       when "participants"
         return self.class.none unless user
 
-        pubslished_emendations.where("decidim_amendments.decidim_user_id = ?", user.id)
+        published_emendations.where("decidim_amendments.decidim_user_id = ?", user.id)
       else # Assume 'all'
-        pubslished_emendations
+        published_emendations
       end
     end
 
@@ -160,6 +160,9 @@ module Decidim
       end
     end
 
+    # Callback called when amendment state is updated
+    def process_amendment_state_change!; end
+
     # Returns an Array of Decidim::User.
     def notifiable_identities
       if is_a?(Decidim::Authorable)

data/lib/decidim/api/amendable_entity_interface.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Core
+    # This interface should be implemented by any Type that can be used as amendment
+    # The only requirement is to have an ID and the Type name be the class.name + Type
+    AmendableEntityInterface = GraphQL::InterfaceType.define do
+      name "AmendableEntityInterface"
+      description "An interface that can be used in objects with amendments"
+
+      field :id, !types.ID, "ID of this entity"
+
+      resolve_type ->(obj, _ctx) {
+        "#{obj.class.name}Type".constantize
+      }
+    end
+  end
+end

data/lib/decidim/api/amendable_interface.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Core
+    # This interface represents an amendable object.
+    AmendableInterface = GraphQL::InterfaceType.define do
+      name "AmendableInterface"
+      description "An interface that can be used in objects with amendments"
+
+      field :amendments, !types[Decidim::Core::AmendmentType] do
+        description "This object's amendments"
+        resolve lambda { |obj, _args, ctx|
+          obj.visible_amendments_for(ctx[:current_user])
+        }
+      end
+    end
+  end
+end

data/lib/decidim/api/attachable_interface.rb

@@ -2,7 +2,7 @@
 
 module Decidim
   module Core
-    # This interface represents a commentable object.
+    # This interface represents a attachable object.
     AttachableInterface = GraphQL::InterfaceType.define do
       name "AttachableInterface"
       description "An interface that can be used in objects with attachments"

data/lib/decidim/api/author_interface.rb

@@ -7,12 +7,16 @@ module Decidim
       name "Author"
       description "An author"
 
+      field :id, !types.ID, "The author ID"
       field :name, !types.String, "The author's name"
       field :nickname, !types.String, "The author's nickname"
 
       field :avatarUrl, !types.String, "The author's avatar url"
       field :profilePath, !types.String, "The author's profile path"
       field :badge, !types.String, "The author's badge icon"
+      field :organizationName, !types.String, "The authors's organization name" do
+        resolve ->(obj, _args, _ctx) { obj.organization.name }
+      end
 
       field :deleted, !types.Boolean, "Whether the author's account has been deleted or not"
 

data/lib/decidim/api/categorizable_interface.rb

@@ -2,7 +2,7 @@
 
 module Decidim
   module Core
-    # This interface represents a commentable object.
+    # This interface represents a categorizable object.
     CategorizableInterface = GraphQL::InterfaceType.define do
       name "CategorizableInterface"
       description "An interface that can be used in categorizable objects."

data/lib/decidim/api/coauthorable_interface.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Core
+    # This interface represents a coauthorable object.
+    CoauthorableInterface = GraphQL::InterfaceType.define do
+      name "CoauthorableInterface"
+      description "An interface that can be used in coauthorable objects."
+
+      field :authorsCount, types.Int do
+        description "The total amount of co-authors that contributed to the proposal. Note that this field may include also non-user authors like meetings or the organization"
+        property :coauthorships_count
+      end
+
+      field :author, Decidim::Core::AuthorInterface do
+        description "The resource author. Note that this can be null on official proposals or meeting-proposals"
+        resolve ->(resource, _, _) {
+          author = resource.creator_identity
+          author if author.is_a?(Decidim::User) || author.is_a?(Decidim::UserGroup)
+        }
+      end
+
+      field :authors, !types[Decidim::Core::AuthorInterface] do
+        description "The resource co-authors. Include only users or groups of users"
+        property :user_identities
+      end
+    end
+  end
+end

data/lib/decidim/api/endorsable_interface.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Core
+    # This interface represents an object capable of endorsements.
+    EndorsableInterface = GraphQL::InterfaceType.define do
+      name "EndorsableInterface"
+      description "An interface that can be used in objects with endorsements"
+
+      field :endorsements, !types[Decidim::Core::AuthorInterface], "The endorsements of this object." do
+        resolve ->(object, _, _) {
+          object.endorsements.map(&:normalized_author)
+        }
+      end
+
+      field :endorsementsCount, types.Int do
+        description "The total amount of endorsements the object has received"
+        property :endorsements_count
+      end
+    end
+  end
+end

data/lib/decidim/api/fingerprint_interface.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Core
+    # This interface represents a fingerprintable object.
+    FingerprintInterface = GraphQL::InterfaceType.define do
+      name "FingerprintInterface"
+      description "An interface that can be used in fingerprintable objects."
+
+      field :fingerprint, !Decidim::Core::FingerprintType, "This object's fingerprint"
+    end
+  end
+end

data/lib/decidim/api/participatory_space_interface.rb

@@ -17,18 +17,15 @@ module Decidim
         }
       end
 
-      field :components, types[ComponentInterface] do
-        description "Lists the components this space contains."
-
-        resolve ->(participatory_space, _args, _ctx) {
-                  Decidim::Component.where(
-                    participatory_space: participatory_space
-                  ).published
-                }
-      end
+      field :components,
+            type: types[ComponentInterface],
+            description: "Lists the components this space contains.",
+            function: ComponentListHelper.new
 
       field :stats, types[Decidim::Core::StatisticType] do
         resolve ->(participatory_space, _args, _ctx) {
+          return if participatory_space.respond_to?(:show_statistics) && !participatory_space.show_statistics
+
           published_components = Component.where(participatory_space: participatory_space).published
 
           stats = Decidim.component_manifests.map do |component_manifest|
@@ -41,5 +38,10 @@ module Decidim
 
       resolve_type ->(obj, _ctx) { obj.manifest.query_type.constantize }
     end
+
+    class ComponentListHelper < ComponentList
+      argument :order, ComponentInputSort, "Provides several methods to order the results"
+      argument :filter, ComponentInputFilter, "Provides several methods to filter the results"
+    end
   end
 end

data/lib/decidim/api/participatory_space_resourceable_interface.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Core
+    # This interface represents a participatorySpaceResourceable object.
+    # It create and array of linked participatory spaces for each registered manifest
+    ParticipatorySpaceResourceableInterface = GraphQL::InterfaceType.define do
+      name "ParticipatorySpaceResourcableInterface"
+      description "An interface that can be used in objects with participatorySpaceResourceable"
+
+      # this handles the cases linked_participatory_space_resources(:participatory_space, :included_participatory_space)
+      field "linkedParticipatorySpaces", !types[ParticipatorySpaceLinkType] do
+        description "Lists all linked participatory spaces in a polymorphic way"
+        resolve ->(participatory_space, _args, _ctx) {
+          Decidim::ParticipatorySpaceLink.where("name like 'included_%' and ((from_id=:id and from_type=:type) or (to_id=:id and to_type=:type))",
+                                                id: participatory_space.id, type: participatory_space.class.name)
+        }
+      end
+    end
+  end
+end

data/lib/decidim/api/scopable_interface.rb

@@ -2,7 +2,7 @@
 
 module Decidim
   module Core
-    # This interface represents a commentable object.
+    # This interface represents a scopable object.
     ScopableInterface = GraphQL::InterfaceType.define do
       name "ScopableInterface"
       description "An interface that can be used in scopable objects."

data/lib/decidim/api/timestamps_interface.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Core
+    # This interface represents an object with standard create_at and updated_at timestamps.
+    TimestampsInterface = GraphQL::InterfaceType.define do
+      name "TimestampsInterface"
+      description "An interface that can be used in objects with created_at and updated_at attributes"
+
+      field :createdAt, Decidim::Core::DateTimeType do
+        description "The date and time this object was created"
+        property :created_at
+      end
+
+      field :updatedAt, Decidim::Core::DateTimeType do
+        description "The date and time this object was updated"
+        property :updated_at
+      end
+    end
+  end
+end

data/lib/decidim/api/traceable_interface.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Core
+    # This interface represents an traceable object.
+    TraceableInterface = GraphQL::InterfaceType.define do
+      name "TraceableInterface"
+      description "An interface that can be used in objects with traceability (versions)"
+
+      field :versionsCount, !types.Int, "Total number of versions", property: :versions_count
+      field :versions, !types[Decidim::Core::TraceVersionType], "This object's versions"
+    end
+  end
+end

data/lib/decidim/authorable.rb

@@ -12,11 +12,25 @@ module Decidim
       belongs_to :author, polymorphic: true, foreign_key: "decidim_author_id", foreign_type: "decidim_author_type"
       belongs_to :user_group, foreign_key: "decidim_user_group_id", class_name: "Decidim::UserGroup", optional: true
 
+      scope :official_origin, lambda {
+        where(decidim_author_type: "Decidim::Organization")
+      }
+
+      scope :user_group_origin, lambda {
+        where(decidim_author_type: "Decidim::UserBaseEntity")
+          .where.not(decidim_user_group_id: nil)
+      }
+
+      scope :citizens_origin, lambda {
+        where(decidim_author_type: "Decidim::UserBaseEntity")
+          .where(decidim_user_group_id: nil)
+      }
+
       validates :author, presence: true
       validate :verified_user_group, :user_group_membership
       validate :author_belongs_to_organization
 
-      # Checks whether the user is author of the given proposal, either directly
+      # Checks whether the user is author of the given resource, either directly
       # authoring it or via a user group.
       #
       # user - the user to check for authorship
@@ -32,6 +46,13 @@ module Decidim
         user_group || author
       end
 
+      # Public: Checks whether the resource is official or not.
+      #
+      # Returns a boolean.
+      def official?
+        decidim_author_type == Decidim::Organization.name
+      end
+
       private
 
       def verified_user_group

data/lib/decidim/authorization_form_builder.rb

@@ -37,6 +37,7 @@ module Decidim
 
     def input_field(name, type)
       return hidden_field(name) if name.to_s == "handler_name"
+      return scopes_selector if name.to_s == "scope_id"
 
       case type.name
       when "Date", "Time"
@@ -46,6 +47,12 @@ module Decidim
       end
     end
 
+    def scopes_selector
+      return if object.user.blank?
+
+      collection_select :scope_id, object.user.organization.scopes, :id, ->(scope) { translated_attribute(scope.name) }
+    end
+
     def find_input_type(name)
       found_attribute = object.class.attribute_set.detect do |attribute|
         attribute.name.to_s == name

data/lib/decidim/coauthorable.rb

@@ -23,6 +23,28 @@ module Decidim
       scope :from_author, ->(author) { from_all_author_identities(author).where("decidim_coauthorships.decidim_user_group_id": nil) }
       # retrieves models from the given UserGroup.
       scope :from_user_group, ->(user_group) { joins(:coauthorships).where("decidim_coauthorships.decidim_user_group_id": user_group.id) }
+      scope :official_origin, lambda {
+        where.not(coauthorships_count: 0)
+             .joins(:coauthorships)
+             .where(decidim_coauthorships: { decidim_author_type: "Decidim::Organization" })
+      }
+      scope :citizens_origin, lambda {
+        where.not(coauthorships_count: 0)
+             .joins(:coauthorships)
+             .where.not(decidim_coauthorships: { decidim_author_type: "Decidim::Organization" })
+             .where(decidim_coauthorships: { decidim_user_group_id: nil })
+      }
+      scope :user_group_origin, lambda {
+        where.not(coauthorships_count: 0)
+             .joins(:coauthorships)
+             .where(decidim_coauthorships: { decidim_author_type: "Decidim::UserBaseEntity" })
+             .where.not(decidim_coauthorships: { decidim_user_group_id: nil })
+      }
+      scope :meeting_origin, lambda {
+        where.not(coauthorships_count: 0)
+             .joins(:coauthorships)
+             .where(decidim_coauthorships: { decidim_author_type: "Decidim::Meetings::Meeting" })
+      }
 
       validates :coauthorships, presence: true
 
@@ -72,11 +94,18 @@ module Decidim
         coauthorships.where(author: author).exists?
       end
 
-      # Returns the identities for the authors, whether they are user groups or users.
+      # Returns the identities for the authors, whether they are user groups, users or others.
       #
-      # Returns an Array of User and/or UserGroups.
+      # Returns an Array of User, UserGroups or any other entity capable object (such as Organization).
       def identities
-        coauthorships.order(:created_at).collect(&:identity)
+        coauthorships.includes(:author, :user_group).order(:created_at).collect(&:identity)
+      end
+
+      # Returns the identities for the authors, only if they are user groups or users.
+      #
+      # Returns an Array of User and/or UserGroups.
+      def user_identities
+        coauthorships.where(decidim_author_type: "Decidim::UserBaseEntity").order(:created_at).collect(&:identity)
       end
 
       # Syntactic sugar to access first coauthor as a Coauthorship.

data/lib/decidim/component_manifest.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "decidim/settings_manifest"
-require "decidim/components/export_manifest"
+require "decidim/exporters/export_manifest"
 
 module Decidim
   # This class handles all the logic associated to configuring a component
@@ -58,6 +58,30 @@ module Decidim
     # probably have the form of `Decidim::<MyComponent>::Permissions`.
     attribute :permissions_class_name, String, default: "Decidim::DefaultPermissions"
 
+    # The name of the class that handles extra logic on settings for this component.
+    # Optional class, that if present receives the settings and validates them.
+    # The suggested naming is `Decidim::<MyComponent>::Admin::ComponentForm`.
+    attribute :component_form_class_name, String, default: "Decidim::Admin::ComponentForm"
+
+    # Does this component have specific data to serialize and import?
+    # Beyond the attributes in decidim_component table.
+    attribute :serializes_specific_data, Boolean, default: false
+
+    # The class to be used to serialize specific data for the current component.
+    # Should be a kind of `Decidim::Exporters::Serializer`.
+    #
+    # Note that this class will be initialized with the component as argument.
+    # Then it makes no sense to use the base Decidim::Exporters::Serializer because it
+    # will serialize the component itself, not the specific data depending on it.
+    # Thus you will always be setting a subclass of `Decidim::Exporters::Serializer`.
+    #
+    attribute :specific_data_serializer_class_name, String
+
+    # The class to be used to import specific data for the current component.
+    # Should be a kind of `Decidim::Importers::Importer`.
+    #
+    attribute :specific_data_importer_class_name, String
+
     validates :name, presence: true
 
     # Public: Registers a hook to this manifest. Hooks get fired when some
@@ -84,7 +108,7 @@ module Decidim
     def run_hooks(event_name, context = nil)
       return unless hooks[event_name]
 
-      hooks[event_name.to_sym].each do |hook|
+      hooks[event_name.to_sym].map do |hook|
         hook.call(context)
       end
     end
@@ -134,10 +158,10 @@ module Decidim
     end
 
     # Public: Registers an export artifact with a name and its properties
-    # defined in `Decidim::Components::ExportManifest`.
+    # defined in `Decidim::Exporters::ExportManifest`.
     #
     # Export artifacts provide an unified way for components to register
-    # exportable collections serialized via a `Serializer` than eventually
+    # exportable collections serialized via a `Serializer` that eventually
     # are transformed to their formats.
     #
     # name  - The name of the artifact. Should be unique in the context of
@@ -156,15 +180,19 @@ module Decidim
     # Pubic: Returns a collection of previously registered export manifests
     # for this component.
     #
-    # Returns an Array<Decidim::Components::ExportManifest>.
+    # Returns an Array<Decidim::Exporters::ExportManifest>.
     def export_manifests
       @export_manifests ||= Array(@exports).map do |(name, block)|
-        Decidim::Components::ExportManifest.new(name, self).tap do |manifest|
+        Decidim::Exporters::ExportManifest.new(name, self).tap do |manifest|
           block.call(manifest)
         end
       end
     end
 
+    def serializes_specific_data?
+      serializes_specific_data
+    end
+
     # Public: Stores an instance of StatsRegistry
     def stats
       @stats ||= StatsRegistry.new
@@ -192,6 +220,33 @@ module Decidim
       permissions_class_name&.constantize
     end
 
+    # Public: Finds the form class from its component, using the
+    # `component_form_class_name` attribute. If the class does not exist,
+    # it raises an exception. If the class name is not set, it returns nil.
+    #
+    # Returns a Class.
+    def component_form_class
+      component_form_class_name&.constantize
+    end
+
+    # Public: Finds the specific data serializer class from its name, using the
+    # `specific_data_serializer_class_name` attribute. If the class does not exist,
+    # it raises an exception. If the class name is not set, it returns nil.
+    #
+    # Returns a Decidim::Exporters::Serializer subclass or nil.
+    def specific_data_serializer_class
+      specific_data_serializer_class_name&.constantize
+    end
+
+    # Public: Finds the specific data importer class from its name, using the
+    # `specific_data_importerer_class_name` attribute. If the class does not exist,
+    # it raises an exception. If the class name is not set, it returns nil.
+    #
+    # Returns a Decidim::Importers::Importer subclass or nil.
+    def specific_data_importer_class
+      specific_data_importer_class_name&.constantize
+    end
+
     # Public: Registers a resource. Exposes a DSL defined by
     # `Decidim::ResourceManifest`. Automatically sets the component manifest
     # for that resource to the current one.