pureapi 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 29f9ce1d05cb751dbf596027db202822a3673eaa
+  data.tar.gz: f3166e0119282f230f7250782153cf83a4bb884e
+SHA512:
+  metadata.gz: c0e73f3029f3d785c960599c23cc6d71f5041044eaa9e80c205246bf1b100178fe2345bf5e91720cc467a92e310bb9e703bf8f88ed2ad3a33f3b55c2365e327a
+  data.tar.gz: a4b8f0a24ef52c14f16e34d884ca3b9a3447d2703c383d9cd32f558962ffaa7d0e652856a99b5fea6d1cc5ef20718bd65327119085de4288f085556dd1fbcf4d

data/bin/pureapi

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'pureapi'
+puts Pureapi.about(ARGV[0])

data/lib/pureapi/controller.rb

@@ -0,0 +1,484 @@
+# Implement methods use for handle with table records like
+# 1. Pagination
+# 2. Sort
+# 3. Search
+# 4. Include
+module Pureapi::Controller
+  # extend ActiveSupport::Concern
+
+  # Define constants of regex table and column name
+  FIELD_NAME = '[a-z_][a-z0-9_]*'
+  NAME_REGEX = /#{FIELD_NAME}/
+  FULLBEFORE_REGEX = /#{FIELD_NAME}\{/
+  BEFORE_REGEX = /\{/
+  AFTER_REGEX = /\}/
+
+  ### Begin 3 main API for GET data
+  # Filter list objects contain search, sort, paginate
+  def default_index_filter(objects)
+    # 1. search
+    # 2. sort and default sort is id.desc
+    objects = default_sort_filter(objects)
+    # 3. conditions
+    objects = default_cond_filter(objects)
+    objects = default_incond_filter(objects)
+    # 4. paginate
+    objects = paging_standard(objects)
+  end
+
+  # Filter list objects contain search, sort, limit
+  def default_report_filter(objects)
+    # 1. search
+    # 2. sort and default sort is id.desc
+    # 3. conditions
+    objects = default_cond_filter(objects)
+    objects = default_incond_filter(objects)
+    # 4. limit similar paginate
+  end
+
+  # Return json for index action
+  def records_json(criterias, includes_deep_level = 2)
+    options = {}
+    includes = criterias.default_includes
+
+    if params.permit(:fields)[:fields]
+      jsons = parse_includes(params.permit(:fields)[:fields], criterias, includes_deep_level)
+
+      includes += jsons[:includes] if !jsons[:includes].blank?
+      options = jsons[:as_json] if !jsons[:as_json].blank?
+    end
+
+    params[:fields] = deparse_fields(options)
+    options[:methods] = criterias.json_methods
+    options[:only] = options[:only].blank? ? criterias.default_onlyasjsons : options[:only]
+    criterias = criterias.includes(includes) if !includes.blank?
+    criterias.as_json(options)
+  end
+
+  # Return json for show action
+  def record_json(model, includes_deep_level = 2)
+    options = {}
+
+    if params.permit(:fields)[:fields]
+      jsons = parse_includes(params.permit(:fields)[:fields], model.class, includes_deep_level)
+
+      options = jsons[:as_json] if !jsons[:as_json].blank?
+    end
+
+    options[:only] = options[:only].blank? ? model.class.default_onlyasjsons : options[:only]
+    options[:methods] = model.class.json_methods
+    model.as_json(options)
+  end
+
+  # Return json for index action
+  def records_asjson(criterias)
+    options = {}
+    includes = []
+
+    if params.permit(:fields)[:fields]
+      jsons = parse_includes(params.permit(:fields)[:fields], criterias)
+
+      includes += jsons[:includes] if !jsons[:includes].blank?
+      options = jsons[:as_json] if !jsons[:as_json].blank?
+    end
+
+    params[:fields] = deparse_fields(options)
+    options[:only] = options[:only].blank? ? criterias.default_onlyasjsons : options[:only]
+    includes += criterias.json_method_includes.slice(*options[:methods]).values if !options[:methods].blank?
+
+    criterias.includes(includes.uniq).as_json(options)
+  end
+
+  # Return json for show action
+  def record_asjson(model)
+    options = {}
+
+    if params.permit(:fields)[:fields]
+      jsons = parse_includes(params.permit(:fields)[:fields], model.class)
+
+      options = jsons[:as_json] if !jsons[:as_json].blank?
+    end
+
+    options[:only] = options[:only].blank? ? model.class.default_onlyasjsons : options[:only]
+    model.as_json(options)
+  end
+
+  # Define json filters for params in render json api
+  def filter_jsons
+    {
+      paging: {
+        page: params[:page],
+        per_page: params[:per_page],
+        page_total: params[:page_total],
+        record_total: params[:record_total],
+        next: params[:page] < params[:page_total] ? (params[:page] + 1) : nil,
+        prev: params[:page] > 1 ? (params[:page] - 1) : nil,
+      },
+      orders: params[:orders] || [],
+      searches: params[:searches] || {},
+      compconds: params[:compconds] || {},
+      logics: params[:logics] || {},
+      fields: params[:fields] || ''
+    }
+  end
+
+  def report_filter_jsons
+    {
+      searches: params[:searches] || {},
+      compconds: params[:compconds] || {},
+      logics: params[:logics] || {},
+    }
+  end
+  ### End 3 main API for GET data
+
+  ### Begin options API for GET data
+  # Filter list objects contain search, sort, paginate
+  def standard_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
+    objects = default_cond_filter(objects)
+    objects = default_incond_filter(objects)
+    # 4. paginate
+    objects = paging_standard(objects)
+  end
+
+  # Filter list objects contain search, sort
+  def without_paging_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
+    objects = default_cond_filter(objects)
+    objects = default_incond_filter(objects)
+  end
+  ### End options API for GET data
+
+  ### Begin setup of default_search_filter
+  # Filter searchs of object criteria
+  def default_search_filter(objects)
+    params[:searches] = search_params
+    advanced_search_params.each{|k, v| params[:searches][k] = v}
+
+    objects = objects.full_search(search_params, advanced_search_params)
+  end
+  ### End setup of default_search_filter
+
+  ### Begin setup of default_sort_filter (.order asc|desc)
+  # Filter orders of object criteria
+  def default_sort_filter(objects)
+    orders = parse_orders(params.permit(orders: [])[:orders], objects.column_names)
+    orders[:id] = :desc if orders.blank?
+    params[:orders] = orders.map{|field, order_type| "#{field}.#{order_type}"}.uniq
+    objects.order(orders)
+  end
+
+  # array orders contains field.asc or field
+  # array column_names contains valid fields
+  # return hash of field => sort type (asc, desc)
+  def parse_orders(orders = [], column_names = [])
+    results = {}
+
+    orders.map do |order|
+      matchs = /(#{FIELD_NAME})\.(asc|desc)/.match(order) || /(#{FIELD_NAME})/i.match(order)
+      results[matchs[1]] = matchs[2] || 'asc' if matchs && column_names.include?(matchs[1])
+    end unless orders.blank?
+
+    results
+  end
+  ### End setup of default_sort_filter
+
+  ### Begin setup of feature comparison conditions
+  # Filter conditions of object criteria
+  # Need upgrade calculate compcond_params
+  def default_cond_filter(objects)
+    compcond_params = []
+
+    objects.compcond_columns.each do |column_name|
+      Constants::COMPARISON_OPERATORS.each do |key, value|
+        compcond_params << [column_name, key].join('.')
+      end
+    end
+
+    compconds = parse_compconds(params.permit(compconds: compcond_params)[:compconds].to_h, objects.column_names)
+    params[:compconds] = {}
+
+    compconds.each do |compcond|
+      params[:compconds]["#{compcond[:f]}.#{Constants::COMPARISON_OPERATORS_INVERT[compcond[:o]]}"] = compcond[:v]
+    end
+
+    objects.compconds(compconds)
+  end
+
+  # Not use under code because lte => lt
+  # matchs = /([a-z0-9_]+)\.(#{Constants::COMPARISON_OPERATORS.keys.join('|')})/.match(key)
+  # if matchs && column_names.include?(matchs[1])
+  #   results << {f: matchs[1], o: Constants::COMPARISON_OPERATORS[matchs[2].to_sym], v: value}
+  # end
+  def parse_compconds(compconds = {}, column_names = [])
+    results = []
+
+    compconds.map do |key, value|
+      splits = key.split('.')
+
+      if splits.length == 2 && column_names.include?(splits[0])
+        if splits[1].to_sym == :eq && Constants::NULL_OPERATOR_KEYS.include?(value)
+          results << {
+            f: splits[0],
+            o: Constants::COMPARISON_OPERATORS[splits[1].to_sym],
+            v: Constants::NULL_OPERATORS[value]}
+        else
+          results << {f: splits[0], o: Constants::COMPARISON_OPERATORS[splits[1].to_sym], v: value}
+        end
+      end
+    end unless compconds.blank?
+
+    results
+  end
+  ### End setup of feature comparison conditions
+
+  ### Begin setup of feature in conditions (logical)
+  # Filter conditions of object criteria
+  # Need upgrade calculate compcond_params
+  def default_incond_filter(objects)
+    logic_params = []
+
+    objects.incond_columns.each do |column_name|
+      logic_params << {[column_name, :in].join('.') => []}
+    end
+
+    logics = parse_logicconds(params.permit(logics: logic_params)[:logics].to_h, objects.column_names)
+    params[:logics] = {}
+
+    logics.each do |logic|
+      params[:logics]["#{logic[:f]}.#{Constants::LOGICAL_OPERATORS_INVERT[logic[:o]]}"] = logic[:v]
+    end
+
+    objects.logicconds(logics)
+  end
+
+  # References from parse_compconds methods
+  # Upgrade results.push(!value.blank?) >> +parse_compconds+
+  def parse_logicconds(compconds = {}, column_names = [])
+    results = []
+
+    compconds.map do |key, value|
+      next if value.blank?
+
+      splits = key.split('.')
+
+      if splits.length == 2 && column_names.include?(splits[0])
+        results << {f: splits[0], o: Constants::LOGICAL_OPERATORS[splits[1].to_sym], v: value}
+      end
+    end unless compconds.blank?
+
+    results
+  end
+  ### End setup 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)
+    page.blank? || page <= 0 ? 1 : (page > page_total ? page_total : page)
+  end
+
+  # Paging standard
+  # Criteria model that will be pagination
+  # Return criteria_model.paginate and params[:page, :per_page, :page_total]
+  def paging_standard(criteria_model)
+    per_page = [paging_params[:per_page].try(:to_i) || Constants::Pagination::DEFAULT_PER_PAGE, 1].max
+
+    # Paging standard
+    record_total = criteria_model.count
+    per_page = record_total if paging_params[:per_page] == Constants::Pagination::INFINITE_PER_PAGE\
+      && record_total > 0
+    page_total = (record_total.to_f / per_page).ceil
+    page = validate_page(paging_params[:page].try(:to_i) || 1, page_total)
+    page = [page, 1].max
+
+    # Assign paging params to params helper
+    params[:page] = page
+    params[:per_page] = per_page
+    params[:page_total] = page_total
+    params[:record_total] = record_total
+
+    criteria_model.paginate(page: page, per_page: per_page)
+  end
+  ### End setup of paging_standard
+
+  ### Begin feature records_json and record_json which render format json
+  # 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)
+    _fields = parse_fields(fields, includes_deep_level)
+
+    if _fields[:only].is_a?(Array) && !_fields[:only].blank?
+      _fields[:methods] = _fields[:only] & model.json_methods
+      _fields[:only] = _fields[:only] & model.column_names.map(&:to_sym)
+    end
+
+    if _fields[:include].is_a?(Hash) && !_fields[:include].blank?
+      _fields[:include] = merge_includes(_fields[:include], model.asjson_fields)
+    end
+
+    {
+      includes: include_relations(_fields),
+      as_json: _fields.delete_if { |k, v| v.blank? }
+    }
+  end
+
+  # Methods parse string fields user for as_json
+  # Example str = "a,b, c,d,e,f,g{k,l,h{b,i}},w{n, m},j,t{ww, gh, l{bb}}, f{k, mm}, vv"
+  # return result = {:only=>["a", "b", "c", "d", "e", "f", "j", "vv"],
+  # :include=>{"g"=>{:only=>["k", "l"], :include=>{"h"=>{:only=>["b", "i"]}}},
+  # "w"=>{:only=>["n", "m"]}, "t"=>{:only=>["ww", "gh"], :include=>{"l"=>{:only=>["bb"]}}},
+  # "f"=>{:only=>["k", "mm"]}}}
+  def parse_fields(str, deep = 2)
+    result = { only: [], include: {} }
+
+    fullbefore = substr_index(str, FULLBEFORE_REGEX)
+    after = substr_index(str, AFTER_REGEX)
+
+    if fullbefore.length == after.length
+      if fullbefore.length == 0
+        result[:only] = str.scan(NAME_REGEX)
+      else
+        kvs = openandclose(fullbefore, after)
+        _kvs = openandclose(substr_index(str, BEFORE_REGEX), after).invert
+        s = 0
+
+        kvs.each do |k, v|
+          if s < k
+            result[:only] += str[s..(k - 1)].scan(NAME_REGEX)
+            s = v + 1
+          elsif
+            s = v + 1
+          end
+
+          if k < v && deep > 0
+            result[:include][str[k..v][NAME_REGEX].to_sym] =\
+              parse_fields(str[(_kvs[v] + 1)..(v - 1)], deep - 1)
+          end
+        end
+
+        if s < (str.length - 1)
+          result[:only] += str[s..-1].scan(NAME_REGEX)
+        end
+      end
+    end
+
+    result[:only] = result[:only].map(&:to_sym)
+    return result.delete_if { |k, v| v.blank? }
+  end
+
+  # Hash +fields+
+  # return String is params query
+  def deparse_fields(fields)
+    return '' unless fields.is_a? Hash
+
+    _arr = []
+
+    if fields[:only].is_a? Array
+      _arr += fields[:only]
+    end
+
+    if fields[:methods].is_a? Array
+      _arr += fields[:methods]
+    end
+
+    if fields[:include].is_a?(Hash) && !fields[:include].blank?
+      fields[:include].each do |k, v|
+        _arr << "#{k}{#{deparse_fields(v)}}"
+      end
+    end
+
+    _arr.join(',')
+  end
+
+  # Require length of before and after is equal
+  # +before.length == after.length > 1+
+  def openandclose(before, after)
+    results = {}
+
+    index = 0
+    results[before[index]] = after[index]
+    before.each_with_index do |value, i|
+      if results[before[index]] > value
+        results[before[index]] = after[i]
+      else
+        index = i
+        results[before[index]] = after[index]
+      end
+    end
+
+    return results
+  end
+
+  # return Array all index of sub_str in str
+  def substr_index(str, sub_str)
+    i = 0
+    all = []
+    while (i = str.index(sub_str, i)).is_a? Integer
+      all << i
+      i += str[i..-1][sub_str].length
+    end
+    all
+  end
+
+  # return all relations be included by fields
+  def include_relations(fields)
+    result = []
+
+    if fields[:include].is_a? Hash
+      fields[:include].each do |k, v|
+        if (v.is_a? Hash) && (v[:include].is_a? Hash)
+          result << { k => include_relations(v)}
+        else
+          result << k
+        end
+      end
+    end
+
+    result
+  end
+
+  def merge_includes(target ,source)
+    result = {}
+
+    target.each do |k, v|
+      result[k] = {}
+
+      if v.is_a?(Hash) && source[k].is_a?(Hash)
+        if source[k][:only].is_a?(Array)
+          result[k][:only] = v[:only].is_a?(Array) ? (v[:only] & source[k][:only]) : source[k][:only]
+        end
+
+        if v[:include].is_a?(Hash) && source[k][:include].is_a?(Hash)
+          result[k][:include] = merge_includes(v[:include], source[k][:include])
+        end
+      end
+    end
+
+    result.delete_if { |k, v| v.blank? }
+  end
+  ### End feature records_json and record_json
+
+  ### Begin declare strong parameters
+  def paging_params
+    params.permit(:page, :per_page)
+  end
+
+  # Strong parameters for default search query
+  def search_params
+    params.permit()
+  end
+
+  # Strong parameters for default advanced search query
+  def advanced_search_params
+    params.permit()
+  end
+  ### End declare strong parameters
+end

data/lib/pureapi/model.rb

@@ -0,0 +1,128 @@
+# Implement methods use for handle with table records like
+# 1. Methods in as_json
+# 2.
+module Pureapi::Model
+  # return default array contains methods for as_json
+  # Eg. [:status_name, :path_detail, :restrictions, :channel_course_code]
+  def json_methods
+    []
+  end
+
+  # return default criterias for advanced_search
+  # Eg.
+  # User .where({}) to fix case return self
+  # def advanced_search(advanced_params)
+  #   criterias = self
+
+  #   # search by list course_ids
+  #   criterias = advanced_params[:course_ids].blank? ?
+  #     criterias : criterias.where(course_id: advanced_params[:course_ids])
+
+  #   # search by list channel_ids
+  #   criterias = advanced_params[:channel_ids].blank? ?
+  #     criterias : criterias.where(channel_id: advanced_params[:channel_ids])
+
+  #   # search by code
+  #   criterias = advanced_params[:code].blank? ?
+  #     criterias : criterias.where(
+  #       "`channel_courses`.`code` LIKE ?",
+  #       "%#{advanced_params[:code]}%"
+  #     )
+
+  #   return criterias.where({})
+  # end
+  def advanced_search(advanced_params)
+    return self.where({})
+  end
+
+  # 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
+  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
+
+  # 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] == '='
+        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
+
+  # Comparsion operator conditions method
+  # Array +params+ contains hash = {f, o, v}
+  # :f is column name
+  # :o is comparsion operator
+  # :v is value
+  def logicconds(params = [])
+    criterias = self
+
+    params.each do |param|
+      if param[:o] == 'IN'
+        criterias = criterias.where(param[:f] => param[:v])
+      end
+    end
+
+    return criterias.where({})
+  end
+
+  # Define array of columns use for comparison conditions
+  # E.g [:id, :name, :channel_course_id, :status]
+  def compcond_columns
+    [:id]
+  end
+
+  # Define array of columns use for in conditions (logical)
+  # E.g [:id, :name, :channel_course_id, :status]
+  def incond_columns
+    [:id]
+  end
+
+  # Define default includes of active records
+  # E.g [:channel, :course]
+  def default_includes
+    []
+  end
+
+  # Define default fields use for asjson on includes
+  # E.g
+  # {
+  #   channel: {only: [:id, :code, :name], include: Channel.asjson_fields},
+  #   course: {only: [:id, :code, :name]}
+  # }
+  def asjson_fields
+    {}
+  end
+
+  def json_method_includes
+    {}
+  end
+
+  # Define default fields use for as_jsons
+  def default_onlyasjsons
+    self.column_names.map(&:to_sym)
+  end
+end

data/lib/pureapi.rb

@@ -0,0 +1,16 @@
+class Pureapi
+  class << self
+    # Say hi to you & talk about gem!
+    #
+    # Example:
+    #   >> Pureapi.about("spanish")
+    #   => hello spanish
+    #
+    # Arguments:
+    #   yourname: (String)
+
+    def about yourname
+      "hello #{yourname}. This is a library for pure api"
+    end
+  end
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: pureapi
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dieu Pham
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-08-10 00:00:00.000000000 Z
+dependencies: []
+description: A simple concern in model & controller for api
+email: dieupv@topica.edu.vn
+executables:
+- pureapi
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/pureapi
+- lib/pureapi.rb
+- lib/pureapi/controller.rb
+- lib/pureapi/model.rb
+homepage: http://rubygems.org/gems/pureapi
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: Pure API
+test_files: []