Module: Decidim::QueryExtensions

Defined in:
lib/decidim/query_extensions.rb

Overview

This module’s job is to extend the API with custom fields related to decidim-core.

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.included(type) ⇒ Object

Public: Extends a type with ‘decidim-core`’s fields.

type - A GraphQL::BaseType to extend.

Returns nothing.



12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
# File 'lib/decidim/query_extensions.rb', line 12

def self.included(type)
  type.field :participatory_processes,
             [Decidim::ParticipatoryProcesses::ParticipatoryProcessType],
             null: true,
             description: "Lists all participatory_processes" do
    argument :filter, Decidim::ParticipatoryProcesses::ParticipatoryProcessInputFilter, "This argument let's you filter the results", required: false
    argument :order, Decidim::ParticipatoryProcesses::ParticipatoryProcessInputSort, "This argument let's you order the results", required: false
  end

  type.field :participatory_process,
             Decidim::ParticipatoryProcesses::ParticipatoryProcessType,
             null: true,
             description: "Finds a participatory_process" do
    argument :id, GraphQL::Types::ID, "The ID of the participatory space", required: false
    argument :slug, String, "The slug of the participatory process", required: false
  end

  type.field :component, Decidim::Core::ComponentInterface, null: true do
    description "Lists the components this space contains."
    argument :id, GraphQL::Types::ID, required: true, description: "The ID of the component to be found"
  end

  type.field :session, Core::SessionType, description: "Return's information about the logged in user", null: true

  type.field :decidim, Core::DecidimType, "Decidim's framework properties.", null: true

  type.field :organization, Core::OrganizationType, "The current organization", null: true

  type.field :hashtags, [Core::HashtagType], null: true, description: "The hashtags for current organization" do
    argument :name, GraphQL::Types::String, "The name of the hashtag", required: false
  end

  type.field :metrics, type: [Decidim::Core::MetricType], null: true do
    argument :names, [GraphQL::Types::String], "The names of the metrics you want to retrieve", camelize: false, required: false
    argument :space_type, GraphQL::Types::String, "The type of ParticipatorySpace you want to filter with", camelize: false, required: false
    argument :space_id, GraphQL::Types::Int, "The ID of ParticipatorySpace you want to filter with", camelize: false, required: false
  end

  type.field :user,
             type: Core::AuthorInterface, null: true,
             description: "A participant (user or group) in the current organization" do
    argument :id, GraphQL::Types::ID, "The ID of the participant", required: false
    argument :nickname, GraphQL::Types::String, "The @nickname of the participant", required: false
  end

  type.field :users,
             type: [Core::AuthorInterface], null: true,
             description: "The participants (users or groups) for the current organization" do
    argument :order, Decidim::Core::UserEntityInputSort, "Provides several methods to order the results", required: false
    argument :filter, Decidim::Core::UserEntityInputFilter, "Provides several methods to filter the results", required: false
  end
end

Instance Method Details

#component(id: {}) ⇒ Object 



75
76
77
78
 
# File 'lib/decidim/query_extensions.rb', line 75

def component(id: {})
  component = Decidim::Component.published.find_by(id: id)
  component&.organization == context[:current_organization] ? component : nil
end

#decidim ⇒ Object 



84
85
86
 
# File 'lib/decidim/query_extensions.rb', line 84

def decidim
  Decidim
end

#hashtags(name: nil) ⇒ Object 



92
93
94
 
# File 'lib/decidim/query_extensions.rb', line 92

def hashtags(name: nil)
  Decidim::HashtagsResolver.new(context[:current_organization], name).hashtags
end

#metrics(names: [], space_type: nil, space_id: nil) ⇒ Object 



96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
 
# File 'lib/decidim/query_extensions.rb', line 96

def metrics(names: [], space_type: nil, space_id: nil)
  manifests = if names.blank?
                Decidim.metrics_registry.all
              else
                Decidim.metrics_registry.all.select do |manifest|
                  names.include?(manifest.metric_name.to_s)
                end
              end
  filters = {}
  if space_type.present? && space_id.present?
    filters[:participatory_space_type] = space_type
    filters[:participatory_space_id] = space_id
  end

  manifests.map do |manifest|
    Decidim::Core::MetricResolver.new(manifest.metric_name, context[:current_organization], filters)
  end
end

#organization ⇒ Object 



88
89
90
 
# File 'lib/decidim/query_extensions.rb', line 88

def organization
  context[:current_organization]
end

#participatory_process(id: nil, slug: nil) ⇒ Object 



70
71
72
73
 
# File 'lib/decidim/query_extensions.rb', line 70

def participatory_process(id: nil, slug: nil)
  manifest = Decidim.participatory_space_manifests.select { |m| m.name == :participatory_processes }.first
  Decidim::Core::ParticipatorySpaceFinderBase.new(manifest: manifest).call(object, { id: id, slug: slug }, context)
end

#participatory_processes(filter: {}, order: {}) ⇒ Object 



65
66
67
68
 
# File 'lib/decidim/query_extensions.rb', line 65

def participatory_processes(filter: {}, order: {})
  manifest = Decidim.participatory_space_manifests.select { |m| m.name == :participatory_processes }.first
  Decidim::Core::ParticipatorySpaceListBase.new(manifest: manifest).call(object, { filter: filter, order: order }, context)
end

#session ⇒ Object 



80
81
82
 
# File 'lib/decidim/query_extensions.rb', line 80

def session
  context[:current_user]
end

#user(id: nil, nickname: nil) ⇒ Object 



115
116
117
 
# File 'lib/decidim/query_extensions.rb', line 115

def user(id: nil, nickname: nil)
  Core::UserEntityFinder.new.call(object, { id: id, nickname: nickname }, context)
end

#users(filter: {}, order: {}) ⇒ Object 



119
120
121
 
# File 'lib/decidim/query_extensions.rb', line 119

def users(filter: {}, order: {})
  Core::UserEntityList.new.call(object, { filter: filter, order: order }, context)
end