biovision 0.0.200518.1 → 0.1.210414.0

data/app/lib/biovision/components/users/validation.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Biovision
+  module Components
+    module Users
+      # Validating instances of User
+      module Validation
+        def validate
+          return if user.nil?
+
+          prepare_screen_name if user.new_record?
+
+          validate_email
+          validate_phone
+          validate_screen_name unless user.data[User::FLAG_SKIP_SCREEN_NAME]
+        end
+
+        private
+
+        def prepare_screen_name
+          use_uuid = false
+          use_uuid = email_as_login! if email_as_login?
+          use_uuid = phone_as_login! if phone_as_login?
+
+          user.screen_name = user.uuid if use_uuid
+        end
+
+        def email_as_login!
+          key = Biovision::Components::UsersComponent::SETTING_EMAIL_AS_LOGIN
+          user.data[key] = true
+        end
+
+        def phone_as_login!
+          key = Biovision::Components::UsersComponent::SETTING_PHONE_AS_LOGIN
+          user.data[key] = true
+        end
+
+        def validate_phone
+          user.errors.add(:phone, :blank) if require_phone? && user.phone.blank?
+
+          normalize_phone_format unless user.phone.blank?
+          validate_phone_format unless user.phone.blank?
+        end
+
+        def normalize_phone_format
+          has_plus = user.phone.strip[0] == '+'
+          normalized_phone = user.phone.gsub(/\D/, '')
+          normalized_phone[0] = '7' if !has_plus && normalized_phone[0] == '8'
+
+          user.phone = "+#{normalized_phone}" unless normalized_phone.blank?
+        end
+
+        # @see https://ru.wikipedia.org/wiki/MSISDN
+        def validate_phone_format
+          return if user.phone =~ /\+\d{11,15}/
+
+          user.errors.add(:phone, :invalid)
+        end
+
+        def validate_email
+          user.errors.add(:email, :blank) if require_email? && user.email.blank?
+
+          validate_email_format unless user.email.blank?
+        end
+
+        def validate_email_format
+          too_long = user.email.to_s.length > User::EMAIL_LIMIT
+          pattern_matches = (user.email.to_s =~ User::EMAIL_PATTERN)
+
+          user.errors.add(:email, :invalid) if too_long || !pattern_matches
+        end
+
+        def validate_screen_name
+          pattern = User::SLUG_PATTERN
+
+          return if user.screen_name =~ pattern
+
+          user.errors.add(:screen_name, :invalid)
+        end
+      end
+    end
+  end
+end

data/app/lib/biovision/components/users_component.rb

@@ -5,42 +5,105 @@ module Biovision
     # Handling users
     class UsersComponent < BaseComponent
       include Users::Authentication
+      include Users::Validation
+      include Users::Codes
+      include Users::FlagHelpers
 
+      CODE_EMAIL_CONFIRMATION = 'email_confirmation'
+      CODE_INVITATION = 'invitation'
+      CODE_PHONE_CONFIRMATION = 'phone_confirmation'
+      CODE_RECOVERY = 'recovery'
+      METRIC_AUTH_FAILURE = 'users.auth.failure.hit'
       METRIC_NEW_USER = 'users.new_user.hit'
+      METRIC_REGISTRATION_BOT = 'users.registration.bot.hit'
+      METRIC_USED_INVITATION = 'users.used_invitation.hit'
+      SETTING_BOUNCE_COUNT = 'bounce_count'
+      SETTING_BOUNCE_TIMEOUT = 'bounce_timeout'
+      SETTING_CONFIRM_EMAIL = 'confirm_email'
+      SETTING_CONFIRM_PHONE = 'confirm_phone'
+      SETTING_EMAIL_AS_LOGIN = 'email_as_login'
+      SETTING_INVITE_COUNT = 'invite_count'
+      SETTING_INVITE_ONLY = 'invite_only'
+      SETTING_OPEN = 'registration_open'
+      SETTING_PHONE_AS_LOGIN = 'phone_as_login'
+      SETTING_REQUIRE_EMAIL = 'require_email'
+      SETTING_REQUIRE_PHONE = 'require_phone'
+      SETTING_USE_INVITES = 'use_invites'
+      SETTING_USE_PHONE = 'use_phone'
+
+      def self.dependent_models
+        [
+          Notification, Code, BiovisionComponentUser, UserLanguage,
+          LoginAttempt, Token, User
+        ]
+      end
 
       def self.settings_flags
