Module: Pureapi::Model

Included in:
MongoidModel, PostgresModel
Defined in:
lib/pureapi/model.rb

Overview

Implement methods use for handle with table records like

  1. Methods in as_json

2.

Defined Under Namespace

Modules: Operators, Pagination

Constant Summary collapse

COMPARISON_OPERATORS = 
{
  eq: '=',
  ne: '<>',
  gt: '>',
  lt: '<',
  gte: '>=',
  lte: '<=',
  like: 'LIKE',
  nlike: 'NOT LIKE',
  regex: 'REGEXP',
}
NULL_OPERATORS = 
{
  'null' => nil,
  'blank' => [nil, ''],
}
LOGICAL_OPERATORS = 
{
  in: 'IN'
}
COMPARISON_OPERATORS_INVERT = 
COMPARISON_OPERATORS.invert
LOGICAL_OPERATORS_INVERT = 
LOGICAL_OPERATORS.invert
NULL_OPERATOR_KEYS = 
NULL_OPERATORS.keys
REFLECT_OPERATORS = 
Operators.constants.inject({}) do |memo, const_name|
  item = Operators.const_get(const_name)
  memo[item[:id]] = item[:is]
  memo
end
PERMIT_OPERATORS = 
Operators.constants.inject({}) do |memo, const_name|
  item = Operators.const_get(const_name)
  memo[item[:id]] = item[:permit]
  memo
end

Instance Method Summary collapse

Instance Method Details

#_include_search(include_params) ⇒ Object

Search by params of relations



301
302
303
304
305
306
307
308
309
 
# File 'lib/pureapi/model.rb', line 301

def _include_search include_params
  criterias = self

  include_params.each do |entity, query|
    criterias = criterias.where(entity => of_entities[entity].compcond_search(query)) if of_entities[entity]
  end

  return criterias.where({})
end

#_json_fields(nested_entities = []) ⇒ Object

Return all available values around model



215
216
217
218
219
220
221
222
223
 
# File 'lib/pureapi/model.rb', line 215

def _json_fields nested_entities = []
  nested_entities << self

  {
    only: default_onlyasjsons,
    methods: json_methods,
    include: get_includes(nested_entities),
  }
end

#_search_fields ⇒ Object

Return all fields can use for search of model



267
268
269
270
271
272
273
274
275
 
# File 'lib/pureapi/model.rb', line 267

def _search_fields
  _results = {only: compcond_columns, include: {}}

  of_entities.each do |entity, _c|
    _results[:include][entity] = _c._search_fields
  end

  _results
end

#_self_search(only_params) ⇒ Object

Search by params of attributes of model



283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
 
# File 'lib/pureapi/model.rb', line 283

def _self_search only_params
  criterias = self

  only_params.each do |filter|
    case filter[:o]
    when Operators::EQ[:id], Operators::IN[:id]
      criterias = criterias.where(filter[:f] => filter[:v])
    when Operators::ISNIL[:id], Operators::ISNNIL[:id]
      criterias = criterias.where("`#{self.table_name}`.`#{filter[:f]}` #{REFLECT_OPERATORS[filter[:o]]}")
    else
      criterias = criterias.where("`#{self.table_name}`.`#{filter[:f]}` #{REFLECT_OPERATORS[filter[:o]]} ?", filter[:v])
    end
  end

  return criterias.where({})
end

#advanced_search(advanced_params) ⇒ Object

return criterias.where({}) end



93
94
95
 
# File 'lib/pureapi/model.rb', line 93

def advanced_search(advanced_params)
  return self.where({})
end

#as_json_fields ⇒ Object

Static of _json_fields



226
227
228
 
# File 'lib/pureapi/model.rb', line 226

def as_json_fields
  @as_json_fields ||= self._json_fields
end

#asjson_fields ⇒ Object

Define default fields use for asjson on includes E.g 

channel: {only: [:id, :code, :name], include: Channel.asjson_fields,
course: [:id, :code, :name]

}



175
176
177
 
# File 'lib/pureapi/model.rb', line 175

def asjson_fields
  {}
end

#compcond_columns ⇒ Object

Define array of columns use for comparison conditions E.g [:id, :name, :channel_course_id, :status]



153
154
155
 
# File 'lib/pureapi/model.rb', line 153

def compcond_columns
  [:id]
end

#compcond_fields ⇒ Object

Static of _search_fields



278
279
280
 
# File 'lib/pureapi/model.rb', line 278

def compcond_fields
  @compcond_fields ||= self._search_fields
end

#compcond_match(str) ⇒ Object

Return matchs of key with compcond_regexp || compcond_regexp2nd



253
254
255
256
257
258
259
260
261
262
263
264
 
# File 'lib/pureapi/model.rb', line 253

def compcond_match(str)
  _matchs = compcond_regexp.match(str) || compcond_regexp2nd.match(str)

  if _matchs
    {
      f: _matchs[1],
      o: _matchs[2] ? _matchs[2].to_sym : :eq,
    }
  else
    nil
  end
end

#compcond_regexp ⇒ Object

Full compcond regexp for key Example:

>> id.gte



