Class: ForestAdminDatasourceRpc::Collection

Inherits:
ForestAdminDatasourceToolkit::Collection
  • Object
show all
Includes:
ForestAdminDatasourceCustomizer::Decorators::Action, Utils, ForestAdminDatasourceToolkit::Components
Defined in:
lib/forest_admin_datasource_rpc/collection.rb

Constant Summary collapse

FIELD_CLASSES = 
{
  'Column' => ForestAdminDatasourceToolkit::Schema::ColumnSchema,
  'ManyToMany' => ForestAdminDatasourceToolkit::Schema::Relations::ManyToManySchema,
  'OneToMany' => ForestAdminDatasourceToolkit::Schema::Relations::OneToManySchema,
  'ManyToOne' => ForestAdminDatasourceToolkit::Schema::Relations::ManyToOneSchema,
  'OneToOne' => ForestAdminDatasourceToolkit::Schema::Relations::OneToOneSchema,
  'PolymorphicManyToOne' => ForestAdminDatasourceToolkit::Schema::Relations::PolymorphicManyToOneSchema,
  'PolymorphicOneToMany' => ForestAdminDatasourceToolkit::Schema::Relations::PolymorphicOneToManySchema,
  'PolymorphicOneToOne' => ForestAdminDatasourceToolkit::Schema::Relations::PolymorphicOneToOneSchema
}.freeze
KEYWORD_PARAM_KINDS = 
i[key keyreq].freeze

Instance Method Summary collapse

Constructor Details

#initialize(datasource, name, schema) ⇒ Collection

Returns a new instance of Collection.



12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
# File 'lib/forest_admin_datasource_rpc/collection.rb', line 12

def initialize(datasource, name, schema)
  super(datasource, name)
  @client = datasource.shared_rpc_client
  @rpc_collection_uri = "/forest/rpc/#{name}"
  @base_params = { collection_name: name }

  ForestAdminAgent::Facades::Container.logger.log('Debug', "Create Rpc collection #{name}.")

  enable_count if schema[:countable]
  enable_search if schema[:searchable]
  add_fields(schema[:fields])
  add_segments(schema[:segments])
  schema[:charts].each { |chart| add_chart(chart) }
  schema[:actions].each do |action_name, action_schema|
    add_action(action_name.to_s, BaseAction.from_plain_object(action_schema))
  end
  @schema[:aggregation_capabilities] = schema[:aggregation_capabilities] if schema[:aggregation_capabilities]
end

Instance Method Details

#add_fields(fields) ⇒ Object 



44
45
46
47
48
49
50
51
52
 
# File 'lib/forest_admin_datasource_rpc/collection.rb', line 44

def add_fields(fields)
  fields.each do |field_name, schema|
    field_name = field_name.to_s
    klass = FIELD_CLASSES[schema[:type]]
    next unless klass

    add_field(field_name, klass.new(**accepted_keywords(klass, schema)))
  end
end

#aggregate(caller, filter, aggregation, limit = nil) ⇒ Object 



103
104
105
106
107
108
109
110
111
112
113
 
# File 'lib/forest_admin_datasource_rpc/collection.rb', line 103

def aggregate(caller, filter, aggregation, limit = nil)
  params = build_params(filter: filter.to_h, aggregation: aggregation.to_h, limit: limit)
  url = "#{@rpc_collection_uri}/aggregate"

  ForestAdminAgent::Facades::Container.logger.log(
    'Debug',
    "Forwarding '#{@name}' aggregate call to the Rpc agent on #{url}."
  )

  @client.call_rpc(url, caller: caller, method: :post, payload: params)
end

#create(caller, data) ⇒ Object 



66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/forest_admin_datasource_rpc/collection.rb', line 66

def create(caller, data)
  params = build_params(data: [data])
  url = "#{@rpc_collection_uri}/create"

  ForestAdminAgent::Facades::Container.logger.log(
    'Debug',
    "Forwarding '#{@name}' creation call to the Rpc agent on #{url}."
  )

  res = @client.call_rpc(url, caller: caller, method: :post, payload: params)
  res.first
