pureapi 0.3.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 04513fc90902a3fe0fb33d34312b7d73a741333f
-  data.tar.gz: c50754ff88d2863babdb95dafa6109369addeadc
+  metadata.gz: 1785ebfc9a66dd582d162f50449a27eb66283a97
+  data.tar.gz: 76c8d1f5aaff7c60b576414e41f97a96da52c164
 SHA512:
-  metadata.gz: c7915efdc3dee1f11e9afc7ab2803ad1d581d70f44eb7cfb66ebeb2bd90fd9af4792b9a9459858900860030382d902b66e1fa23b7e09f929337601a750bf01ae
-  data.tar.gz: 4022dc3fa66e213c9a01c31dfc5ed13ce043ceb5c018eace3f4126bd0d7b356c5d2e50e20d27bea32e94e37430f3469745d925daccb80f439c75109bacca0335
+  metadata.gz: 711367bd3e8cb79b9bd77d015a27a8d87de8bbedea5582c6616a9afee8a600dc13733a5e6d8886626cdc1b9143fcbf39db213a3c5adaa6cf7b4cf4cef69c9723
+  data.tar.gz: 4c3026a51a0ece1227c697d054abcc4cae1bd5eddb5d7be06ad33a336789d40e1ff1f61516464dab68e234ef3474bd33c71c4be6ed2887f28803c553d3c014b9

data/lib/pureapi.rb

@@ -3,6 +3,7 @@ module Pureapi
   autoload :Controller, 'pureapi/controller'
   # autoload :Model, 'pureapi/model'
   # autoload :MongoidModel, 'pureapi/mongoid_model'
+  # autoload :PostgresModel, 'pureapi/postgres_model'
 
   # Default way to set up Jwtauth.
   # a fresh initializer with all configuration values.

data/lib/pureapi/controller.rb

@@ -16,6 +16,18 @@ module Pureapi::Controller
   AFTER_REGEX = /\}/
 
   ### Begin 3 main API for GET data
+  # Filter list objects contain search, sort, paginate
+  def core_index_filter(objects)
+    # 1. search
+    objects = default_search_filter(objects)
+    # 2. sort and default sort is id.desc
+    objects = default_sort_filter(objects)
+    # 3. conditions (replace for +default_cond|incond_filter+)
+    objects = core_cond_filter(objects)
+    # 4. paginate
+    objects = paging_standard(objects)
+  end
+
   # Filter list objects contain search, sort, paginate
   def default_index_filter(objects)
     # 1. search
@@ -105,6 +117,42 @@ module Pureapi::Controller
     model.as_json(options)
   end
 
