Class: Avo::ResourcesController

Inherits:
ApplicationController show all
Defined in:
app/controllers/avo/resources_controller.rb

Instance Method Summary collapse

Methods inherited from ApplicationController

#exception_logger, #init_app

Instance Method Details

#attach ⇒ Object 



180
181
182
183
184
185
186
187
188
189
 
# File 'app/controllers/avo/resources_controller.rb', line 180

def attach
  attachment_class = App.get_model_class_by_name params[:attachment_name].pluralize 1
  attachment_model = attachment_class.safe_constantize.find params[:attachment_id]
  attached = resource.send(params[:attachment_name]) << attachment_model

  render json: {
    success: true,
    message: "#{attachment_class} attached.",
  }
end

#cast_nullable(params) ⇒ Object 



202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
 
# File 'app/controllers/avo/resources_controller.rb', line 202

def cast_nullable(params)
  fields = avo_resource.get_fields

  nullable_fields = fields.filter { |field| field.nullable }
                          .map { |field| [field.id, field.null_values] }
                          .to_h

  params.each do |key, value|
    nullable = nullable_fields[key.to_sym]

    if nullable.present? && value.in?(nullable)
      params[key] = nil
    end
  end

  params
end

#create ⇒ Object 



128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
 
# File 'app/controllers/avo/resources_controller.rb', line 128

def create
  create_params = resource_params

  # Update the foreign key for a belongs_to relation from a has_many via creation.
  if params[:via_relationship].present?
    relationship_foreign_key = params[:via_resource_name].singularize.camelize.safe_constantize.reflections[params[:via_relationship]].foreign_key
    if create_params[relationship_foreign_key].blank?
      create_params[relationship_foreign_key] = params[:via_resource_id]
    end
  end

  casted_params = cast_nullable(create_params)

  resource = resource_model.new(casted_params)
  resource.save!

  render json: {
    success: true,
    resource: Avo::Resources::Resource.hydrate_resource(resource, avo_resource, :create),
    message: 'Resource created',
  }
end

#destroy ⇒ Object 



159
160
161
162
163
164
165
 
# File 'app/controllers/avo/resources_controller.rb', line 159

def destroy
  resource.destroy!

  render json: {
    message: 'Resource destroyed',
  }
end

#detach ⇒ Object 



191
192
193
194
195
196
197
198
199
200
 
# File 'app/controllers/avo/resources_controller.rb', line 191

def detach
  attachment_class = App.get_model_class_by_name params[:attachment_name].pluralize 1
  attachment_model = attachment_class.safe_constantize.find params[:attachment_id]
  attached = resource.send(params[:attachment_name]).delete attachment_model

  render json: {
    success: true,
    message: "#{attachment_class} attached.",
  }
end

#edit ⇒ Object 



99
100
101
102
103
 
# File 'app/controllers/avo/resources_controller.rb', line 99

def edit
  @view = :edit

  show
end

#fields ⇒ Object 



151
152
153
154
155
156
157
 
# File 'app/controllers/avo/resources_controller.rb', line 151

def fields
  resource = resource_model.new

  render json: {
    resource: Avo::Resources::Resource.hydrate_resource(resource, avo_resource, :create),
  }
end

#filters ⇒ Object 



167
168
169
170
171
172
173
174
175
176
177
178
 
# File 'app/controllers/avo/resources_controller.rb', line 167

def filters
  avo_filters = avo_resource.get_filters
  filters = []

  avo_filters.each do |filter|
    filters.push(filter.new.render_response)
  end

  render json: {
    filters: filters,
  }
end

#index ⇒ Object 



5
6
7
8
9
10
11
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
64
65
66
67
68
69
70
 
# File 'app/controllers/avo/resources_controller.rb', line 5

def index
  params[:page] ||= 1
  params[:per_page] ||= Avo.configuration.per_page
  params[:sort_by] = params[:sort_by].present? ? params[:sort_by] : :created_at
  params[:sort_direction] = params[:sort_direction].present? ? params[:sort_direction] : :desc
  filters = get_filters

  if params[:via_resource_name].present? and params[:via_resource_id].present? and params[:via_relationship].present?
    # get the reated resource (via_resource)
    related_resource = App.get_resource_by_name(params[:via_resource_name])
    related_model = related_resource.model
    # fetch the entries
    query = related_model.find(params[:via_resource_id]).public_send(params[:via_relationship])
    params[:per_page] = Avo.configuration.via_per_page
  elsif ['has_many', 'has_and_belongs_to_many'].include? params[:for_relation]
    resources = resource_model.all.map do |model|
      {
        value: model.id,
        label: model.send(avo_resource.title),
      }
    end

    return render json: {
      resources: resources
    }
  else
    query = resource_model
  end

  query = query.order("#{params[:sort_by]} #{params[:sort_direction]}")

  if filters.present?
    filters.each do |filter_class, filter_value|
      query = filter_class.safe_constantize.new.apply_query request, query, filter_value
    end
  end

  # Eager load the attachments
  query = eager_load_files(query)

  # Eager lood the relations
  if avo_resource.includes.present?
    query = query.includes(*avo_resource.includes)
  end

  resources = query.page(params[:page]).per(params[:per_page])

  resources_with_fields = []
  resources.each do |resource|
    resources_with_fields << Avo::Resources::Resource.hydrate_resource(resource, avo_resource, :index)
  end

  meta = {
    per_page_steps: Avo.configuration.per_page_steps,
    available_view_types: avo_resource.available_view_types,
    default_view_type: avo_resource.default_view_type || Avo.configuration.default_view_type,
  }

  render json: {
    success: true,
    meta: meta,
    resources: resources_with_fields,
    per_page: params[:per_page],
    total_pages: resources.total_pages,
  }
end

#search ⇒ Object 



72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
# File 'app/controllers/avo/resources_controller.rb', line 72

def search
  if params[:resource_name].present?
    resources = add_link_to_search_results search_resource(avo_resource)
  else
    resources = []

    resources_to_search_through = App.get_resources.select { |r| r.search.present? }
    resources_to_search_through.each do |resource_model|
      found_resources = add_link_to_search_results search_resource(resource_model)
      resources.push({
        label: resource_model.name,
        resources: found_resources
      })
    end
  end

  render json: {
    resources: resources
  }
end

#show ⇒ Object 



93
94
95
96
97
 
# File 'app/controllers/avo/resources_controller.rb', line 93

def show
  render json: {
    resource: Avo::Resources::Resource.hydrate_resource(resource, avo_resource, @view || :show),
  }
end

#update ⇒ Object 



105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
 
# File 'app/controllers/avo/resources_controller.rb', line 105

def update
  update_file_fields

  # Filter out the file params
  regular_resource_params = resource_params.select do |id, value|
    !avo_resource.attached_file_fields.map(&:id).to_s.include? id
  end

  if avo_resource.has_devise_password and regular_resource_params[:password].blank?
    regular_resource_params.delete(:password_confirmation)
    regular_resource_params.delete(:password)
  end

  casted_params = cast_nullable(regular_resource_params)
  avo_resource.fill_model(resource, casted_params).save!

  render json: {
    success: true,
    resource: Avo::Resources::Resource.hydrate_resource(resource, avo_resource, :show),
    message: 'Resource updated',
  }
end