care 0.1.0

data/lib/care.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+require "care/version"
+require "care/seed"
+require 'care/jwt_service'
+
+require 'rswag/specs'
+require 'rswag/api'
+require 'rswag/ui'
+
+
+require 'rails/generators'
+require 'jwt'
+require 'patch/action_controller/api'
+require 'cancancan'
+
+require 'care/finder'
+require 'activerecord-import'
+
+require 'active_model_serializers'
+ActiveModel::Serializer.config.adapter = :json
+
+require 'kaminari'
+
+module Care
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/lib/care/auto_finder/by_ids.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Care::AutoFinder
+  #
+  # Содержит методы для фильтрации по ids
+  #
+  # @example
+  #   class Finder
+  #     include ByIds
+  #
+  #     attr_accessor :params
+  #
+  #     def call
+  #       params = { ids: [1, 2, 3] }
+  #       by_ids(Document)
+  #     end
+  #   end
+  #
+  module ByIds
+    def ids(items)
+      params[:ids].present? ? items.where(id: params[:ids]) : items
+    end
+  end
+end

data/lib/care/auto_finder/findable.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Care::AutoFinder
+  module Findable
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      attr_accessor :chain_filter
+      # attr_accessor :relation
+
+      def set_relation(relation)
+        @relation = relation
+      end
+
+      def entity
+        self.relation = yield
+      end
+
+      def filter_by(*filters)
+        self.chain_filter = filters
+      end
+
+      def relation
+        @relation ||= /(.*)Finder/.match(name)[1].singularize.constantize
+      end
+
+      #
+      # @param [Hash] options параметры для работы файдера
+      # @option options [ActiveRecord] :relation модель, для которой будет вестись поиск
+      # @option options [Hash] :params опции для поиска
+      #
+      # @example
+      #   FooBarFinder
+      #     .call(
+      #       relation: FooBar,
+      #       params: { page: 10, limit: 2, name: 'Lorem' }
+      #     )
+      #
+      def call(options = {})
+        new(options).call
+      end
+    end
+
+    def initialize(options = {})
+      options = options.symbolize_keys
+      @relation = options[:relation] || self.class.relation || options[:params][:relation]
+      @params = options[:params] || options || {}
+    end
+
+    def call
+      collection = relation || self.class.relation
+
+      chain_filter.each do |filter|
+        collection = send(filter, collection)
+      end
+
+      collection.distinct
+    end
+
+    protected
+
+    attr_reader :relation, :params
+
+    def chain_filter
+      self.class.chain_filter || [:ids, :paginate, :search, :sort]
+    end
+  end
+end

data/lib/care/auto_finder/finder_methods.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Care::AutoFinder
+  module FinderMethods
+    extend ActiveSupport::Concern
+
+    included do
+      include Care::AutoFinder::Paginateble
+      include Care::AutoFinder::Searchable
+      include Care::AutoFinder::Sortable
+      include Care::AutoFinder::ByIds
+    end
+
+    def range_filter(options)
+      options = Struct.new(*options.keys).new(*options.values)
+
+      if options.start.present? && options.end.present?
+        options.collection.where(options.column => options.start..options.end)
+      elsif options.start.present?
+        options.collection.where("#{options.column} >= ?", options.start)
+      elsif options.end.present?
+        options.collection.where("#{options.column} <= ?", options.end)
+      else
+        options.collection
+      end
+    end
+  end
+end

data/lib/care/auto_finder/paginateble.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Care::AutoFinder
+  #
+  # Содержит методы для пагинации коллекции
+  #
+  # @example
+  #   class Finder
+  #     include Paginateble
+  #
+  #     attr_reader :params
+  #
+  #     def call
+  #       params = { page: 2, limit: 10 }
+  #       by_page(Document)
+  #     end
+  #   end
+  #
+  module Paginateble
+    DEFAULT_LIMIT = 100
+
+    def by_page(items)
+      params[:page].present? ? items.page(params[:page]).per(params[:limit] || DEFAULT_LIMIT) : items
+    end
+
+    def paginate(items)
+      by_page(items)
+    end
+  end
+end

data/lib/care/auto_finder/searchable.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Care::AutoFinder
+  #
+  # Содержит методы для полнотекстового поиска в коллекции
+  #
+  # @example
+  #   class Finder
+  #     include Care::AutoFinder::Searchable
+  #
+  #     attr_reader :params
+  #
+  #     search_by :name, :version
+  #     search_by :name, address: %i[locality street house flat]
+  #       # columns => [:name, {:address=>[:locality, :street, :house, :flat]}]
+  #
+  #     def call
+  #       params = { search: 'сзи' }
+  #       search(Document)
+  #     end
+  #   end
+  #
+  module Searchable
+    extend ActiveSupport::Concern
+
+    def search(items)
+      if params[:search].present?
+        Searcher.call(items: items, columns: columns, search: params[:search])
+      else
+        items
+      end
+    end
+
+    def search_into_array_field(column)
+      relation.where("array_to_string(#{column}, '||') LIKE ?", "%#{params[:search]}%")
+    end
+
+    def search_into_joined_field(field_path)
+      relation.where("#{field_path} LIKE ?", "%#{params[:search]}%")
+    end
+
+    module ClassMethods
+      attr_accessor :columns
+
+      def search_by(*columns)
+        self.columns = columns
+      end
+    end
+
+    protected
+
+    def columns
+      self.class.columns
+    end
+  end
+end

