c80_shared 0.1.67 → 0.1.68

data/app/services/abstract_prices_service.rb

@@ -0,0 +1,70 @@
+class AbstractPricesService
+
+  attr_reader :built_prices
+
+  def initialize(all_currencies = ::Dicts::Currency::ALL2)                                                              # all_currencies - список валют, в которых надо сохранить цены
+    @all_currencies = all_currencies
+    _reset_ivars
+  end
+
+  private
+
+  def _model
+    raise NotImplementedError
+  end
+
+  def _fields_for_create
+    raise NotImplementedError
+  end
+
+  def _save(prices)                                                                                                     # помещаем в базу всё одним запросом
+    filtered = prices.select { |el| !el[:_delete] && el[:value].to_i != 0 }                                             # игнорируя цены, которые были помечены "к удалению" или те, у которых значение 0 (0 можно подавать, если хотим "удалить" цену продажи)
+    return if filtered.size.zero?
+
+    values = filtered.map do |p|
+      _fields_for_create.map do |field|
+        p[field.to_sym]
+      end.compact * ','
+    end * '),('
+    values = '(%s)' % values
+    sql    = 'INSERT INTO %s(%s) VALUES %s' % [_model.table_name, _fields_for_create * ',', values]
+    ActiveRecord::Base.connection.execute sql
+
+    filtered
+  end
+
+  # из базы удаляем все записи, принадлежащие данной лодке
+  # т.к. считаем, что с формы приходит полная картина по ценам
+  # кроме того, юзер может просто изменить, например, период в уже
+  # существующей строке с ценами, которую он видит на экране
+  def _delete_existing_records(boat_id)
+    sql = 'DELETE FROM %s WHERE boat_id = %s' % [_model.table_name, boat_id]
+    ActiveRecord::Base.connection.execute sql
+  end
+
+  def _build_other(price)                                                                                               # отталкиваясь от валюты входных данных, рассчитываем "те же" цены в других валютах
+    return if price[:_delete] || price[:value].to_i == 0                                                                # игнорируя цены, которые были помечены "к удалению" или те, у которых значение 0 (0 можно подавать, если хотим "удалить" цену продажи)
+
+    incoming_curr  = ::Dicts::Currency.find(price[:currency_id])
+    currs_to_build = @all_currencies - [incoming_curr]
+    rates          = Currency.fresh(incoming_curr.index).rates
+    rates          = JSON.parse(rates)['rates']
+
+    currs_to_build.each do |curr|
+      rate               = rates[curr.index]
+      res                = price.clone
+      res[:currency_id]  = curr.id
+      res[:value]        = res[:value].to_f * rate
+      res[:is_orig]      = false
+      @built_prices      << res
+    end
+  end
+
+  def _delete_bad_values(prices)
+    prices.delete_if { |price| price[:value].nil? || price[:value].to_f.zero? }
+  end
+
+  def _reset_ivars
+    @built_prices = []
+  end
+end

data/app/services/boats/boat_prices_save_service.rb