end

#delete(caller, filter) ⇒ Object 



91
92
93
94
95
96
97
98
99
100
101
 
# File 'lib/forest_admin_datasource_rpc/collection.rb', line 91

def delete(caller, filter)
  params = build_params(filter: filter.to_h)
  url = "#{@rpc_collection_uri}/delete"

  ForestAdminAgent::Facades::Container.logger.log(
    'Debug',
    "Forwarding '#{@name}' deletion call to the Rpc agent on #{url}."
  )

  @client.call_rpc(url, caller: caller, method: :post, payload: params)
end

#execute(caller, name, data, filter = nil) ⇒ Object 



115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
 
# File 'lib/forest_admin_datasource_rpc/collection.rb', line 115

def execute(caller, name, data, filter = nil)
  data = encode_form_data(data)
  params = build_params(action: name, filter: filter&.to_h, data: data)
  url = "#{@rpc_collection_uri}/action-execute"

  ForestAdminAgent::Facades::Container.logger.log(
    'Debug',
    "Forwarding '#{@name}' action #{name} call to the Rpc agent on #{url}."
  )

  response = @client.call_rpc_raw(url, caller: caller, method: :post, payload: params,
                                       symbolize_keys: true)

  return build_file_result(response) if response.headers['x-forest-action-type'] == 'File'

  response.body
end

#get_form(caller, name, data = nil, filter = nil, metas = nil) ⇒ Object 



133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
 
# File 'lib/forest_admin_datasource_rpc/collection.rb', line 133

def get_form(caller, name, data = nil, filter = nil, metas = nil)
  params = build_params(action: name)
  if caller
    data = encode_form_data(data)
    params = params.merge({ filter: filter&.to_h, metas: metas, data: data })
  end
  url = "#{@rpc_collection_uri}/action-form"

  ForestAdminAgent::Facades::Container.logger.log(
    'Debug',
    "Forwarding '#{@name}' action form #{name} call to the Rpc agent on #{url}."
  )

  result = @client.call_rpc(url, caller: caller, method: :post, payload: params, symbolize_keys: true)
  result.map do |field|
    Actions::ActionFieldFactory.build(field.to_h)
  end
end

#list(caller, filter, projection) ⇒ Object 



54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/forest_admin_datasource_rpc/collection.rb', line 54

def list(caller, filter, projection)
  params = build_params(filter: filter.to_h, projection: projection)
  url = "#{@rpc_collection_uri}/list"

  ForestAdminAgent::Facades::Container.logger.log(
    'Debug',
    "Forwarding '#{@name}' list call to the Rpc agent on #{url}."
  )

  @client.call_rpc(url, caller: caller, method: :post, payload: params)
end

#render_chart(caller, name, record_id, parameters = {}) ⇒ Object 



152
153
154
155
156
157
158
159
160
161
162
 
# File 'lib/forest_admin_datasource_rpc/collection.rb', line 152

def render_chart(caller, name, record_id, parameters = {})
  params = build_params(chart: name, record_id: record_id, parameters: parameters)
  url = "#{@rpc_collection_uri}/chart"

  ForestAdminAgent::Facades::Container.logger.log(
    'Debug',
    "Forwarding '#{@name}' chart #{name} call to the Rpc agent on #{url}."
  )

  @client.call_rpc(url, caller: caller, method: :post, payload: params)
end

#update(caller, filter, data) ⇒ Object 



79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/forest_admin_datasource_rpc/collection.rb', line 79

def update(caller, filter, data)
  params = build_params(filter: filter.to_h, patch: data)
  url = "#{@rpc_collection_uri}/update"

  ForestAdminAgent::Facades::Container.logger.log(
    'Debug',
    "Forwarding '#{@name}' update call to the Rpc agent on #{url}."
  )

  @client.call_rpc(url, caller: caller, method: :post, payload: params)
end