Filters by remote_availibity, location, position_type in query object

apps/web/controllers/vacancies/index.rb

@@ -34,8 +34,23 @@ def call(params)
 
         private
 
+        Container = Module.new do
+          extend Transproc::Registry
+          import Transproc::HashTransformations
+          import Transproc::Coercions
+          import Transproc::ClassTransformations
+        end
+
+        class Transformer < Transproc::Transformer[Container]
+          symbolize_keys
+          map_value :remote, t(:to_boolean)
+          constructor_inject Queries::Vacancy::SearchQuery
+        end
+
         def search_query
-          params[:query] ? search_query_parser.call(params[:query]) : EMPTY_SEARCH_QUERY
+          query_attributes = params[:query] ? search_query_parser.call(params[:query]) : EMPTY_SEARCH_QUERY
+          initial_attributes = { remote: nil, position_type: nil, location: nil }
+          Transformer.new.call(initial_attributes.merge(query_attributes))
         end
       end
     end

lib/core/queries/vacancy.rb

@@ -1,30 +1,48 @@
 # frozen_string_literal: true
 
 module Queries
+  class Vacancy
+    class SearchQuery < Dry::Struct
+      attribute :remote, Core::Types::Strict::Bool.optional.default(nil)
+      attribute :position_type, Core::Types::VacancyPositionTypes.optional.default(nil)
+      attribute :location, Core::Types::Strict::String.optional.default(nil)
+    end
+  end
+
   class Vacancy
     attr_reader :repo
 
     def initialize(repo = VacancyRepository.new)
       @repo = repo
     end
 
-    def all_with_contact(limit:, page:)
-      all_with_contact_relation(limit: limit, page: page).to_a
+    def all_with_contact(limit:, page:, search_query:)
+      all_with_contact_relation(limit: limit, page: page, search_query: search_query).to_a
     end
 
-    def pager_for_all_with_contact(limit:, page:)
+    def pager_for_all_with_contact(limit:, page:, search_query:)
       Hanami::Pagination::Pager.new(
-        all_with_contact_relation(limit: limit, page: page).pager
+        all_with_contact_relation(limit: limit, page: page, search_query: search_query).pager
       )
     end
 
     private
 
-    def all_with_contact_relation(limit:, page:)
-      repo.aggregate(:contact)
-          .where(published: true, archived: false, deleted_at: nil)
-          .map_to(::Vacancy).order { created_at.desc }
-          .per_page(limit).page(page || 1)
+    QUERY_MODIFIERS = {
+      remote: ->(query, filter_value) { query.where(remote_available: filter_value) },
+      position_type: ->(query, filter_value) { query.where(position_type: filter_value) },
+      location: ->(query, filter_value) { query.where { location.ilike("%#{filter_value}%") } }
+    }.freeze
+
+    def all_with_contact_relation(limit:, page:, search_query:)
+      query = repo.aggregate(:contact)
+                  .where(published: true, archived: false, deleted_at: nil)
+      search_query.to_h.each do |key, value|
+        modifier = QUERY_MODIFIERS[key]
+        query = modifier.call(query, value) if modifier && value
+      end
+      query.map_to(::Vacancy).order { created_at.desc }
+           .per_page(limit).page(page || 1)
     end
   end
 end

lib/vacancies/operations/list.rb

@@ -9,9 +9,13 @@ class List < ::Libs::Operation
 
       PAGINATION_LIMIT = 10
 
-      def call(search_query: {}, page: 1) # rubocop:disable Lint/UnusedMethodArgument
-        pager = vacancy_query.pager_for_all_with_contact(limit: PAGINATION_LIMIT, page: page || 1)
-        result = vacancy_query.all_with_contact(limit: PAGINATION_LIMIT, page: page || 1)
+      def call(search_query: {}, page: 1)
+        pager = vacancy_query.pager_for_all_with_contact(
+          limit: PAGINATION_LIMIT,
+          page: page || 1,
+          search_query: search_query
+        )
+        result = vacancy_query.all_with_contact(limit: PAGINATION_LIMIT, page: page || 1, search_query: search_query)
 
         Success(result: result, pager: pager)
       end

spec/core/queries/vacancy_spec.rb

@@ -2,11 +2,27 @@
 
 RSpec.describe Queries::Vacancy, type: :query do
   let(:repo) { described_class.new }
+  let(:query_attributes) { return { remote: nil, position_type: nil, location: nil } }
+  let(:search_query) { Queries::Vacancy::SearchQuery.new }
 
   describe '#all_with_contact' do
-    subject { repo.all_with_contact(limit: 10, page: 1) }
+    subject { repo.all_with_contact(limit: 10, page: 1, search_query: search_query) }
 
-    before { Fabricate.create(:vacancy, published: published, archived: archived, deleted_at: deleted_at) }
+    let(:remote_available) { nil }
+    let(:position_type) { nil }
+    let(:location) { nil }
+
+    before do
+      Fabricate.create(
+        :vacancy,
+        published: published,
+        archived: archived,
+        deleted_at: deleted_at,
+        remote_available: remote_available,
+        position_type: position_type,
+        location: location
+      )
+    end
 
     context 'when vacancy published and not archived or deleted' do
       let(:published) { true }
@@ -16,6 +32,42 @@
       it { expect(subject.count).to eq(1) }
       it { expect(subject).to all(be_a(Vacancy)) }
       it { expect(subject.first.contact).to be_a(Contact) }
+
+      context 'and remote in search_query is true' do
+        let(:search_query) { Queries::Vacancy::SearchQuery.new(query_attributes.merge(remote: true)) }
+
+        it { expect(subject).to eq([]) }
+
+        context 'and remote_available in record is true as well' do
+          let(:remote_available) { true }
+
+          it { expect(subject.count).to eq(1) }
+        end
+      end
+
+      context 'and position_type in search_query is equal "other"' do
+        let(:search_query) { Queries::Vacancy::SearchQuery.new(query_attributes.merge(position_type: 'other')) }
+
+        it { expect(subject).to eq([]) }
+
+        context 'and position_type in record is "other" as well' do
+          let(:position_type) { 'other' }
+
+          it { expect(subject.count).to eq(1) }
+        end
+      end
+
+      context 'and location in search query is not empty' do
+        let(:search_query) { Queries::Vacancy::SearchQuery.new(query_attributes.merge(location: 'VASYUKI')) }
+
+        it { expect(subject).to eq([]) }
+
+        context 'and location in record includes location from search query' do
+          let(:location) { 'New Vasyuki' }
+
+          it { expect(subject.count).to eq(1) }
+        end
+      end
     end
 
     context 'when vacancy published and archived' do

spec/web/controllers/vacancies/index_spec.rb

@@ -24,7 +24,7 @@
       it { expect(subject).to be_success }
 
       it do
-        expect(operation).to receive(:call).with(page: nil, search_query: { remote: 'true', text: 'search text' })
+        expect(operation).to receive(:call).with(page: nil, search_query: Queries::Vacancy::SearchQuery.new(remote: true, location: nil, position_type: nil)) 
         subject
       end
     end