@@ -0,0 +1,79 @@
+module Boats
+  #
+  # spec/services/boat/boat_prices_save_service_spec.rb
+  #
+  class BoatPricesSaveService < ::AbstractPricesService
+
+    attr_reader :is_for_rent
+
+    def self.perform(boat, params)
+      new.perform(boat, params)
+    end
+
+    def perform(boat, prices = nil)
+      _reset_ivars
+      return false if prices.nil?
+
+      boat_prices_params = prices.deep_dup                                                                              # Rails deep_dup https://apidock.com/rails/Hash/deep_dup
+      boat_prices_params = boat_prices_params.map { |bp| bp.symbolize_keys }
+      filtered           = _delete_bad_values boat_prices_params
+      return false if filtered.size.zero?                                                                               # взаимодействия с базой не будет, если все цены с "плохими" значениями
+
+      filtered.each do |bp|                                                                                             # bp = {uom_id, season_id, currency_id, duration, value, discount}
+        bp[:boat_id]    = boat.id
+        bp[:is_orig]    = true
+        bp[:value]      = bp[:value].is_a?(String) ? bp[:value].split(/[, ]/).join : bp[:value]                         # с формы может прийти строка, сгруппированная по разрадям, вида "100,100,222"
+        bp[:duration]   = format('%.1f', bp[:duration])
+        bp[:discount]   = bp[:discount].to_f                                                                            # с формы может прийти пустая строка ''
+        bp[:created_at] = '\'%s\'' % Time.now.to_s(:db)
+        _build_other bp
+      end
+
+      filtered2 = _del_duplicates(filtered + @built_prices)
+      return false if filtered2.size.zero?
+
+      saved = nil
+      ActiveRecord::Base.transaction do
+        _delete_existing_records boat.id
+        saved = _save filtered2
+      end
+
+      @is_for_rent = _detect_for_rent saved
+      true
+    end
+
+    private
+
+    def _model
+      BoatPrice
+    end
+
+    def _fields_for_create
+      @fields_for_create ||= %w'boat_id uom_id duration season_id is_orig discount currency_id value created_at'
+    end
+
+
+    def _delete_bad_values(prices)
+      prices.delete_if do |price|
+        price[:value].nil? || price[:value].to_f.zero? || format('%.1f', price[:duration].to_f) == '0.0'
+      end
+    end
+
+    def _del_duplicates(params)                                                                                         # подстраховываемся, вдруг форма прислала что-то не то
+      grouped  = params.group_by { |row| [row[:duration].to_f, row[:uom_id], row[:season_id], row[:currency_id]] }      # убираем из params массива дубликаты согласно уникальному индексу в db
+      grouped.map {|_, v| v.first }
+    end
+
+    def _reset_ivars
+      @is_for_rent = nil
+      super
+    end
+
+    def _detect_for_rent(saved_prices)
+      return 0 if saved_prices.nil?
+      # noinspection RubySimplifyBooleanInspection
+      !!saved_prices.select { |bp| !bp[:_delete] }.size.nonzero? ? 1 : 0
+    end
+
+  end
+end

data/app/services/boats/boat_sale_prices_save_service.rb

@@ -0,0 +1,58 @@
+module Boats
+  #
+  # [spec/services/boat/boat_sale_price_save_service_spec.rb]
+  #
+  class BoatSalePricesSaveService < ::AbstractPricesService
+
+    attr_reader :is_for_sale
+
+    def self.perform(boat_id, price)
+      new.perform boat_id, price
+    end
+
+    def perform(boat_id, price = nil)
+      _reset_ivars
+      return false if price.nil?
+
+      sp = price.dup
+      sp[:boat_id]    = boat_id
+      sp[:is_orig]    = true
+      sp[:value]      = sp[:value].is_a?(String) ? sp[:value].split(/[, ]/).join : sp[:value].to_i                      # с формы может прийти строка, сгруппированная по разрадям, вида "100,100,222" + тут же превращаем nil в 0
+      sp[:discount]   = sp[:discount].present? ? sp[:discount] : 0
+      sp[:created_at] = '\'%s\'' % Time.now.to_s(:db)
+      _build_other sp
+
+      filtered2 = @built_prices + [sp]
+      saved     = nil
+      ActiveRecord::Base.transaction do
+        _delete_existing_records boat_id
+        saved = _save filtered2
+      end
+
+      @is_for_sale = _detect_for_sale saved
+      true
+    end
+
+    private
+
+    def _model
+      BoatSalePrice
+    end
+
+    def _fields_for_create
+      @fields_for_create ||= %w'boat_id currency_id value discount is_orig created_at'
+    end
+
+    def _reset_ivars
+      @is_for_sale = nil
+      super
+    end
+
+    def _detect_for_sale(saved_prices)
+      return 0 if saved_prices.nil?
+      # noinspection RubySimplifyBooleanInspection
+      !!saved_prices.select { |bp| bp[:value].to_i != 0 }.size.nonzero? ? 1 : 0
+    end
+
+  end
+end

