Module: Anubis::Core::Data::Get

Included in:
Anubis::Core::DataController, Sso::Client::Data::Get, Tenant::Data::Get
Defined in:
app/controllers/anoubis/core/data/get.rb

Overview

Module gets system data for Anubis::Core::DataController

Block of table data getters collapse

Block of {Anubis::Data::Actions#edit edit} and {Anubis::Data::Actions#update update} getters collapse

Block of {Anubis::Data::Actions#new new} or {Anubis::Data::Actions#create create} getters collapse

Instance Method Summary collapse

Instance Method Details

#get_autocomplete_data(field, value) ⇒ Hash

Get autocomplete data for field

Parameters:

  • field (Anubis::Etc::Field) —

    • field for loading data

  • value (String) —

    • search value for load data

Returns:

  • (Hash) —

    resulting hash for selected data



475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
 
# File 'app/controllers/anoubis/core/data/get.rb', line 475

def get_autocomplete_data(field, value)
  value = value.to_s
  if value.index(' ')
    words = value.split(' ')

    max_count = 0;
    words.each do |word|
      max_count = word.length if word.length > max_count
      if field.autocomplete[:where].count == 0
        field.autocomplete[:where].push field.table_field+' LIKE ?'
      else
        field.autocomplete[:where][0] += ' AND '+field.table_field+' LIKE ?'
      end
      field.autocomplete[:where].push("%#{word}%")
    end
    if max_count < field.autocomplete[:count]
      field.autocomplete[:where] = []
    end
  else
    if value.length >= field.autocomplete[:count]
      field.autocomplete[:where] = [field.table_field+' LIKE ?', '%'+value+'%']
    end
  end
  if field.autocomplete[:where].count > 0
    self.load_autocomplete_data field
  end
  if self.etc.data.data
    self.etc.data.data.each do |item|
      if item.respond_to? field.model.title
        self.output.values.push(
          #id: item.id,
          value: item.send(field.model.title)
        )
      else
        self.output.values.push(
          #id: item.id,
          value: item.id
        )
      end
    end
  end
  return self.output.values
end

#get_data_options(time) ⇒ Hash

Get defined fields options

Parameters:

  • time (Number) —

    last execution time of action

Returns:

  • (Hash) —

    hash of fields options



369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
 
# File 'app/controllers/anoubis/core/data/get.rb', line 369

def get_data_options(time)
  time = time.to_s.to_i
  self.setup_fields
  result = {}
  self.etc.data.fields.each do |key, field|
    if field.options
      if field.options.list
        if time == 0
          result[key] = field.options.list if field.options.show != 'never'
        else
          if field.model
            if field.options.show == 'always'
              result[key] = field.options.list
            else
              if field.options.show == 'update' && field.model.updated_at > time
                result[key] = field.options.list
              end
            end
          else
            result[key] = field.options.list if field.options.show == 'update' || field.options.show == 'always'
          end
        end
      end
    end
  end
  result
end

#get_data_row(row) ⇒ Hash

Get data fields defined in custom controller for single row

Parameters:

  • row (ActiveRecord) —

    single row of model data

Returns:

  • (Hash) —

    calculated hash of model row



212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
 
# File 'app/controllers/anoubis/core/data/get.rb', line 212

def get_data_row(row)
  fields = self.get_fields

  new_row = {}

  case self.etc.action
  when 'show'
    new_row = { id: row.id, sys_title: row.sys_title }
  when 'index', 'export'
    new_row = { id: row.id, sys_title: row.sys_title, actions: self.get_table_actions(row) }
  when 'new', 'create'
    new_row = {}
  when 'edit', 'update'
    new_row = { id: row.id, sys_title: row.sys_title }
  end

  fields.each_key do |key|
    begin
      value = eval 'row.' + fields[key].field
      error = false
    rescue
      new_row[key] = fields[key].error_text
      error = true
      if fields[key].type == 'key'
        error = false
      end
    end

    new_row = new_row.merge(self.convert_db_to_view_value(key, value)) if !error
  end

  return new_row
end

#get_eager_load ⇒ Object

Get default eager load definition for controller action



96
97
98
99
100
 
# File 'app/controllers/anoubis/core/data/get.rb', line 96

def get_eager_load
  return self.etc.data.eager_load if self.etc.data.model
  self.get_model
  return self.etc.data.eager_load
end

#get_edit_data_row(row) ⇒ Hash

Get table data for single row for edit or update actions.

Parameters:

  • row (ActiveRecord) —

    single row of model data

Returns:

  • (Hash) —

    calculated hash of model row



312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
 
# File 'app/controllers/anoubis/core/data/get.rb', line 312

def get_edit_data_row(row)
  self.setup_edit_fields
  new_row = { id: row.id, sys_title: row.sys_title }
  self.etc.data.fields.each do |key, field|
    if row.respond_to? field.field
      value = row.send field.field
      error = false
    else
      new_row[key] = field.error_text
      error = true
    end
    new_row = new_row.merge(self.convert_db_to_edit_value(key, value)) if !error
  end
  return new_row
end

#get_edit_eager_load ⇒ Object

Get default eager load definition for edit or update actions.



292
293
294
295
296
 
# File 'app/controllers/anoubis/core/data/get.rb', line 292

def get_edit_eager_load
  return self.etc.data.eager_load if self.etc.data.model
  self.get_edit_model
  return self.etc.data.eager_load
end

#get_edit_fields ⇒ Hash

Return current table fields hash for edit or update actions.

Returns:

  • (Hash) —

    current defined table fields



302
303
304
305
 
# File 'app/controllers/anoubis/core/data/get.rb', line 302

def get_edit_fields
  self.setup_edit_fields
  self.etc.data.fields
end

#get_edit_model ⇒ Object

Get model that is used for edit or update actions.



282
283
284
285
286
287
 
# File 'app/controllers/anoubis/core/data/get.rb', line 282

def get_edit_model
  return self.etc.data.model if self.etc.data.model
  self.etc.data.model = self.edit_model
  self.etc.data.eager_load = self.edit_eager_load
  return self.etc.data.model
end

#get_fields ⇒ Hash

Return current fields hash for defined action.

Returns:

  • (Hash) —

    current defined table fields



431
432
433
434
 
# File 'app/controllers/anoubis/core/data/get.rb', line 431

def get_fields
  self.setup_fields
  self.etc.data.fields
end

#get_fields_properties(fields = nil) ⇒ Hash

Returns fields for table output.

Returns:

  • (Hash) —

    calculated hash for fields properties for current action



174
175
176
177
178
179
180
181
182
183
184
185
 
# File 'app/controllers/anoubis/core/data/get.rb', line 174

def get_fields_properties(fields = nil)
  fields = fields_order if !fields
  result = []
  fields.each do |value|
    if self.etc.data.fields
      if self.etc.data.fields.key? value.to_sym
        result.push self.etc.data.fields[value.to_sym].properties(self.etc.data.model, self.etc.action) if self.etc.data.fields[value.to_sym].visible
      end
    end
  end
  result
end

#get_filter_properties ⇒ Hash

Returns fields for filter form.

Returns:

  • (Hash) —

    calculated hash for fields properties for current action



190
191
192
193
 
# File 'app/controllers/anoubis/core/data/get.rb', line 190

def get_filter_properties
  fields = filter_order
  self.get_fields_properties fields
end

#get_filter_where ⇒ Object 



120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
# File 'app/controllers/anoubis/core/data/get.rb', line 120

def get_filter_where
  #puts 'get_filter_where!'
  #puts self.etc.data.filter.to_h
  return if self.etc.data.filter
  filter = {}
  if params.key? :filter
    begin
      filter = JSON.parse(params[:filter]).with_indifferent_access.to_h
    rescue
      filter = {}
    end
  end
  self.setup_fields
  #puts 'get_filter_where'
  #puts self.etc.data.fields
  self.etc.data.filter = Anubis::Etc::Filter.new({ data: filter, fields: self.etc.data.fields })

  #puts self.etc.data.filter.to_h
end

#get_filter_where_array ⇒ Object 



145
146
147
148
 
# File 'app/controllers/anoubis/core/data/get.rb', line 145

def get_filter_where_array
  self.get_filter_where
  return self.etc.data.filter.array
end

#get_filter_where_hash ⇒ Object 



140
141
142
143
 
# File 'app/controllers/anoubis/core/data/get.rb', line 140

def get_filter_where_hash
  self.get_filter_where
  return self.etc.data.filter.hash
end

#get_formatted_string_field(options) ⇒ Hash

Returns formatted field hash for field type 'string'

Parameters:

  • options (Hash) —

    initial filed options

Options Hash (options):

  • :min (String) —

    defines minimum string length (default: 0)

  • :max (String) —

    defines maximum string length (default: 0)

Returns:

  • (Hash) —

    resulting hash for field type 'string'



465
466
467
468
 
# File 'app/controllers/anoubis/core/data/get.rb', line 465

def get_formatted_string_field(options)
  field = {}
  return field
end

#get_frame_button(key, button) ⇒ Hash

Get frame button

Parameters:

  • key (String) —

    button identificator

  • button (Hash) —

    initial button options

Options Hash (button):

  • :type (String) — default: 'default' —

    type of the button ('primary', 'danger', 'default')

  • :mode (String) — default: 'single' —

    button action object ('single', 'multiple')

  • :title (String) —

    title of the frame. If title isn't defined then system is trying to take value from yml translation file at path [<language>.<controller with dot>.frame.buttons.<key>.title] (eg. en.anubis.tenants.frame.buttons.new.title for english language 'anubis/tenants' controller 'new' button). If path absents then value isn't set.

  • :hint (String) —

    hint of the frame. If hint isn't defined then system is trying to take value from yml translation file at path [<language>.<controller with dot>.frame.buttons.<key>.hint] (eg. en.anubis.tenants.frame.buttons.new.hint for english language 'anubis/tenants' controller 'new' button). If path absents then value isn't set.

Returns:

  • (Hash) —

    resulting button options



35
36
37
38
39
40
41
42
43
44
45
 
# File 'app/controllers/anoubis/core/data/get.rb', line 35

def get_frame_button(key, button)
  button[:key] = key.to_s
  button[:type] = 'default' unless button.has_key? :type
  button[:mode] = 'single' unless button.has_key? :mode
  button[:decoration] = 'none' unless button.has_key? :decoration
  text = I18n.t('.buttons.'+button[:key]+'.title', default: '')
  button[:title] = text if text != ''
  text = I18n.t('.buttons.'+button[:key]+'.hint', default: '')
  button[:hint] = text if text != ''
  button
end

#get_frame_buttons(args = {}) ⇒ Hash

Get frame buttons data based on passed arguments.

Parameters:

  • args (Hash) (defaults to: {}) —

    additional parameters are used for define frame buttons.

Options Hash (args):

  • :tab (String) —

    tab is used for generation buttons

Returns:

  • (Hash) —

    returns resulting button hash



12
13
14
15
16
17
18
 
# File 'app/controllers/anoubis/core/data/get.rb', line 12

def get_frame_buttons(args = {})
  buttons = self.frame_buttons(args)
  buttons.each do |key, button|
    buttons[key] = self.get_frame_button key, button
  end
  buttons
end

#get_model ⇒ Object

Get model that is used for controller action



85
86
87
88
89
90
91
92
 
# File 'app/controllers/anoubis/core/data/get.rb', line 85

def get_model
  return self.etc.data.model if self.etc.data.model
  if defined? self.model
    self.etc.data.model = self.model
    self.etc.data.eager_load = self.eager_load
  end
  return self.etc.data.model
end

#get_new_data_row1(row) ⇒ Hash

Get table data for single row for new or create actions.

Parameters:

  • row (ActiveRecord) —

    single row of model data

Returns:

  • (Hash) —

    calculated hash of model row



347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
 
# File 'app/controllers/anoubis/core/data/get.rb', line 347

def get_new_data_row1(row)
  self.setup_new_fields
  new_row = {}
  self.etc.data.fields.each do |key, field|
    if row.respond_to? field.field
      value = row.send field.field
      error = false
    else
      new_row[key] = field.error_text
      error = true
    end
    new_row = new_row.merge(self.convert_db_to_new_value(key, value)) if !error
  end
  return new_row
end

#get_new_fields ⇒ Hash

Return current table fields hash for new or create actions

Returns:

  • (Hash) —

    current defined table fields



337
338
339
340
 
# File 'app/controllers/anoubis/core/data/get.rb', line 337

def get_new_fields
  self.setup_new_fields
  self.etc.data.fields
end

#get_order ⇒ Hash, String

Returns order for current tab

Returns:

  • (Hash, String) —

    order fore current tab



400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
 
# File 'app/controllers/anoubis/core/data/get.rb', line 400

def get_order
  return {id: :desc} if self.etc.tab.sort == nil

  result = {}

  field = self.etc.data.fields[self.etc.tab.sort.to_sym].order
  if field.field.class == Symbol
    result[field.field] = self.etc.tab.order
  else
    if field.field.class == String
      if field.field.index(',')
        result = field.field.gsub(',', ' ' + self.etc.tab.order.to_s.upcase + ',') + ' ' + self.etc.tab.order.to_s.upcase
      else
        result = field.field + ' ' + self.etc.tab.order.to_s.upcase
      end
    else
      if field.field.class == Array
        field.field.each do |item|
          if item.class == Symbol
            result[item] = self.etc.tab.order
          end
        end
      end
    end
  end
  result
end

#get_parent_data ⇒ ActiveRecord

Returns current parent data. If data not loaded then load it.

Returns:

  • (ActiveRecord) —

    resulting parent data



522
523
524
525
526
527
 
# File 'app/controllers/anoubis/core/data/get.rb', line 522

def get_parent_data
  if !self.etc.data.parent
    self.load_parent_data
  end
  self.etc.data.parent
end

#get_permited_params ⇒ Hash<Symbol, string>

Returns permitted parameters. Parameters is got from standard parameters output and checks according by described self.etc.data.fields.

Returns:

  • (Hash<Symbol, string>) —

    permitted paramters' collection



440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
 
# File 'app/controllers/anoubis/core/data/get.rb', line 440

def get_permited_params
  permit = []
  allowed = self.fields_order
  self.etc.data.fields.each_key do | key |
    single = true
    if self.etc.data.fields[key].type == 'listbox'
      single = false if self.etc.data.fields[key].format == 'multiple'
    end
    if single
      permit.push key
    else
      data = {}
      data[key] = []
      permit.push data
    end
  end
  params[:data].permit(permit).to_h.symbolize_keys
end

#get_tab(tab, options = {}) ⇒ Object

Get tab parameters

Parameters:

  • tab (String) —

    identifier

  • options (Hash) (defaults to: {}) —

    initial tab options

Options Hash (options):

  • :title (String) —

    title of the frame. If title isn't defined then value is taken from yml translation file at path [<language>.<controller with dot>.frame.tabs.<tab>.title] (eg. en.anubis.tenants.frame.tabs.all.title for english language 'anubis/tenants' controller 'all' tab). If path absents then value is set into humanized form of tab identifier (eg. 'All' for 'all' tab).

  • :hint (String) —

    hint of the frame. If hint isn't defined then system is trying to take value from yml translation file at path [<language>.<controller with dot>.frame.tabs.<tab>.hint] (eg. en.anubis.tenants.frame.tabs.all.hint for english language 'anubis/tenants' controller 'all' tab). If path absents then value isn't set.



59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
# File 'app/controllers/anoubis/core/data/get.rb', line 59

def get_tab(tab, options = {})
  options[:tab] = tab.to_s
  options[:title] = I18n.t('.tabs.'+options[:tab]+'.title', default: options[:tab].humanize) if !options.key? :title
  if !options.has_key? :hint
    hint = I18n.t('.tabs.'+options[:tab]+'.hint', default: '')
    options[:hint] = hint if hint != ''
  end

  if options.key? :export
    options[:export] = true if options[:export].class != FalseClass
  else
    options[:export] = self.is_export({ tab: tab.to_s })
  end

  if options.key? :filter
    options[:filter] = true if options[:filter].class != FalseClass
  else
    options[:filter] = self.is_filter({ tab: tab.to_s })
  end
  options[:buttons] = self.get_frame_buttons({ tab: options[:tab] })
  #options[:where] = self.where if !options.key? :where
  options
end

#get_tab_where ⇒ Object

Get where for controller action fro defined tab



104
105
106
107
 
# File 'app/controllers/anoubis/core/data/get.rb', line 104

def get_tab_where
  return self.etc.tab.where if self.etc.tab.where
  []
end

#get_table_action(action, row) ⇒ Boolean

Returns posibility of using action for table data

Parameters:

  • action (String) —

    desired action

  • row (ActiveRecord) —

    single active record row

Returns:

  • (Boolean) —

    is action present or not



266
267
268
269
270
271
272
273
274
 
# File 'app/controllers/anoubis/core/data/get.rb', line 266

def get_table_action(action, row)
  result = false
  if self.respond_to?(('table_action_'+action).to_sym)
    result = send 'table_action_'+action, row
  else
    result = true
  end
  result
end

#get_table_actions(row) ⇒ Hash

Returns current table actions for selected row

Parameters:

  • row (ActiveRecord) —

    single row of model data

Returns:

  • (Hash) —

    resulting has of buttons



250
251
252
253
254
255
256
257
258
259
 
# File 'app/controllers/anoubis/core/data/get.rb', line 250

def get_table_actions(row)
  self.etc.data.actions = self.table_actions if !self.etc.data.actions
  result = {}
  self.etc.data.actions.each do |value|
    if self.get_table_action value, row
      result[value.to_sym] = I18n.t(params[:controller].sub('/', '.')+'.table.actions.'+value, title: row.sys_title, default: I18n.t('actions.'+value, title: row.sys_title))
    end
  end
  result
end

#get_table_data ⇒ Object

Load data into the system variable self.etc.data.data and return fields defined in controller.



197
198
199
200
201
202
203
204
205
206
 
# File 'app/controllers/anoubis/core/data/get.rb', line 197

def get_table_data
  self.load_table_data self.etc.data.limit, self.etc.data.offset
  data = []
  if self.etc.data.data
    self.etc.data.data.each do |row|
      data.push get_data_row row
    end
  end
  data
end

#get_table_data_count ⇒ Integer

Get total number of rows in defined model. Also sets additional system properties self.etc.data.limit, self.etc.data.offset and self.etc.data.count

Returns:

  • (Integer) —

    the total number of rows.



157
158
159
160
161
162
163
164
165
166
167
168
169
 
# File 'app/controllers/anoubis/core/data/get.rb', line 157

def get_table_data_count
  self.load_table_data_count
  self.etc.data.limit = params[:limit] if params.has_key? :limit
  self.etc.data.offset = params[:offset] if params.has_key? :offset
  if self.etc.data.offset >= self.etc.data.count
    if self.etc.data.count > 0
      self.etc.data.offset = ((self.etc.data.count-1) / self.etc.data.limit).truncate * self.etc.data.limit
    else
      self.etc.data.offset = 0
    end
  end
  self.etc.data.count
end

#get_tenant_where(model) ⇒ Object 



115
116
117
118
 
# File 'app/controllers/anoubis/core/data/get.rb', line 115

def get_tenant_where(model)
  return { tenant_id: self.current_user.tenant_id } if model.new.respond_to? :tenant_id
  return {}
end

#get_where ⇒ Object

Get where for controller action



111
112
113
 
# File 'app/controllers/anoubis/core/data/get.rb', line 111

def get_where
  self.where
end