decidim-core 0.23.2 → 0.24.0

data/lib/decidim/amendable.rb

@@ -44,7 +44,7 @@ module Decidim
         when "participants"
           return none unless user
 
-          where(id: joins(:amendable).where("decidim_amendments.decidim_user_id = ?", user.id))
+          where(id: joins(:amendable).where(decidim_amendments: { decidim_user_id: user.id }))
         else # Assume 'all'
           only_emendations
         end
@@ -67,6 +67,7 @@ module Decidim
 
     class_methods do
       attr_reader :amendable_options
+
       # Public: Configures amendable for this model.
       #
       # fields  - An `Array` of `symbols` specifying the fields that can be amended
@@ -134,7 +135,7 @@ module Decidim
       when "participants"
         return self.class.none unless user
 
-        published_emendations.where("decidim_amendments.decidim_user_id = ?", user.id)
+        published_emendations.where(decidim_amendments: { decidim_user_id: user.id })
       else # Assume 'all'
         published_emendations
       end

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

@@ -14,7 +14,7 @@ module Decidim
     #
     # For an example check
     # decidim-proposals/app/types/decidim/proposals/proposals_type.rb
-    class ComponentFinderBase < GraphQL::Function
+    class ComponentFinderBase
       attr_reader :model_class
 
       def initialize(model_class:)

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

@@ -14,8 +14,9 @@ module Decidim
     # This is used by ParticipatorySpaceInterface to apply filter/orders when
     # searching raw components. When listing properly defined components,
     # use ComponentListBase instead
-    class ComponentList < GraphQL::Function
+    class ComponentList
       include NeedsApiFilterAndOrder
+      include NeedsApiDefaultOrder
       attr_reader :model_class
 
       def initialize
@@ -26,11 +27,10 @@ module Decidim
         @query = Decidim::Component
         # remove default ordering if custom order required
         @query = @query.unscoped if args[:order]
-        @query = @query.where(
-          participatory_space: participatory_space
-        ).published
+        @query = @query.where(participatory_space: participatory_space).published
         add_filter_keys(args[:filter])
         add_order_keys(args[:order].to_h)
+        add_default_order
         @query
       end
     end

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

@@ -25,8 +25,9 @@ module Decidim
     # For an example check
     # decidim-proposals/app/types/decidim/proposals/proposals_type.rb
     #
-    class ComponentListBase < GraphQL::Function
+    class ComponentListBase
       include NeedsApiFilterAndOrder
+      include NeedsApiDefaultOrder
       attr_reader :model_class
 
       def initialize(model_class:)
@@ -40,6 +41,7 @@ module Decidim
         add_filter_keys(args[:filter])
         order = filter_keys_by_settings(args[:order].to_h, component)
         add_order_keys(order)
+        add_default_order
         @query
       end
 

data/lib/decidim/api/functions/needs_api_default_order.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Core
+    module NeedsApiDefaultOrder
+      private
+
+      # Add default order to the query in order to avoid random PostgreSQL
+      # ordering between the queries for different pages of results. If some of
+      # the queried records are updated or new records are added between the
+      # API calls to different pages of records, PostgreSQL can randomly change
+      # the order causing duplicates to appear or some records to disappear from
+      # the results unless the order of the records is explicitly defined.
+      #
+      # Note that this needs to be called as the last method before returning
+      # the query so that it won't affect the desired ordering specified in the
+      # GraphQ query. In that case, ordering by ID will be the secondary order
+      # of the records.
+      def add_default_order
+        @query = @query.order(:id)
+      end
+    end
+  end
+end

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

@@ -5,7 +5,7 @@ module Decidim
     # An abstract base class resolver for the GraphQL endpoint for a single participatory space
     # Inherit from this class and add search arguments to create finder participatory classes
     # as is shown in ParticipatorySpaceFinder
-    class ParticipatorySpaceFinderBase < GraphQL::Function
+    class ParticipatorySpaceFinderBase
       attr_reader :manifest
 
       def initialize(manifest:)
@@ -19,7 +19,7 @@ module Decidim
 
       def call(_obj, args, ctx)
         query = { organization: ctx[:current_organization] }
-        args.keys.each do |key|
+        args.compact.keys.each do |key|
           query[key] = args[key]
         end
         model_class.public_spaces.find_by(query)

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

@@ -7,8 +7,9 @@ module Decidim
     # as is shown in ParticipatorySpaceList
     # + info:
     # https://github.com/rmosolgo/graphql-ruby/blob/v1.6.8/guides/fields/function.md
-    class ParticipatorySpaceListBase < GraphQL::Function
+    class ParticipatorySpaceListBase
       include NeedsApiFilterAndOrder
+      include NeedsApiDefaultOrder
       attr_reader :manifest
 
       def initialize(manifest:)
@@ -27,6 +28,7 @@ module Decidim
 
         add_filter_keys(args[:filter])
         add_order_keys(args[:order].to_h)
+        add_default_order
         @query
       end
     end

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