data/app/services/central_agent/save_boat_service.rb

@@ -0,0 +1,117 @@
+module CentralAgent
+  class SaveBoatService
+
+    attr_reader :errors, :boat
+
+    def initialize
+      _reset_ivars
+    end
+
+    # @param [Hash] boat_params
+    # @param [Hash] cookies  example: {... "currency"=>"USD", "dimension"=>"ft", "volume"=>"liters", "business"=>"rent", "language"=>"en"}
+    #
+    def perform(boat_params, cookies, current_user, state: Boat::STATE_PREMODERATED)
+      _reset_ivars
+
+      @schema = ::Schemas::CentralAgent::SaveBoatSchema.new boat_params.dup                                             # проверяем параметры, пришедшие с формы
+      unless @schema.valid?
+        @errors = @schema.errors.messages
+        return false
+      end
+
+      if boat_params[:id].present?
+        boat = _update_boat(@schema.attributes, cookies)
+      else
+        boat = _create_boat(@schema.attributes, cookies, current_user, state)
+      end
+
+      @boat = boat
+      true
+    end
+
+    private
+
+    def _create_boat(boat_params, cookies, current_user, state)                                                         # TODO:: проверить и доработать при необходимости (ref /home/scout/git/get-the-boat/app/services/boat_register_service.rb)
+      prms = _fuck_params boat_params
+
+      boat = Boat.new
+      boat.assign_attributes prms
+      boat.state = state
+
+      _handle_boat_attributes(boat, cookies)
+
+      ActiveRecord::Base.transaction do
+        boat.users << current_user
+
+        boat.send :set_slug
+        boat.save validate: false
+        boat.update_attribute(:boat_photo_id, boat.boat_photos.first.id)                                                # TODO:: реализовать назначение главного фото (пока же на скорую руку делаем первую фотку главной)
+        _save_prices boat
+      end
+
+      boat
+    end
+
+    def _update_boat(boat_params, cookies)                                                                              # TODO:: реализовать назначение главного фото (в админке, например, приходит такое: "boat"=>{"boat_photo_id"=>"41434"})
+      # _fuck_params - подгоняем под active_record (перегоняем массив в хэш)
+      #boat_locs2                       = boat_params[:boat_locations_attributes].compact.map { |attr| [attr[:id], attr] }.to_h
+      #prms                             = boat_params.except(:rent_prices, :sale_price, :boat_locations_attributes)      # с формы из кабинета, в отличии от админки, приходит длина в виде "boat_length_metrics_ft" => "12.0"
+      #prms[:boat_locations_attributes] = boat_locs2
+      prms = _fuck_params boat_params
+
+      boat = Boat.find boat_params[:id]
+      boat.assign_attributes prms
+
+      _handle_boat_attributes(boat, cookies)
+
+      ActiveRecord::Base.transaction do
+        boat.send :set_slug
+        boat.save validate: false
+        _save_prices boat
+        boat.cancel if boat.state == ::Boat::STATE_APPROVED.to_s                                                        # кто знает, что там наизменял агент в своей лодке, вдруг фотки с телефонами загрузил?
+      end
+
+      boat
+    end
+
+    # boat_params - это атрибуты схемы
+    def _fuck_params(boat_params)
+      # подгоняем под active_record (перегоняем массив в хэш)
+      boat_locs2                       = boat_params[:boat_locations_attributes].compact.map { |attr| [(attr[:id] || -(rand*1000).to_i), attr] }.to_h
+      prms                             = boat_params.except(:rent_prices, :sale_price, :boat_locations_attributes, :main_boat_photo_id)      # с формы из кабинета, в отличии от админки, приходит длина в виде "boat_length_metrics_ft" => "12.0"
+      prms[:boat_photo_id]             = boat_params[:main_boat_photo_id]
+      prms[:boat_locations_attributes] = boat_locs2
+      prms
+    end
+
+    def _handle_boat_attributes(boat, cookies)
+      dimension_service = ::DimensionService.new(boat)                                                                    # присланные измерения переведём в другие единицы измерения
+      dimension_service.calculate_boat_attributes(cookies[:dimension])
+
+      # volume_service = VolumeService.new(boat)
+      # volume_service.calculate_boat_attributes(cookies[:volume])
+    end
+
+    # сохраним цены аренды и цену продажи
+    def _save_prices(boat)
+      service = ::Boats::BoatPricesSaveService.new
+      result  = service.perform boat, @schema.attributes[:rent_prices]
+
+      if result && boat.for_rent != service.is_for_rent                                                                 # result = true - обязательное условие
+        boat.update_columns for_rent: service.is_for_rent
+      end
+
+      service = ::Boats::BoatSalePricesSaveService.new
+      result  = service.perform boat.id, @schema.attributes[:sale_price]
+
+      if result && boat.for_sale != service.is_for_sale                                                                 # result = true - обязательное условие
+        boat.update_columns for_sale: service.is_for_sale
+      end
+    end
+
+    def _reset_ivars
+      @errors = { }
+      @boat   = nil
+    end
+  end
+end

