decidim-core 0.23.6 → 0.24.0.rc1

data/{app/functions/decidim/core → lib/decidim/api/functions}/user_entity_finder.rb

@@ -9,10 +9,7 @@ module Decidim
     #   name
     # }
     #
-    class UserEntityFinder < GraphQL::Function
-      argument :id, types.ID, "The ID of the participant"
-      argument :nickname, types.String, "The @nickname of the participant"
-
+    class UserEntityFinder
       def call(_obj, args, ctx)
         filters = {
           organization: ctx[:current_organization]

data/{app/functions/decidim/core → lib/decidim/api/functions}/user_entity_list.rb

@@ -9,10 +9,8 @@ module Decidim
     #   name
     # }
     #
-    class UserEntityList < GraphQL::Function
+    class UserEntityList
       include NeedsApiFilterAndOrder
-      argument :order, UserEntityInputSort, "Provides several methods to order the results"
-      argument :filter, UserEntityInputFilter, "Provides several methods to filter the results"
 
       def initialize
         @model_class = Decidim::UserBaseEntity

data/{app/types/decidim/core → lib/decidim/api/input_filters}/component_input_filter.rb

@@ -10,41 +10,39 @@ module Decidim
       description "A type used for filtering any component parent objects"
 
       argument :type,
-               type: String,
+               type: GraphQL::Types::String,
                description: "Filters by type of component",
                required: false,
-               prepare: ->(value, _ctx) do
-                 { manifest_name: value.downcase }
-               end
+               prepare: lambda { |value, _ctx|
+                          { manifest_name: value.downcase }
+                        }
       argument :name,
-               type: String,
+               type: GraphQL::Types::String,
                description: "Filters by name of the component, additional locale parameter can be provided to specify in which to search",
                required: false,
-               prepare: ->(search, ctx) do
-                          proc do |model_class, locale|
+               prepare: lambda { |search, ctx|
+                          lambda { |model_name, locale|
                             locale = ctx[:current_organization].default_locale if locale.blank?
-                            op = Arel::Nodes::InfixOperation.new("->>", model_class.arel_table[:name], Arel::Nodes.build_quoted(locale))
+                            op = Arel::Nodes::InfixOperation.new("->>", model_name.arel_table[:name], Arel::Nodes.build_quoted(locale))
                             op.matches("%#{search}%")
-                          end
-                        end
+                          }
+                        }
+
       argument :with_geolocation_enabled,
-               type: Boolean,
+               type: GraphQL::Types::Boolean,
                description: "Returns components with geolocation activated (may be Proposals or Meetings)",
                required: false,
-               prepare: ->(active, _ctx) do
-                 proc do |_model_class|
-                   ["(settings->'global'->>'geocoding_enabled')::boolean is ? or manifest_name='meetings'", active]
-                 end
-               end
+               prepare: lambda { |active, _ctx|
+                          ->(_model_name, _locale) { ["(settings->'global'->>'geocoding_enabled')::boolean is ? or manifest_name='meetings'", active] }
+                        }
+
       argument :with_comments_enabled,
-               type: Boolean,
+               type: GraphQL::Types::Boolean,
                description: "Returns components with comments enabled globally (can still be deactivated in the current step if the component has steps)",
                required: false,
-               prepare: ->(active, _ctx) do
-                 proc do |_model_class|
-                   ["(settings->'global'->>'comments_enabled')::boolean is ?", active]
-                 end
-               end
+               prepare: lambda { |active, _ctx|
+                          ->(_model_name, _locale) { ["(settings->'global'->>'comments_enabled')::boolean is ?", active] }
+                        }
     end
   end
 end

data/{app/types/decidim/core → lib/decidim/api/input_filters}/has_hastaggable_input_filter.rb

@@ -5,7 +5,7 @@ module Decidim
     module HasHastaggableInputFilter
       def self.included(child_class)
         child_class.argument :hashtag,
-                             type: String,
+                             type: GraphQL::Types::String,
                              description: "List result having this hashtag",
                              required: false,
                              prepare: ->(hashtag, _ctx) { "##{hashtag.sub(/^#/, "")}" }

data/{app/types/decidim/core → lib/decidim/api/input_filters}/has_localized_input_filter.rb

@@ -5,16 +5,16 @@ module Decidim
     module HasLocalizedInputFilter
       def self.included(child_class)
         child_class.argument :locale,
-                             type: String,
+                             type: GraphQL::Types::String,
                              description: "Specify the locale to use when searching translated fields, otherwise default organization language will be used",
                              required: false,
-                             prepare: ->(locale, ctx) do
+                             prepare: lambda { |locale, ctx|
                                unless ctx[:current_organization].available_locales.include?(locale)
                                  raise GraphQL::ExecutionError, "#{locale} locale is not used in the organization"
                                end
 
                                locale
-                             end
+                             }
       end
     end
   end

data/{app/types/decidim/core → lib/decidim/api/input_filters}/has_publishable_input_filter.rb

@@ -5,23 +5,23 @@ module Decidim
     module HasPublishableInputFilter
       def self.included(child_class)
         child_class.argument :published_before,
-                             type: String,
+                             type: GraphQL::Types::String,
                              description: "List result published **before** (and **excluding**) this date. Expected format `YYYY-MM-DD`",
                              required: false,
-                             prepare: ->(date, _ctx) do
+                             prepare: lambda { |date, _ctx|
                                proc do |model_class|
                                  model_class.arel_table[:published_at].lt(date_to_iso8601(date, :publishedBefore))
                                end
-                             end
+                             }
         child_class.argument :published_since,
-                             type: String,
+                             type: GraphQL::Types::String,
                              description: "List result published after (and **including**) this date. Expected format `YYYY-MM-DD`",
                              required: false,
-                             prepare: ->(date, _ctx) do
+                             prepare: lambda { |date, _ctx|
                                proc do |model_class|
                                  model_class.arel_table[:published_at].gteq(date_to_iso8601(date, :publishedBefore))
                                end
-                             end
+                             }
       end
 
       def self.date_to_iso8601(date, key)

data/{app/types/decidim/core → lib/decidim/api/input_filters}/has_timestamp_input_filter.rb

@@ -5,41 +5,41 @@ module Decidim
     module HasTimestampInputFilter
       def self.included(child_class)
         child_class.argument :created_before,
-                             type: String,
+                             type: GraphQL::Types::String,
                              description: "List result created **before** (and **excluding**) this date. Expected format `YYYY-MM-DD`",
                              required: false,
-                             prepare: ->(date, _ctx) do
+                             prepare: lambda { |date, _ctx|
                                proc do |model_class|
                                  model_class.arel_table[:created_at].lt(date_to_iso8601(date, :createdBefore))
                                end
-                             end
+                             }
         child_class.argument :created_since,
-                             type: String,
+                             type: GraphQL::Types::String,
                              description: "List result created after (and **including**) this date. Expected format `YYYY-MM-DD`",
                              required: false,
-                             prepare: ->(date, _ctx) do
+                             prepare: lambda { |date, _ctx|
                                proc do |model_class|
                                  model_class.arel_table[:created_at].gteq(date_to_iso8601(date, :createdBefore))
                                end
-                             end
+                             }
         child_class.argument :updated_before,
-                             type: String,
+                             type: GraphQL::Types::String,
                              description: "List result updated **before** (and **excluding**) this date. Expected format `YYYY-MM-DD`",
                              required: false,
-                             prepare: ->(date, _ctx) do
+                             prepare: lambda { |date, _ctx|
                                proc do |model_class|
                                  model_class.arel_table[:updated_at].lt(date_to_iso8601(date, :updatedBefore))
                                end
-                             end
+                             }
         child_class.argument :updated_since,
-                             type: String,
+                             type: GraphQL::Types::String,
                              description: "List result updated after (and **including**) this date. Expected format `YYYY-MM-DD`",
                              required: false,
-                             prepare: ->(date, _ctx) do
+                             prepare: lambda { |date, _ctx|
                                proc do |model_class|
                                  model_class.arel_table[:updated_at].gteq(date_to_iso8601(date, :updatedBefore))
                                end
-                             end
+                             }
       end
 
       def self.date_to_iso8601(date, key)

data/{app/types/decidim/core → lib/decidim/api/input_filters}/participatory_space_input_filter.rb

@@ -12,7 +12,6 @@ Specific participatory spaces (such as Processes or Assemblies) usually implemen
 
 A typical query would look like:
 
-
 ```
   {
     participatoryProcesses(filter:{ publishedBefore: \"2020-01-01\" }) {

data/lib/decidim/api/input_filters/user_entity_input_filter.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Core
+    class UserEntityInputFilter < BaseInputFilter
+      graphql_name "UserEntityFilter"
+      description "A type used for filtering any user or group
+
+      A typical query would look like:
+
+      ```
+      {
+        users(filter:{wildcard:\"sandy\", excludeIds:[2,10,11]}) {
+          id
+          ...on User {
+            groups {
+              name
+            }
+          }
+          ...on UserGroup {
+            members {
+              name
+            }
+          }
+        }
+      }
+      ```
+      "
+
+      argument :type,
+               type: String,
+               description: "Filters by type of entity (User or UserGroup)",
+               required: false,
+               prepare: lambda { |value, _ctx|
+                          type = value.downcase.camelcase
+                          type = "UserGroup" if %w(Group Usergroup).include?(type)
+                          { type: "Decidim::#{type}" }
+                        }
+      argument :name,
+               type: String,
+               description: "Filters by name of the user entity. Searches (case insensitive) any fragment of the provided string",
+               required: false,
+               prepare: lambda { |value, _ctx|
+                 [
+                   lambda { |model_class, _locale|
+                     model_class.arel_table[:name].matches("%#{value}%")
+                   }
+                 ]
+               }
+      argument :nickname,
+               type: String,
+               description: "Filters by nickname of the user entity. Searches (case insensitive) any fragment of the provided string",
+               required: false,
+               prepare: lambda { |value, _ctx|
+                          value = value[1..-1] if value.starts_with? "@"
+                          [
+                            lambda { |model_class, _locale|
+                              model_class.arel_table[:nickname].matches("%#{value}%")
+                            }
+                          ]
+                        }
+      argument :wildcard,
+               type: String,
+               description: "Filters by nickname or name of the user entity. Searches (case insensitive) any fragment of the provided string",
+               required: false,
+               prepare: lambda { |value, _ctx|
+                          value = value[1..-1] if value.starts_with? "@"
+                          [
+                            lambda { |model_class, _locale|
+                              op_name = model_class.arel_table[:name].matches("%#{value}%")
+                              op_nick = model_class.arel_table[:nickname].matches("%#{value}%")
+                              op_name.or(op_nick)
+                            }
+                          ]
+                        }
+      argument :exclude_ids,
+               type: [ID],
+               description: "Excludes users contained in given ids. Valid values are one or more IDs (passed as an array)",
+               required: false,
+               prepare: lambda { |value, _ctx|
+                          [
+                            lambda { |model_class, _locale|
+                              model_class.arel_table[:id].not_in(value)
+                            }
+                          ]
+                        }
+    end
+  end
+end

data/{app/types/decidim/core → lib/decidim/api/input_sorts}/base_input_sort.rb

@@ -6,8 +6,9 @@ module Decidim
       # Overwrite the prepare method to allow 2 possible values only
       def prepare
         arguments.each do |key, value|
-          next if key == "locale"
-          raise GraphQL::ExecutionError, "Invalid order value for #{key}, only ASC or DESC are valids" unless valid_order?(value)
+          next if key.to_s == "locale"
+          next if value.respond_to?(:call)
+          raise GraphQL::ExecutionError, "Invalid order value for #{key.inspect}, only ASC or DESC are valids (received #{value.inspect})" unless valid_order?(value)
         end
         super
       end

data/{app/types/decidim/core → lib/decidim/api/input_sorts}/component_input_sort.rb

@@ -8,25 +8,24 @@ module Decidim
       graphql_name "ComponentSort"
       description "A type used for sorting any component parent objects"
 
-      argument :id, String, "Sort by ID, valid values are ASC or DESC", required: false
-      argument :weight, String, "Sort by weight (order in the website), valid values are ASC or DESC", required: false
+      argument :id, GraphQL::Types::String, "Sort by ID, valid values are ASC or DESC", required: false
+      argument :weight, GraphQL::Types::String, "Sort by weight (order in the website), valid values are ASC or DESC", required: false
       argument :type,
-               type: String,
+               type: GraphQL::Types::String,
                description: "Sort by type of component, alphabetically, valid values are ASC or DESC",
                required: false,
-               prepare: ->(direction, _ctx) do
-                 { manifest_name: direction }
-               end
+               as: :manifest_name
       argument :name,
-               type: String,
+               type: GraphQL::Types::String,
                description: "Sort by name of the component, alphabetically, valid values are ASC or DESC",
                required: false,
-               prepare: ->(direction, ctx) do
-                          proc do |locale|
+               as: :name,
+               prepare: lambda { |direction, ctx|
+                          lambda { |locale|
                             locale = ctx[:current_organization].default_locale if locale.blank?
                             [Arel.sql("name->? #{direction.upcase}"), locale]
-                          end
-                        end
+                          }
+                        }
     end
   end
 end

data/{app/types/decidim/core → lib/decidim/api/input_sorts}/has_endorsable_input_sort.rb

@@ -5,12 +5,10 @@ module Decidim
     module HasEndorsableInputSort
       def self.included(child_class)
         child_class.argument :endorsement_count,
-                             type: String,
+                             type: GraphQL::Types::String,
                              description: "Sort by number of endorsements, valid values are ASC or DESC",
                              required: false,
-                             prepare: ->(value, _ctx) do
-                                        { endorsements_count: value }
-                                      end
+                             as: :endorsements_count
       end
     end
   end

data/{app/types/decidim/core → lib/decidim/api/input_sorts}/has_localized_input_sort.rb

@@ -5,16 +5,16 @@ module Decidim
     module HasLocalizedInputSort
       def self.included(child_class)
         child_class.argument :locale,
-                             type: String,
+                             type: GraphQL::Types::String,
                              description: "Specify the locale to use when ordering translated fields, otherwise default organization language will be used",
                              required: false,
-                             prepare: ->(locale, ctx) do
+                             prepare: lambda { |locale, ctx|
                                unless ctx[:current_organization].available_locales.include?(locale)
                                  raise GraphQL::ExecutionError, "#{locale} locale is not used in the organization"
                                end
 
                                locale
-                             end
+                             }
       end
     end
   end

data/{app/types/decidim/core → lib/decidim/api/input_sorts}/has_publishable_input_sort.rb

@@ -4,7 +4,7 @@ module Decidim
   module Core
     module HasPublishableInputSort
       def self.included(child_class)
-        child_class.argument :published_at, String, "Sort by date of publication, valid values are ASC or DESC", required: false
+        child_class.argument :published_at, GraphQL::Types::String, "Sort by date of publication, valid values are ASC or DESC", required: false
         # child_class.argument :created_at, String, "Sort by date of creation, valid values are ASC or DESC", required: false
         # child_class.argument :updated_at, String, "Sort by date of last modification, valid values are ASC or DESC", required: false
       end

data/lib/decidim/api/input_sorts/has_timestamp_input_sort.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Core
+    module HasTimestampInputSort
+      def self.included(child_class)
+        child_class.argument :created_at, GraphQL::Types::String, "Sort by date of creation, valid values are ASC or DESC", required: false
+        child_class.argument :updated_at, GraphQL::Types::String, "Sort by date of last modification, valid values are ASC or DESC", required: false
+      end
+    end
+  end
+end

data/{app/types/decidim/core → lib/decidim/api/input_sorts}/participatory_space_input_sort.rb

@@ -8,7 +8,7 @@ module Decidim
       graphql_name "ParticipatorySpaceSort"
       description "A type used for sorting any generic participatory space"
 
-      argument :id, String, "Sort by ID, valid values are ASC or DESC", required: false
+      argument :id, GraphQL::Types::String, "Sort by ID, valid values are ASC or DESC", required: false
     end
   end
 end

data/{app/types/decidim/core → lib/decidim/api/input_sorts}/user_entity_input_sort.rb

@@ -6,17 +6,17 @@ module Decidim
       graphql_name "UserEntitySort"
       description "A type used for sorting any component parent objects"
 
-      argument :id, String, "Sort by ID, valid values are ASC or DESC", required: false
+      argument :id, GraphQL::Types::String, "Sort by ID, valid values are ASC or DESC", required: false
       argument :type,
-               type: String,
+               type: GraphQL::Types::String,
                description: "Sort by type of user entity (user or group), alphabetically, valid values are ASC or DESC",
                required: false
       argument :name,
-               type: String,
+               type: GraphQL::Types::String,
                description: "Sort by name of the user entity (user or group), alphabetically, valid values are ASC or DESC",
                required: false
       argument :nickname,
-               type: String,
+               type: GraphQL::Types::String,
                description: "Sort by nickname of the user entity (user or group), alphabetically, valid values are ASC or DESC",
                required: false
     end

data/lib/decidim/api/{amendable_entity_interface.rb → interfaces/amendable_entity_interface.rb}

@@ -4,15 +4,15 @@ 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"
+    module AmendableEntityInterface
+      include Decidim::Api::Types::BaseInterface
       description "An interface that can be used in objects with amendments"
 
-      field :id, !types.ID, "ID of this entity"
+      field :id, ID, "ID of this entity", null: false
 
-      resolve_type ->(obj, _ctx) {
+      def self.resolve_type(obj, _ctx)
         "#{obj.class.name}Type".constantize
-      }
+      end
     end
   end
 end

data/lib/decidim/api/interfaces/amendable_interface.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Core
+    # This interface represents an amendable object.
+    module AmendableInterface
+      include Decidim::Api::Types::BaseInterface
+      description "An interface that can be used in objects with amendments"
+
+      field :amendments, [Decidim::Core::AmendmentType, { null: true }], description: "This object's amendments", null: false
+
+      def amendments
+        object.visible_amendments_for(context[:current_user])
+      end
+    end
+  end
+end

data/lib/decidim/api/{attachable_interface.rb → interfaces/attachable_interface.rb}

@@ -3,11 +3,11 @@
 module Decidim
   module Core
     # This interface represents a attachable object.
-    AttachableInterface = GraphQL::InterfaceType.define do
-      name "AttachableInterface"
+    module AttachableInterface
+      include Decidim::Api::Types::BaseInterface
       description "An interface that can be used in objects with attachments"
 
-      field :attachments, !types[Decidim::Core::AttachmentType], "This object's attachments"
+      field :attachments, [Decidim::Core::AttachmentType, { null: true }], "This object's attachments", null: false
     end
   end
 end

data/lib/decidim/api/interfaces/author_interface.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Core
+    # This interface represents an author who owns a resource.
+    module AuthorInterface
+      include Decidim::Api::Types::BaseInterface
+      graphql_name "Author"
+      description "An author"
+
+      field :id, ID, "The author ID", null: false
+      field :name, String, "The author's name", null: false
+      field :nickname, String, "The author's nickname", null: false
+
+      field :avatar_url, String, "The author's avatar url", null: false
+      field :profile_path, String, "The author's profile path", null: false
+      field :badge, String, "The author's badge icon", null: false
+      field :organization_name, String, "The authors's organization name", null: false
+
+      def organization_name
+        object.organization.name
+      end
+
+      field :deleted, Boolean, "Whether the author's account has been deleted or not", null: false
+
+      def self.resolve_type(obj, _ctx)
+        return Decidim::Core::UserType if obj.is_a? Decidim::User
+        return Decidim::Core::UserGroupType if obj.is_a? Decidim::UserGroup
+      end
+    end
+  end
+end

data/lib/decidim/api/interfaces/authorable_interface.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Core
+    # This interface represents a commentable object.
+    module AuthorableInterface
+      include Decidim::Api::Types::BaseInterface
+      description "An interface that can be used in authorable objects."
+
+      field :author, Decidim::Core::AuthorInterface, "The resource author", null: true do
+        # can be an Authorable or a Coauthorable
+      end
+
+      def author
+        if object.respond_to?(:normalized_author)
+          object&.normalized_author
+        elsif object.respond_to?(:creator_identity)
+          object&.creator_identity
+        end
+      end
+    end
+  end
+end

data/lib/decidim/api/{categorizable_interface.rb → interfaces/categorizable_interface.rb}

@@ -3,11 +3,11 @@
 module Decidim
   module Core
     # This interface represents a categorizable object.
-    CategorizableInterface = GraphQL::InterfaceType.define do
-      name "CategorizableInterface"
+    module CategorizableInterface
+      include Decidim::Api::Types::BaseInterface
       description "An interface that can be used in categorizable objects."
 
-      field :category, Decidim::Core::CategoryType, "The object's category"
+      field :category, Decidim::Core::CategoryType, "The object's category", null: false
     end
   end
 end

data/lib/decidim/api/interfaces/coauthorable_interface.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Core
+    # This interface represents a coauthorable object.
+    module CoauthorableInterface
+      include Decidim::Api::Types::BaseInterface
+      description "An interface that can be used in coauthorable objects."
+
+      field :authors_count, Integer,
+            method: :coauthorships_count,
+            description: "The total amount of co-authors that contributed to the entity. Note that this field may include also non-user authors like meetings or the organization",
+            null: true
+
+      field :author, Decidim::Core::AuthorInterface,
+            description: "The resource author. Note that this can be null on official proposals or meeting-proposals",
+            null: true
+
+      def author
+        author = object.creator_identity
+        author if author.is_a?(Decidim::User) || author.is_a?(Decidim::UserGroup)
+      end
+
+      field :authors, [Decidim::Core::AuthorInterface, { null: true }],
+            method: :user_identities,
+            description: "The resource co-authors. Include only users or groups of users",
+            null: false
+    end
+  end
+end

data/lib/decidim/api/interfaces/component_interface.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Core
+    module ComponentInterface
+      include Decidim::Api::Types::BaseInterface
+      description "This interface is implemented by all components that belong into a Participatory Space"
+
+      field :id, ID, "The Component's unique ID", null: false
+
+      field :name, TranslatedFieldType, "The name of this component.", null: false
+
+      field :weight, Integer, "The weight of the component", null: false
+
+      field :participatory_space, ParticipatorySpaceType, "The participatory space in which this component belongs to.", null: false
+
+      def self.resolve_type(obj, _ctx)
+        obj.manifest.query_type.constantize
+      end
+    end
+  end
+end