data/lib/care/auto_finder/searcher.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Care::AutoFinder
+  class Searcher
+    attr_reader :relation
+    attr_reader :query
+    attr_reader :columns
+    attr_reader :attributes
+    attr_reader :arel_table
+    attr_reader :table
+    attr_reader :pattern
+
+    def initialize(params)
+      @relation = params[:items]
+      @columns = params[:columns]
+      @attributes = params[:columns]
+      @query = params[:search]
+      @arel_table = relation.arel_table
+      @table = relation.arel_table
+      @pattern = "%#{sanitaze(query)}%"
+    end
+
+    def self.call(params)
+      new(params).call
+    end
+
+    def call
+      predicate = complile_node(relation, attributes).reduce { |memo, expression| memo ? memo.or(expression) : memo }
+      relation.where(predicate)
+    end
+
+    protected
+
+    def complile_node(relation, attributes)
+      expression = [*attributes].map { |attribute|
+        if attribute.is_a?(Symbol)
+          compile(relation, attribute)
+        elsif attribute.is_a?(Hash)
+          attribute.map do |child_relation, child_attributes|
+            complile_node(inner_relation(relation, child_relation), child_attributes)
+          end
+        end
+      }
+
+      expression.flatten
+    end
+
+    #
+    # rubocop:disable Metrics/AbcSize
+    #
+    def compile(relation, attribute)
+      if relation.columns_hash[attribute.to_s] && relation.columns_hash[attribute.to_s].type == :date
+        Arel.sql("to_char(#{attribute}, 'DD.MM.YYYY')").matches(pattern)
+      elsif relation.columns_hash[attribute.to_s] && relation.columns_hash[attribute.to_s].type == :datetime
+        Arel.sql("to_char(#{attribute}, 'DD.MM.YYYY')").matches(pattern)
+      elsif relation.columns_hash[attribute.to_s] && relation.columns_hash[attribute.to_s].type == :integer
+        Arel.sql("to_char(#{attribute}, '999')").matches(pattern)
+      elsif relation.columns_hash[attribute.to_s]&.array?
+        Arel.sql("array_to_string(#{attribute}, ', ')").matches(pattern)
+      elsif relation.respond_to?(:custom_columns) && relation.custom_columns[attribute]
+        Arel.sql(relation.custom_columns[attribute]).matches(pattern)
+      else
+        relation.arel_table[attribute].matches(pattern)
+      end
+    end
+    #
+    # rubocop:enable Metrics/AbcSize
+    #
+
+    private
+
+    def sanitaze(string, escape_character = '\\')
+      pattern = Regexp.union(escape_character, "%", "_")
+      string.gsub(pattern) { |x| [escape_character, x].join }
+    end
+
+    def inner_relation(relation, target_relation)
+      target = relation.reflections[target_relation.to_s]
+      target ? target.klass : ArtificalRelation.new(target_relation)
+    end
+
+    #
+    # Исскуственая модель, имеющая функцию arel_table
+    #
+    class ArtificalRelation
+      attr_accessor :table_name
+
+      def initialize(table_name)
+        @table_name = table_name
+      end
+
+      def arel_table
+        Arel::Table.new(table_name)
+      end
+
+      def columns_hash
+        {}
+      end
+    end
+  end
+end

data/lib/care/auto_finder/sortable.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Care::AutoFinder
+  #
+  # Содержит методы для сортировки коллекции
+  #
+  # @example
+  #   class Finder
+  #     include Sortable
+  #
+  #     attr_reader :params
+  #
+  #     def call
+  #       params = { sort: 'name_asc' }
+  #       sort(Document)
+  #     end
+  #   end
+  #
+  module Sortable
+    # def sort(items)
+    #   params[:sort].present? ? items.order(order_expiration) : items.order(created_at: :asc)
+    # end
+
+    def sort(items)
+      if params[:sort].present?
+        items.order(order_expiration)
+      elsif items.methods.include?(:default_sort)
+        items.default_sort
+      else
+        items.order(created_at: :asc)
+      end
+    end
+
+    private
+
+    def order_expiration
+      order_match_parts = params[:sort].rpartition("_")
+      {order_match_parts.first => order_match_parts.last}
+    end
+  end
+end

data/lib/care/finder.rb

@@ -0,0 +1,17 @@
+require_relative 'auto_finder/findable'
+require_relative 'auto_finder/paginateble'
+require_relative 'auto_finder/by_ids'
+require_relative 'auto_finder/sortable'
+require_relative 'auto_finder/searchable'
+require_relative 'auto_finder/finder_methods'
+
+module Care
+  class Finder
+    include Care::AutoFinder::Findable
+    include Care::AutoFinder::FinderMethods
+
+    def self.call(relation, params)
+      new(relation: relation, params: params).call
+    end
+  end
+end

data/lib/care/jwt_service.rb

@@ -0,0 +1,24 @@
+module Care
+  class JwtService
+    def decode(token)
+      decoded_token = JWT.decode(token, public_key, true, algorithm: 'RS256')
+      HashWithIndifferentAccess.new(decoded_token[0])
+    end
+
+    def encode(payload)
+      JWT.encode(payload, secret_key, 'RS256')
+    end
+
+    private
+
+    def public_key
+      key = File.read(ENV['JWT_SECRET_PATH'])
+      OpenSSL::PKey::RSA.new(key)
+    end
+
+    def secret_key
+      key = File.read(ENV['JWT_SECRET_PATH'])
+      OpenSSL::PKey::RSA.new(key)
+    end
+  end
+end

data/lib/care/rspec.rb

@@ -0,0 +1,15 @@
+require 'factory_bot_rails'
+require 'database_cleaner-active_record'
+require 'faker'
+require 'rspec-rails'
+require 'shoulda-matchers'
+require 'dotenv-rails'
+
+
+require_relative 'support/authorization_helper'
+require_relative 'support/error_collection'
+require_relative 'support/factory_bot'
+require_relative 'support/pagination'
+require_relative 'support/parameters'
+require_relative 'support/request_helper'
+