data/app/services/dimension_service.rb

@@ -0,0 +1,42 @@
+class DimensionService
+
+  def initialize model
+    @model = model
+  end
+
+  def calculate_boat_attributes default_dimension
+
+    attributes = [:boat_length_metrics, :boat_beam_metrics, :boat_draft_metrics, :boat_gross_tonage]
+
+    available_dimensions(default_dimension).each do |available_dimension|
+
+      # puts "#{available_dimension} #{default_dimension}"
+      dimension_value = Dimension::COMPARISON[default_dimension.to_sym][available_dimension.to_sym]
+
+      attributes.each do |attribute|
+        attribute_dimension         = attribute.to_s + "_#{available_dimension}"
+        attribute_default_dimension = attribute.to_s + "_#{default_dimension}"
+        default_dimension_value     = @model.attributes[attribute_default_dimension.downcase]
+
+        if default_dimension_value
+          calculated_dimension = default_dimension_value * dimension_value
+          @model.send("#{attribute_dimension}=", calculated_dimension)
+          # puts "#{default_dimension_value} #{default_dimension} is #{calculated_dimension} #{available_dimension}"
+        else
+          @model.send("#{attribute_dimension}=", nil)
+        end
+      end
+    end
+
+  end
+
+  def available_dimensions default_dimension
+    available_dimensions = []
+    I18n::t('static.dimensions').select do |dimension|
+      next if dimension[:id] == default_dimension
+      available_dimensions << dimension[:id]
+    end
+    available_dimensions
+  end
+
+end

data/app/services/lease/create_broadcast_inquiry_service.rb