-        %w[
-          registration_open email_as_login confirm_email require_email
-          invite_only use_invites
+        [
+          SETTING_OPEN, SETTING_EMAIL_AS_LOGIN, SETTING_CONFIRM_EMAIL,
+          SETTING_CONFIRM_PHONE, SETTING_PHONE_AS_LOGIN, SETTING_REQUIRE_EMAIL,
+          SETTING_REQUIRE_PHONE, SETTING_INVITE_ONLY, SETTING_USE_INVITES,
+          SETTING_USE_PHONE
         ]
       end
 
       def self.settings_numbers
-        %w[invite_count bounce_count bounce_timeout]
+        [SETTING_INVITE_COUNT, SETTING_BOUNCE_COUNT, SETTING_BOUNCE_TIMEOUT]
+      end
+
+      # @param [User] user
+      def self.created_user(user)
+        BiovisionComponent.active.pluck(:slug).each do |slug|
+          handler = Biovision::Components::BaseComponent.handler_class(slug)
+          handler.handle_new_user(user) if handler.respond_to?(:handle_new_user)
+        end
+      end
+
+      # @param [User] user
+      def self.handle_new_user(user)
+        handler = new(BiovisionComponent[slug], user)
+
+        return unless handler.use_invites?
+
+        parameters = {
+          user: user,
+          quantity: handler.settings[SETTING_INVITE_COUNT].to_i
+        }
+
+        code = handler.component.codes.new(parameters)
+        code.code_type = CODE_INVITATION
+        code.save
       end
 
       # @param [Hash] parameters
-      # @param [Code] code
-      def register_user(parameters, code)
+      # @param [Code|nil] code
+      def register_user(parameters, code = nil)
         handler = Users::RegistrationHandler.new(self)
         handler.handle(parameters, code)
       end
 
-      # @param [User] entity
-      def valid?(entity)
-        entity.valid? && valid_slug?(entity)
+      # @param [Hash] user_data
+      # @param [Hash] profile_data
+      def create_user(user_data, profile_data)
+        handler = Users::ProfileHandler.new(self)
+        handler.create(user_data, profile_data)
+        handler.user
       end
 
-      def valid_slug?(entity)
-        if settings['email_as_login']
-          entity.slug =~ /\A[-_a-z0-9.]+@[-a-z0-9.]+\.[a-z]{2,24}\z/
-        elsif entity.slug =~ /\A[_a-z0-9]{1,30}\z/
-          true
-        else
-          key = 'activerecord.errors.models.user.attributes.slug.invalid'
-          entity.errors[:slug] = t(key)
-          false
-        end
+      # @param [User] user
+      # @param [Hash] user_data
+      # @param [Hash] profile_data
+      def update_user(user, user_data, profile_data)
+        handler = Users::ProfileHandler.new(self)
+        handler.user = user
+        handler.update(user_data, profile_data)
+      end
+
+      # @param [String|Symbol] attribute_name
+      def attribute(attribute_name)
+        return nil if user.nil?
+
+        user.attributes[attribute_name.to_s]
       end
     end
   end

data/app/lib/biovision/notifiers/base_notifier.rb

@@ -20,7 +20,7 @@ module Biovision
       end
 
       def self.slug
-        to_s.demodulize.underscore.gsub('_notifier', '')
+        to_s.demodulize.to_s.underscore.gsub('_notifier', '')
       end
 
       # @param [String] slug
@@ -56,7 +56,7 @@ module Biovision
       def check_and_notify(id, type)
         return if check_chain(id, type).exists?
 
-        notify({id: id, type: type})
+        notify({ id: id, type: type })
       end
 
       # @param [Integer] id

data/app/lib/biovision/notifiers/contact_notifier.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Biovision
+  module Notifiers
+    # Notification mapper for contact component
+    class ContactNotifier < BaseNotifier
+      TYPE_FEEDBACK_MESSAGE = 'feedback_message'
+
+      # @param [Integer] message_id
+      def new_feedback_message(message_id)
+        check_and_notify(message_id, TYPE_FEEDBACK_MESSAGE)
+      end
+    end
+  end
+end

data/app/lib/canonizer.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# Helper for canonizing and transliterating strings
+class Canonizer
+  # Keys are not latin letters
+  TRANSLITERATION_MAP = {
+    'а' => 'a', 'б' => 'b', 'в' => 'v', 'г' => 'g', 'д' => 'd', 'е' => 'e',
+    'ё' => 'yo', 'ж' => 'zh', 'з' => 'z', 'и' => 'i', 'й' => 'j', 'к' => 'k',
+    'л' => 'l', 'м' => 'm', 'н' => 'n', 'о' => 'o', 'п' => 'p', 'р' => 'r',
+    'с' => 's', 'т' => 't', 'у' => 'u', 'ф' => 'f', 'х' => 'kh', 'ц' => 'c',
+    'ч' => 'ch', 'ш' => 'sh', 'щ' => 'shh', 'ъ' => '', 'ы' => 'y', 'ь' => '',
+    'э' => 'e', 'ю' => 'yu', 'я' => 'ya',
+    'å' => 'ao', 'ä' => 'ae', 'ö' => 'oe', 'é' => 'e'
+  }.freeze
+
+  # @param [String] text
+  def self.transliterate(text)
+    pattern = Regexp.new "[#{TRANSLITERATION_MAP.keys.join}]"
+    result = text.to_s.downcase.gsub(pattern, TRANSLITERATION_MAP)
+
+    a = /[^-a-z0-9_]/ # non-allowed characters will be replaced with dash
+    b = /\A[-_]*([-a-z0-9_]*[a-z0-9]+)[-_]*\z/ # chop leading and trailing dash
+    result.gsub(a, '-').gsub(b, '\1').gsub(/--+/, '-').gsub(/-+\z/, '')
+  end
+
+  # @param [String] input
+  def self.canonize(input)
+    lowered = input.to_s.downcase.strip
+    canonized = lowered.gsub(/[^a-zа-я0-9ё]/, '')
+    canonized.empty? ? lowered : canonized
+  end
+
+  # @param [String] input
+  def self.urlize(input)
+    lowered = input.to_s.downcase.squish
+    lowered.gsub(/[^a-zа-я0-9ё]/, '-').gsub(/-+\z/, '')
+  end
+end

data/app/lib/carrier_wave/image_optim.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module CarrierWave
+  # Optimizing uploaded images
+  module ImageOptim
+    DEFAULT_OPTIONS = {
+      skip_missing_workers: true,
+      advpng: false,
+      gifsicle: false,
+      jhead: false,
+      jpegrecompress: false,
+      jpegtran: false,
+      pngcrush: false,
+      pngout: false,
+      pngquant: false,
+      svgo: false,
+      jpegoptim: { max_quality: 75 },
+      optipng: { level: 4 }
+    }.freeze
+
+    def optimize(options = {})
+      image_optim = ::ImageOptim.new(optimizer_options(options))
+      image_optim.optimize_image!(current_path)
+    end
+
+    private
+
+    def optimizer_options(options)
+      DEFAULT_OPTIONS.deep_merge(options)
+    end
+  end
+end

data/app/mailers/code_sender.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Mailer for sending codes to users
+class CodeSender < ApplicationMailer
+  # Email confirmation code
+  #
+  # @param [Integer] code_id
+  def email(code_id)
+    @code = Code.find_by(id: code_id)
+    return if @code.nil?
+
+    user = @code.user
+
+    return if user.email.blank? || user.email_confirmed?
+
+    mail to: user.email
+  end
+
+  # Password reset code
+  #
+  # @param [Integer] code_id
+  def password(code_id)
+    @code = Code.find_by(id: code_id)
+
+    return if @code.nil? || @code.user.email.blank?
+
+    mail to: @code.user.email
+  end
+end

data/app/models/agent.rb

@@ -32,4 +32,8 @@ class Agent < ApplicationRecord
 
     find_or_create_by(name: name[0..254])
   end
+
+  def bot?
+    name.downcase.include?('bot')
+  end
 end

data/app/models/biovision_component.rb

@@ -14,16 +14,21 @@ class BiovisionComponent < ApplicationRecord
   include FlatPriority
   include RequiredUniqueSlug
 
+  SLUG_LIMIT = 250
+  SLUG_PATTERN_HTML = '^[a-zA-Z][-a-zA-Z0-9_]+[a-zA-Z0-9]$'
+
   has_many :biovision_component_users, dependent: :delete_all
   has_many :simple_images, dependent: :destroy
+  has_many :codes, dependent: :delete_all
 
+  scope :active, -> { where(active: true) }
   scope :list_for_administration, -> { ordered_by_priority }
 
   # Find component by slug
   #
-  # @param [String] slug
+  # @param [String|Class] slug
   def self.[](slug)
-    find_by(slug: slug)
+    find_by(slug: slug.respond_to?(:slug) ? slug.slug : slug)
   end
 
   # @param [String] slug
@@ -42,4 +47,19 @@ class BiovisionComponent < ApplicationRecord
   def privileges
     biovision_component_users.recent
   end
+
+  # @param [User] user
+  # @param [String] type
+  # @param [Integer] quantity
+  def find_or_create_code(user, type, quantity = 1)
+    code = codes.owned_by(user).with_type(type).active.first
+
+    if code.nil?
+      code = codes.new(user: user, quantity: quantity)
+      code.code_type = type
+      code.save
+    end
+
+    code
+  end
 end

data/app/models/browser.rb

@@ -28,7 +28,7 @@ class Browser < ApplicationRecord
 
   scope :list_for_administration, -> { order('name asc, version asc') }
 
-  def self.entity_parameters
+  def self.entity_parameters(*)
     %i[banned mobile name version]
   end
 end

data/app/models/code.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Code for users
-# 
+#
 # Attributes:
 #   agent_id [Agent], optional
 #   biovision_component_id [BiovisionComponent]
@@ -20,18 +20,19 @@ class Code < ApplicationRecord
   QUANTITY_RANGE = (0..32_767).freeze
 
   belongs_to :biovision_component
-  belongs_to :user
+  belongs_to :user, optional: true
 
   after_initialize :generate_body
 
   before_validation :sanitize_quantity
 
   validates_presence_of :body
-  validates_uniqueness_of :body
+  validates_uniqueness_of :body, unless: :phone?
   validates_length_of :body, maximum: BODY_LIMIT
 
   scope :recent, -> { order('id desc') }
   scope :active, -> { where('quantity > 0') }
+  scope :with_type, ->(v) { where("data->>'type' = ?", v) unless v.blank? }
   scope :list_for_administration, -> { recent }
 
   # @param [Integer] page
@@ -39,12 +40,12 @@ class Code < ApplicationRecord
     list_for_administration.page(page)
   end
 
-  def self.entity_parameters
-    %i[body payload quantity]
+  def self.entity_parameters(*)
+    %i[body quantity]
   end
 
-  def self.creation_parameters
-    entity_parameters + %i[user_id code_type_id]
+  def self.creation_parameters(*)
+    entity_parameters + %i[user_id biovision_component_id]
   end
 
   def activated?
@@ -55,13 +56,35 @@ class Code < ApplicationRecord
     quantity.positive?
   end
 
+  # @param [String] type_name
+  def type?(type_name)
+    code_type == type_name.to_s
+  end
+
+  def code_type
+    data['type'].to_s
+  end
+
+  # @param [String] new_type
+  def code_type=(new_type)
+    data['type'] = new_type.to_s
+  end
+
+  def phone?
+    type?(Biovision::Components::UsersComponent::CODE_PHONE_CONFIRMATION)
+  end
+
   private
 
   def generate_body
     return unless body.nil?
 
-    number = SecureRandom.random_number(0xffff_ffff_ffff_ffff)
-    self.body = number.to_s(36).scan(/.{4}/).join('-').upcase
+    if phone?
+      number = SecureRandom.random_number(0xffff_ffff_ffff_ffff)
+      self.body = number.to_s(36).scan(/.{4}/).join('-').upcase
+    else
+      self.body = SecureRandom.random_number(1_000_000).to_s.rjust(6, '0')
+    end
   end
 
   def sanitize_quantity