241
242
243
 
# File 'lib/pureapi/model.rb', line 241

def compcond_regexp
  @compcond_regexp ||= /^(#{compcond_columns.join("|")})\.(#{REFLECT_OPERATORS.keys.join("|")})$/
end

#compcond_regexp2nd ⇒ Object

Compcond regexp for key Example:

>> id



248
249
250
 
# File 'lib/pureapi/model.rb', line 248

def compcond_regexp2nd
  @compcond_regexp2nd ||= /^(#{compcond_columns.join("|")})$/
end

#compcond_search(params) ⇒ Object

Collaborate _self_search & _include_search



312
313
314
315
316
317
318
319
 
# File 'lib/pureapi/model.rb', line 312

def compcond_search params
  criterias = self

  criterias = criterias._self_search(params[:only]) if params[:only].is_a?(Array)
  criterias = criterias._include_search(params[:include]) if params[:include].is_a?(Hash)

  return criterias.where({})
end

#compconds(params = []) ⇒ Object

Comparsion operator conditions method Array params contains hash = o, v :f is column name :o is comparsion operator :v is value



120
121
122
123
124
125
126
127
128
129
130
131
132
 
# File 'lib/pureapi/model.rb', line 120

def compconds(params = [])
  criterias = self

  params.each do |param|
    if param[:o] == COMPARISON_OPERATORS[:eq]
      criterias = criterias.where(param[:f] => param[:v])
    else
      criterias = criterias.where("`#{self.table_name}`.`#{param[:f]}` #{param[:o]} ?", param[:v])
    end
  end

  return criterias.where({})
end

#default_includes ⇒ Object

Define default includes of active records E.g [:channel, :course]



165
166
167
 
# File 'lib/pureapi/model.rb', line 165

def default_includes
  []
end

#default_onlyasjsons ⇒ Object

Define default fields use for as_jsons



184
185
186
 
# File 'lib/pureapi/model.rb', line 184

def default_onlyasjsons
  self.column_names.map(&:to_sym)
end

#full_search(params, advanced_params) ⇒ Object

Provide search function 2 type: normal and advanced Required setup advanced_search methods

ActionController::Parameters _params, contain fields use .where() ActionController::Parameters _advanced_params, detail in advanced_search method Or Hash _params, contain fields use .where() Hash _advanced_params, detail in advanced_search method



105
106
107
108
109
110
111
112
113
 
# File 'lib/pureapi/model.rb', line 105

def full_search(params, advanced_params)
  _params = params.delete_if { |k, v| v.blank? }

  criterias = self
  criterias = _params.blank? ? criterias : criterias.where(_params.to_h)
  criterias = advanced_params.blank? ? criterias : criterias.advanced_search(advanced_params.to_h)

  return criterias.where({})
end

#get_includes(nested_entities) ⇒ Object

Get all includes of relations in model



201
202
203
204
205
206
207
208
209
210
211
212
 
# File 'lib/pureapi/model.rb', line 201

def get_includes nested_entities
  _results = {}
  _entities = include_entities

  (_entities.keys - nested_entities).each do |_c|
    _entities[_c].each do |_r|
      _results[_r] = _c._json_fields(nested_entities)
    end
  end

  _results
end

#include_entities ⇒ Object

Define relation entities can be included Example:

>> {User => [:manager], Department => [:department]}



191
192
193
 
# File 'lib/pureapi/model.rb', line 191

def include_entities
  {}
end

#incond_columns ⇒ Object

Define array of columns use for in conditions (logical) E.g [:id, :name, :channel_course_id, :status]



159
160
161
 
# File 'lib/pureapi/model.rb', line 159

def incond_columns
  [:id]
end

#json_method_includes ⇒ Object 



179
180
181
 
# File 'lib/pureapi/model.rb', line 179

def json_method_includes
  {}
end

#json_methods ⇒ Object

return default array contains methods for as_json Eg. [:status_name, :path_detail, :restrictions, :channel_course_code]



66
67
68
 
# File 'lib/pureapi/model.rb', line 66

def json_methods
  []
end

#logicconds(params = []) ⇒ Object

Comparsion operator conditions method Array params contains hash = o, v :f is column name :o is comparsion operator :v is value



139
140
141
142
143
144
145
146
147
148
149
 
# File 'lib/pureapi/model.rb', line 139

def logicconds(params = [])
  criterias = self

  params.each do |param|
    if param[:o] == LOGICAL_OPERATORS[:in]
      criterias = criterias.where(param[:f] => param[:v])
    end
  end

  return criterias.where({})
end

#of_entities ⇒ Object

Begin methods for feature compconds filter Return list of all belongs_to => class_name Example:

>> {ad: Ad, lead_level: LeadLevel, course: Course}



234
235
236
 
# File 'lib/pureapi/model.rb', line 234

def of_entities
  {}
end

#paginate(params) ⇒ Object

Require params is hash contain Integer :page, :per_page



196
197
198
 
# File 'lib/pureapi/model.rb', line 196

def paginate(params)
  self.limit(params[:per_page]).offset((params[:page] - 1) * params[:per_page])
end