@@ -0,0 +1,68 @@
+module Lease
+  #
+  # Если заявка создаётся НЕ со страницы лодки - используется этот сервис
+  #
+  class CreateBroadcastInquiryService
+
+    attr_reader :inquiry, :errors
+
+    def initialize
+      _reset_instance_variables
+    end
+
+    def perform(client_account, params)
+      _reset_instance_variables
+
+      @inquiry = ::Lease::Inquiry.new
+      _assign_attributes(client_account, params)
+      return false unless @inquiry.valid?
+
+      inquiry_profile = ::Lease::InquiryProfile.new inquiry: @inquiry
+
+      @inquiry.transaction do
+        @inquiry.save!
+        inquiry_profile.save!
+      end
+
+      if params[:uploaded_license_file].present?
+        ::Lease::LicenseService.new.process_license_file(client_account, params[:uploaded_license_file])
+      end
+
+      true
+    end
+
+    protected
+
+    def _assign_attributes(client_account, params)
+      @inquiry.client_account      = client_account
+      @inquiry.address             = params[:address]
+      @inquiry.latitude            = params[:latitude]
+      @inquiry.longitude           = params[:longitude]
+      @inquiry.from                = params[:from]
+      @inquiry.to                  = params[:to]
+      @inquiry.name                = params[:name]
+      @inquiry.phone_number        = params[:phone_number]
+      @inquiry.is_skippered        = params[:is_skippered]
+      @inquiry.comments            = params[:comments]
+      @inquiry.need_transfer       = params[:need_transfer]
+      @inquiry.watersports         = params[:watersports]
+      @inquiry.guests              = params[:guests]
+      @inquiry.kids                = params[:kids]
+      @inquiry.boat_type_ids       = params[:boat_types] # fuckin' rent_form.rb
+      @inquiry.staying_overnight   = params[:staying_overnight]
+      @inquiry.hours_per_day       = params[:hours_per_day]&.join(',')
+
+      if params[:my_price].present? && !params[:my_price].to_i.zero?
+        @inquiry.my_price          = params[:my_price]
+        @inquiry.my_price_currency = params[:my_price_currency]
+        @inquiry.is_my_price       = true
+      end
+    end
+
+    def _reset_instance_variables
+      @errors  = { }
+      @inquiry = nil
+    end
+
+  end
+end

data/config/initializers/core_ext/string.rb

@@ -0,0 +1,62 @@
+class String
+
+  def clear_query
+    dup.clear_query!
+  end
+
+  def clear_query!
+    gsub!(/\s+/, ' ')
+    strip!
+    self
+  end
+
+  def nums_only
+    scan(/\d/).join
+  end
+
+  def numeric?
+    true if Float(self) rescue false
+  end
+
+  def to_bool
+    %w[t true yes on 1].include? self
+  end
+
+  def sanitize(options = {})
+    ActionController::Base.helpers.sanitize(self, options)
+  end
+
+  def nl2br
+    dup.nl2br!
+  end
+
+  def nl2br!
+    gsub!(/\r/, '')
+    gsub!(/\n/, '<br>')
+    self
+  end
+
+  def strip_leading_zeros
+    dup.strip_leading_zeros!
+  end
+
+  def strip_leading_zeros!
+    gsub!(/^0+/, '')
+    self
+  end
+
+  def try_to_integer
+    Integer( try_to_big_decimal ) rescue self
+  end
+
+  def try_to_big_decimal
+    gsub!(/\s/, '')
+    begin
+      Float(self)
+    rescue
+      return self
+    end
+    BigDecimal(self)
+  end
+
+end

data/lib/c80_shared/version.rb

@@ -1,3 +1,3 @@
 module C80Shared
-  VERSION = "0.1.67"
+  VERSION = "0.1.68"
 end

data/lib/c80_shared.rb

@@ -3,6 +3,33 @@ lambda do
   lib_path  = '%s/**/*.rb' % File.expand_path('../c80_shared', __FILE__)
   # noinspection RubyResolve
   Dir[lib_path].each { |f| require_relative f }
+
+  require_relative 'dry/errors'
+  require_relative 'dry/schema'
+  require_relative 'dry/rule'
+
+  require_relative 'dry/rules/binary'
+  require_relative 'dry/rules/composite'
+  require_relative 'dry/rules/between'
+  require_relative 'dry/rules/min_length'
+  require_relative 'dry/rules/greater_than'
+  require_relative 'dry/rules/not_equal'
+  require_relative 'dry/rules/less_than'
+  require_relative 'dry/rules/greater_than_or_equal'
+  require_relative 'dry/rules/collection'
+  require_relative 'dry/rules/length_between'
+  require_relative 'dry/rules/or'
+  require_relative 'dry/rules/and'
+  require_relative 'dry/rules/less_than_or_equal'
+  require_relative 'dry/rules/then'
+  require_relative 'dry/rules/format'
+  require_relative 'dry/rules/present'
+  require_relative 'dry/rules/length_equal'
+  require_relative 'dry/rules/included'
+  require_relative 'dry/rules/equal'
+  require_relative 'dry/rules/max_length'
+
+  require_relative 'dry/rules_factory'
 end.call
 
 # загружаем все классы из директории app