+  # New version of return json for index action
+  def records_as_json(criterias, includes_deep_level = 2)
+    options = {}
+    includes = []
+
+    if params.permit(:fields)[:fields]
+      # Get fields from params
+      _fields = parse_fields(params.permit(:fields)[:fields], includes_deep_level)
+      # Merge with as_json_fields of entity
+      options = merge_as_json(_fields, criterias.as_json_fields)
+      # Get relations for includes
+      includes += include_relations(options)
+    end
+
+    # Reflect options to params
+    params[:fields] = deparse_fields(options)
+    # Get relations for includes from methods
+    includes += criterias.json_method_includes.slice(*options[:methods]).values if !options[:methods].blank?
+
+    criterias.includes(includes).as_json(options)
+  end
+
+  # New version of return json for show action
+  def record_as_json(model, includes_deep_level = 2)
+    options = {}
+
+    if params.permit(:fields)[:fields]
+      # Get fields from params
+      _fields = parse_fields(params.permit(:fields)[:fields], includes_deep_level)
+      # Merge with as_json_fields of entity
+      options = merge_as_json(_fields, model.class.as_json_fields)
+    end
+
+    model.as_json(options)
+  end
+
   # Define json filters for params in render json api
   def filter_jsons
     {
@@ -281,6 +329,71 @@ module Pureapi::Controller
   end
   ### End setup of feature comparison conditions
 
+  ### Begin setup new version of feature comparison conditions
+  # Filter conditions of object criteria
+  def core_cond_filter(objects)
+    # Default +compcond_params+ for query
+    compcond_params = {}
+
+    # Collaborate params, operators, model to get +compcond_params+
+    if params[:compconds].is_a?(ActionController::Parameters)
+      compcond_params = parse_compcond_fields(params[:compconds], objects)
+    end
+
+    # Assign params[:compconds] after parse
+    params[:compconds] = deparse_compcond_fields(compcond_params)
+
+    # Add conditions of +compcond_params+ to objects
+    objects.compcond_search(compcond_params)
+  end
+
+  def parse_compcond_fields params, model, limit = 10
+    # Default results
+    _results = {only: [], include: {}}
+
+    params.keys.each do |key|
+      # Get field and operator from +key+ of model
+      matchs = model.compcond_match(key)
+
+      if matchs
+        matchs[:v] = params.permit(permit_operator(key, matchs[:o]))[key]
+
+        _results[:only] << matchs
+      end
+
+      # Process for belongs_to relations
+      entity = model.of_entities[key.to_sym]
+
+      if limit > 1 && entity && params[key].is_a?(ActionController::Parameters)
+        _results[:include][key.to_sym] = parse_compcond_fields(params[key], entity, limit - 1)
+      end
+    end
+
+    _results
+  end
+
+  def deparse_compcond_fields compcond_params
+    # Default results
+    _results = {}
+
+    # Assign from +compcond_params[:only]+
+    compcond_params[:only] && compcond_params[:only].each do |item|
+      _results["#{item[:f]}.#{item[:o]}"] = item[:v]
+    end
+
+    # Assign from +compcond_params[:include]+
+    compcond_params[:include] && compcond_params[:include].each do |key, item|
+      _results[key] = deparse_compcond_fields(item)
+    end
+
+    _results
+  end
+
+  def permit_operator key, operator
+    Pureapi::Model::PERMIT_OPERATORS[operator] ? { key => Pureapi::Model::PERMIT_OPERATORS[operator] } : key
+  end
+  ### End setup new version of feature comparison conditions
+
   ### Begin setup of paging_standard. If not use will_paginate, write in mode class
   # Method validate page number (like page params)
   def validate_page(page, page_total)
@@ -312,6 +425,33 @@ module Pureapi::Controller
   ### End setup of paging_standard
 
   ### Begin feature records_json and record_json which render format json
+  # Merge target from request params, source from model
+  #
+  # Arguments:
+  #   target: (Hash)
+  #   source: (Hash)
+  def merge_as_json(target ,source)
+    result = {}
+
+    if source[:only].is_a?(Array)
+      result[:only] = target[:only].is_a?(Array) ? (target[:only] & source[:only]) : source[:only]
+    end
+
+    if source[:methods].is_a?(Array) && target[:only].is_a?(Array)
+      result[:methods] = target[:only] & source[:methods]
+    end
+
+    if source[:include].is_a?(Hash) && target[:include].is_a?(Hash)
+      result[:include] = {}
+
+      (source[:include].keys & target[:include].keys).each do |k|
+        result[:include][k] = merge_as_json(target[:include][k], source[:include][k])
+      end
+    end
+
+    result.delete_if { |k, v| v.blank? }
+  end
+
   # Methods return hash contain full params use for ActiveRecord includes()
   # and ActiveModel::Serializers::JSON as_json()
   def parse_includes(fields, model, includes_deep_level = 2)

data/lib/pureapi/model.rb

@@ -33,6 +33,33 @@ module Pureapi::Model
   LOGICAL_OPERATORS_INVERT = LOGICAL_OPERATORS.invert
   NULL_OPERATOR_KEYS = NULL_OPERATORS.keys
 
+  # New version of +COMPARISON_OPERATORS+ & others
+  module Operators
+    EQ = { id: :eq, is: '=' }
+    NE = { id: :ne, is: '<>' }
+    GT = { id: :gt, is: '>' }
+    LT = { id: :lt, is: '<' }
+    GTE = { id: :gte, is: '>=' }
+    LTE = { id: :lte, is: '<=' }
+    LIKE = { id: :like, is: 'LIKE' }
+    NLIKE = { id: :nlike, is: 'NOT LIKE' }
+    REGEXP = { id: :regexp, is: 'REGEXP' }
+    IN = { id: :in, is: 'IN', permit: [] }
+    ISNIL = { id: :isnil, is: 'IS NULL' }
+    ISNNIL = { id: :isnnil, is: 'IS NOT NULL' }
+  end
+
+  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
 
   # return default array contains methods for as_json
   # Eg. [:status_name, :path_detail, :restrictions, :channel_course_code]
@@ -158,8 +185,137 @@ module Pureapi::Model
     self.column_names.map(&:to_sym)
   end
 
+  # Define relation entities can be included
+  # Example:
+  #   >> {User => [:manager], Department => [:department]}
+  def include_entities
+    {}
+  end
+
   # Require params is hash contain Integer :page, :per_page
   def paginate(params)
     self.limit(params[:per_page]).offset((params[:page] - 1) * params[:per_page])
   end
+
+  # Get all includes of relations in model
+  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
+
+  # Return all available values around model
+  def _json_fields nested_entities = []
+    nested_entities << self
+
+    {
+      only: default_onlyasjsons,
+      methods: json_methods,
+      include: get_includes(nested_entities),
+    }
+  end
+
+  # Static of +_json_fields+
+  def as_json_fields
+    @as_json_fields ||= self._json_fields
+  end
+
+  ### Begin methods for feature compconds filter
+  # Return list of all belongs_to => class_name
+  # Example:
+  #   >> {ad: Ad, lead_level: LeadLevel, course: Course}
+  def of_entities
+    {}
+  end
+
+  # Full compcond regexp for key
+  # Example:
+  #   >> id.gte
+  def compcond_regexp
+    @compcond_regexp ||= /^(#{compcond_columns.join("|")})\.(#{REFLECT_OPERATORS.keys.join("|")})$/
+  end
+
+  # Compcond regexp for key
+  # Example:
+  #   >> id
+  def compcond_regexp2nd
+    @compcond_regexp2nd ||= /^(#{compcond_columns.join("|")})$/
+  end
+
+  # Return matchs of key with +compcond_regexp+ || +compcond_regexp2nd+
+  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
+
+  # Return all fields can use for search of model
+  def _search_fields
+    _results = {only: compcond_columns, include: {}}
+
+    of_entities.each do |entity, _c|
+      _results[:include][entity] = _c._search_fields
+    end
+
+    _results
+  end
+
+  # Static of +_search_fields+
+  def compcond_fields
+    @compcond_fields ||= self._search_fields
+  end
+
+  # Search by params of attributes of model
+  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
+
+  # Search by params of relations
+  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
+
+  # Collaborate +_self_search+ & +_include_search+
+  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
+  ### End methods for feature compconds filter
 end

data/lib/pureapi/postgres_model.rb

@@ -0,0 +1,75 @@
+require 'active_support/concern'
+require 'pureapi/model'
+
+# Provide methods (override, polymorphic) for use data handling
+# # => comfortable when use postgresql
+
+module Pureapi::PostgresModel
+  extend ActiveSupport::Concern
+  include Pureapi::Model
+
+  # New version of +COMPARISON_OPERATORS+ & others
+  module Operators
+    EQ = { id: :eq, is: '=' }
+    NE = { id: :ne, is: '<>' }
+    GT = { id: :gt, is: '>' }
+    LT = { id: :lt, is: '<' }
+    GTE = { id: :gte, is: '>=' }
+    LTE = { id: :lte, is: '<=' }
+    LIKE = { id: :like, is: 'LIKE' }
+    NLIKE = { id: :nlike, is: 'NOT LIKE' }
+    REGEXP = { id: :regexp, is: '~' }
+    IN = { id: :in, is: 'IN', permit: [] }
+    ISNIL = { id: :isnil, is: 'IS NULL' }
+    ISNNIL = { id: :isnnil, is: 'IS NOT NULL' }
+  end
+
+  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
+
+  # Comparsion operator conditions method
+  # Array +params+ contains hash = {f, o, v}
+  # :f is column name
+  # :o is comparsion operator
+  # :v is value
+  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
+
+  # Search by params of attributes of model
+  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
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pureapi
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Dieu Pham
@@ -36,6 +36,7 @@ files:
 - lib/pureapi/controller.rb
 - lib/pureapi/model.rb
 - lib/pureapi/mongoid_model.rb
+- lib/pureapi/postgres_model.rb
 homepage: http://rubygems.org/gems/pureapi
 licenses:
 - MIT