레일 - 검색 결과 필터링을위한 동적 쿼리 작성

Question

동적 검색 방법을 구축하여 검색 결과를 필터링하려고합니다.

내 모델 :

class Order < ActiveRecord::Base 
    scope :by_state, -> (state) { joins(:states).where("states.id = ?", state) } 
    scope :by_counsel, -> (counsel) { where("counsel_id = ?", counsel) } 
    scope :by_sales_rep, -> (sales) { where("sales_id = ?", sales) } 
    scope :by_year, -> (year) { where("title_number LIKE ?", "%NYN#{year}%") } 
    has_many :properties, :dependent => :destroy 
    has_many :documents, :dependent => :destroy 
    has_many :participants, :dependent => :destroy 
    has_many :states, through: :properties 
    belongs_to :action 
    belongs_to :role 
    belongs_to :type 
    belongs_to :sales, :class_name => 'Member' 
    belongs_to :counsel, :class_name => 'Member' 
    belongs_to :deal_name 
end 

class Property < ActiveRecord::Base 
    belongs_to :order 
    belongs_to :state 
end 

class State < ActiveRecord::Base 
    has_many :properties 
    has_many :orders, through: :properties 
end 

나는 기본적으로 모든 주문을 표시하는 페이지가 있습니다. 결과 필터링을 허용하는 확인란을 갖고 싶습니다. 필터는 Year, State, Sales 및 Counsel입니다. 검색어의 예는 다음과 같습니다. 상태 (has_many부터 NJ, PA, CA 등)의 2016 년, 2015 년 ("order.title_number LIKE?", "% NYN # {year} %")의 모든 주문은 sales_id 무제한 및 counsel_id 무제한 counsel_id.

너트 쉘에서 사용자가 확인하는 모든 옵션을 고려하여 하나의 쿼리를 작성하는 방법을 알아 내려고합니다. 현재 쿼리 코드는 다음과 같습니다.

def Order.query(opt = {}) 
    results = [] 
    orders = [] 

    if !opt["state"].empty? 
     opt["state"].each do |value| 
     if orders.empty? 
      orders = Order.send("by_state", value) 
     else 
      orders << Order.send("by_state", value) 
     end 
     end 
     orders = orders.flatten 
    end 

    if !opt["year"].empty? 
     new_orders = [] 

     opt["year"].each do |y| 
     new_orders = orders.by_year(y) 
     results << new_orders 
     end 
    end 

    if !opt["sales_id"].empty? 

    end 

    if !opt["counsel_id"].empty? 

    end 
    if !results.empty? 
     results.flatten 
    else 
     orders.flatten 
    end 
    end 

다음은 무제한 필터링을 허용하는 해결책입니다.

def self.query(opts = {}) 

    orders = Order.all 
    opts.delete_if { |key, value| value.blank? } 
    const_query = "" 
    state_query = nil 
    counsel_query = nil 
    sales_query = nil 
    year_query = nil 
    queries = [] 

    if opts["by_year"] 
     year_query = opts["by_year"].map do |val| 
     " title_number LIKE '%NYN#{val}%' " 
     end.join(" or ") 
     queries << year_query 
    end  

    if opts["by_sales_rep"] 
     sales_query = opts["by_sales_rep"].map do |val| 
     " sales_id = '#{val}' " 
     end.join(" or ") 
     queries << sales_query 
    end 

    if opts["by_counsel"] 
     counsel_query = opts["by_counsel"].map do |val| 
     " counsel_id = '#{val}' " 
     end.join(" or ") 
     queries << counsel_query 
    end 

    if opts["by_state"]  
     state_query = opts["by_state"].map do |val| 
     "states.id = '#{val}'" 
     end.join(" or ") 
    end 

    query_string = queries.join(" AND ") 

    if state_query 
     @orders = Order.joins(:states).where("#{state_query}") 
     @orders = @orders.where(query_string) 
    else 
     @orders = orders.where("#{query_string}") 
    end 

    @orders.order("title_number DESC") 
    end 

Answer 1

일반적인 패턴 인 검색어/필터 객체를 찾고 있습니까? 나는 이것과 비슷한 answer을 썼지 만 중요한 부분을 추출하려고 노력할 것이다.

먼저 논리를 해당 객체로 이동해야합니다. 검색/필터 개체가 초기화되면 관계 쿼리 (Order.all 또는 일부 기본 쿼리)로 시작한 다음 필터링을 수행해야합니다.

다음은 멋진 기본 예제로 올바른 트랙을 얻을 수 있습니다. 그렇게 부르면 orders = OrderQuery.call(params)입니다.

# /app/services/order_query.rb 
class OrderQuery 
    def call(opts) 
    new(opts).results 
    end 

    private 

    attr_reader :opts, :orders 

    def new(opts={}) 
    @opts = opts 
    @orders = Order.all # If using Rails 3 you'll need to use something like 
         # Order.where(1=1) to get a Relation instead of an Array. 
    end 

    def results 
    if !opt['state'].empty? 
     opt['state'].each do |state| 
     @orders = orders.by_state(state) 
     end 
    end 

    if !opt['year'].empty? 
     opt['year'].each do |year| 
     @orders = orders.by_year(year) 
     end 
    end 

    # ... all filtering logic 
    # you could also put this in private functions for each 
    # type of filter you support. 

    orders 
    end 
end 

EDIT : 사용하는 대신 또는 논리 AND 논리

# /app/services/order_query.rb 
class OrderQuery 
    def call(opts) 
    new(opts).results 
    end 

    private 

    attr_reader :opts, :orders 

    def new(opts={}) 
    @opts = opts 
    @orders = Order.all # If using Rails 3 you'll need to use something like 
         # Order.where(1=1) to get a Relation instead of an Array. 
    end 

    def results 
    if !opt['state'].empty? 
     @orders = orders.where(state: opt['state']) 
    end 

    if !opt['year'].empty? 
     @orders = orders.where(year: opt['year']) 
    end 

    # ... all filtering logic 
    # you could also put this in private functions for each 
    # type of filter you support. 

    orders 
    end 
end 

상기 구문은 기본적으로 말을 if state is in this array of states와 year is within this array of years 필터.