data/lib/dry/errors.rb

@@ -0,0 +1,77 @@
+module Dry
+  class Errors
+
+    attr_reader :messages
+
+    def initialize(messages = {})
+      @messages = messages
+    end
+
+
+    def add(key, message)
+      keys = key.to_s.split('.').map!(&:to_sym)
+      old  = messages.dig(*keys[0...-1]) rescue {}
+      old  = {} unless old.is_a?(Hash)
+      new  = keys[0...-1].inject(messages) { |h, k| h[k] ||= {} rescue h = {}; h[k] = {} }
+      new[keys.last] = [] unless new.is_a?(Array)
+      new[keys.last] << message
+      new.merge!(old)
+    end
+
+
+    def merge!(error, parent_key = nil)
+      hash_to_dots(error.messages, {}, parent_key).each do |key, messages|
+        messages.each { |message| add(key, message) }
+      end
+      messages
+    end
+
+
+    def any?
+      messages.any?
+    end
+
+
+    def has_key?(key)
+      keys = key.to_s.split('.').map!(&:to_sym)
+      keys.size == 1 ? messages[keys.first].present? : (messages.dig(*keys[0...-1])[keys.last].present? rescue false)
+    end
+
+
+    def first_message
+      fetch_messages(messages.values.first).first
+    end
+
+
+    def clone
+      self.class.new(messages.clone)
+    end
+
+
+    private
+
+
+    def hash_to_dots(hash, results = {}, start_key = '')
+      hash.each do |key, value|
+        key = key.to_s
+        key_value = start_key.present? ? sprintf('%s.%s', start_key, key) : key
+        if value.is_a?(Hash)
+          results.merge!(hash_to_dots(value, results, key_value))
+        else
+          results[key_value] = value
+        end
+      end
+      results
+    end
+
+
+    def fetch_messages(value)
+      if value.is_a?(Hash)
+        fetch_messages(value.values.first)
+      else
+        value
+      end
+    end
+
+  end
+end

data/lib/dry/rule.rb

@@ -0,0 +1,69 @@
+module Dry
+  class Rule
+
+    attr_reader :value, :errors, :args
+
+    def initialize(value, errors = Dry::Errors.new, **args)
+      @value  = value
+      @errors = errors
+      @args   = args.symbolize_keys
+    end
+
+
+    def name
+      args[:name]
+    end
+
+
+    def add_error
+      errors.add(key, messages[name.to_s] || 'invalid')
+    end
+
+
+    def clone
+      self.class.new(value, errors.clone, args)
+    end
+
+
+    def and(right)
+      Dry::Rules::And.new(self, errors, args.merge(right: right))
+    end
+    alias :& :and
+
+
+    def then(right)
+      Dry::Rules::Then.new(self, errors, args.merge(right: right))
+    end
+    alias :> :then
+
+
+    def or(right)
+      Dry::Rules::Or.new(self, errors, args.merge(right: right))
+    end
+    alias :| :or
+
+
+    def +(right)
+      Dry::Rules::Collection.new(self, errors, args.merge(right: right))
+    end
+
+
+    def valid?
+      raise NotImplementedError
+    end
+
+
+    private
+
+
+    def messages
+      @messages ||= (args[:messages] || {}).deep_stringify_keys
+    end
+
+
+    def key
+      @key ||= args[:key] || (raise 'Missing required param "key"')
+    end
+
+  end
+end