biovision 0.0.200518.1 → 0.1.210414.0

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

@@ -4,6 +4,9 @@ module Biovision
   module Components
     # Component for tracking UA and IP
     class TrackComponent < BaseComponent
+      def self.dependent_models
+        [IpAddress, Agent, Browser]
+      end
     end
   end
 end

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

@@ -11,18 +11,20 @@ module Biovision
           let_user_in?
         end
 
-        protected
+        private
 
         def let_user_in?
-          return false if user.nil? || user.banned?
-
-          too_many_attempts? ? (log_attempt && false) : try_password
+          if user.nil? || user.banned?
+            register_failure && false
+          else
+            too_many_attempts? ? (log_attempt && false) : try_password
+          end
         end
 
         def too_many_attempts?
-          timeout = settings['bounce_timeout'].to_i.abs.minutes.ago
-          limit = settings['bounce_limit'].to_i
-          LoginAttempt.owned_by(user).since(timeout).count > limit
+          timeout = settings[self.class::SETTING_BOUNCE_TIMEOUT].to_i.abs
+          limit = settings[self.class::SETTING_BOUNCE_COUNT].to_i
+          LoginAttempt.owned_by(user).since(timeout.minutes.ago).count > limit
         end
 
         def log_attempt
@@ -35,12 +37,18 @@ module Biovision
         end
 
         def count_attempt
+          register_failure
           log_attempt
           return unless too_many_attempts?
 
           notifier = Biovision::Notifiers::UsersNotifier.new(user)
           notifier.new_login_attempt(@track)
         end
+
+        def register_failure
+          metric = Biovision::Components::UsersComponent::METRIC_AUTH_FAILURE
+          register_metric(metric)
+        end
       end
     end
   end

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Biovision
+  module Components
+    module Users
+      # Handling user-related codes
+      module Codes
+        # @param [Code] code
+        # @param [String] code_type
+        def valid_code?(code, code_type)
+          return false if code.nil? || code.biovision_component != @component
+
+          code.type?(code_type) && code.active?
+        end
+
+        # @param [Code] code
+        def valid_email_confirmation?(code)
+          return false if code.nil? || code.biovision_component != @component
+          return false unless code.active?
+
+          code_type = self.class::CODE_EMAIL_CONFIRMATION
+          code.type?(code_type) && code.data['email'] == user.email
+        end
+
+        # @param [Code] code
+        def valid_invitation?(code)
+          valid_code?(code, self.class::CODE_INVITATION)
+        end
+
+        # @param [Code] code
+        def valid_recovery?(code)
+          valid_code?(code, self.class::CODE_RECOVERY)
+        end
+
+        # @param [User] user
+        def create_email_confirmation(user)
+          code_type = self.class::CODE_EMAIL_CONFIRMATION
+          code = @component.codes.new(user: user, code_type: code_type)
+          code.data['email'] = user.email
+          code.save
+          code
+        end
+
+        # @param [User] user
+        def create_phone_confirmation(user)
+          code_type = self.class::CODE_PHONE_CONFIRMATION
+          code = @component.codes.new(user: user, code_type: code_type)
+          code.data['phone'] = user.phone
+          code.save
+          code
+        end
+
+        # @param [User] user
+        def send_email_confirmation(user)
+          code_type = self.class::CODE_EMAIL_CONFIRMATION
+          codes = @component.codes.active.owned_by(user).with_type(code_type)
+          code = codes.find_by("data->>'email' = ?", user.email)
+          code = create_email_confirmation(user) if code.nil?
+
+          CodeSender.email(code.id).deliver_later
+        end
+
+        # @param [User] user
+        def send_phone_confirmation(user)
+          code_type = self.class::CODE_PHONE_CONFIRMATION
+          codes = @component.codes.active.owned_by(user).with_type(code_type)
+          code = codes.find_by("data->>'phone' = ?", user.email)
+          code = create_phone_confirmation(user) if code.nil?
+
+          SendPhoneConfirmationJob.perform_later(code.id)
+        end
+
+        # @param [Code] code
+        def activate_email_confirmation(code)
+          return unless valid_email_confirmation?(code)
+
+          code.user.update(email_confirmed: true)
+        end
+
+        # @param [Code] code
+        # @param [User] user
+        def activate_invitation(code, user)
+          return if code.nil? || !code.active? || user.nil?
+
+          code.decrement!(:quantity)
+          user.update(inviter_id: code.user_id)
+
+          register_metric(self.class::METRIC_USED_INVITATION)
+        end
+
+        # @param [User] user
+        def create_invitations_for_user(user)
+          quantity = settings[self.class::SETTING_INVITE_COUNT].to_i
+
+          return if quantity < 1
+
+          code = @component.codes.new(user: user, quantity: quantity)
+          code.code_type = self.class::CODE_INVITATION
+          code.save
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Biovision
+  module Components
+    module Users
+      # Helper methods for checking user flags
+      module FlagHelpers
+        def needs_email_confirmation?
+          return false if user&.email_confirmed?
+
+          confirm_email? && !user.email.blank?
+        end
+
+        def needs_phone_confirmation?
+          return false if user&.phone_confirmed?
+
+          confirm_phone? && !user.phone.blank?
+        end
+
+        def registration_open?
+          key = Biovision::Components::UsersComponent::SETTING_OPEN
+          settings[key]
+        end
+
+        def email_as_login?
+          key = Biovision::Components::UsersComponent::SETTING_EMAIL_AS_LOGIN
+          settings[key]
+        end
+
+        def phone_as_login?
+          key = Biovision::Components::UsersComponent::SETTING_PHONE_AS_LOGIN
+          settings[key]
+        end
+
+        def require_email?
+          key = Biovision::Components::UsersComponent::SETTING_REQUIRE_EMAIL
+          settings[key] || email_as_login?
+        end
+
+        def require_phone?
+          key = Biovision::Components::UsersComponent::SETTING_REQUIRE_PHONE
+          settings[key] || phone_as_login?
+        end
+
+        def confirm_email?
+          key = Biovision::Components::UsersComponent::SETTING_CONFIRM_EMAIL
+          settings[key]
+        end
+
+        def confirm_phone?
+          key = Biovision::Components::UsersComponent::SETTING_CONFIRM_PHONE
+          settings[key]
+        end
+
+        def invite_only?
+          key = Biovision::Components::UsersComponent::SETTING_INVITE_ONLY
+          settings[key]
+        end
+
+        def use_invites?
+          key = Biovision::Components::UsersComponent::SETTING_USE_INVITES
+          settings[key] || invite_only?
+        end
+
+        def use_phone?
+          key = Biovision::Components::UsersComponent::SETTING_USE_PHONE
+          settings[key]
+        end
+      end
+    end
+  end
+end

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

@@ -5,8 +5,118 @@ module Biovision
     module Users
       # Handling user profiles
       class ProfileHandler
+        GENDERS = { 0 => 'female', 1 => 'male', 2 => 'other' }.freeze
+
         attr_accessor :user
+
+        # @param [Biovision::Components::UsersComponent] component
+        def initialize(component)
+          @component = component
+        end
+
+        # List of attributes that can be used in user profile
+        #
+        # Change this method in decorators for other values
+        def self.allowed_parameters
+          %w[gender name patronymic surname about]
+        end
+
+        # List of parameters to be used in controllers for create/update
+        def self.permitted_for_request
+          allowed_parameters.map do |key|
+            key.respond_to?(:to_h) ? [[key.shift, key]].to_h : key
+          end
+        end
+
+        # Normalize profile parameters for storage
+        #
+        # Makes consistent format of profile hash.
+        #
+        # @param [Hash] input
+        def self.clean_parameters(input)
+          return {} unless input.respond_to?(:key?)
+
+          output = normalized_parameters(input)
+          (allowed_parameters - output.keys).each do |parameter|
+            if parameter.respond_to?(:shift)
+              key = parameter.shift
+              output[key] = array_value(input[key].to_h, parameter)
+            else
+              output[parameter] = scalar_value(input, parameter)
+            end
+          end
+          output
+        end
+
+        # @param [Hash] input
+        # @param [String] key
+        def self.scalar_value(input, key)
+          input.key?(key) ? input[key].to_s : nil
+        end
+
+        # @param [Hash] input
+        # @param [Array] keys
+        def self.array_value(input, keys)
+          keys.each.map { |key| [key, scalar_value(input, key)] }.to_h
+        end
+
+        # @param [Integer|nil] gender_id
+        def self.gender(gender_id)
+          prefix = 'activerecord.attributes.user_profile.genders'
+          gender_key = gender_id.blank? ? '' : gender_id.to_i
+          postfix = GENDERS[gender_key] || 'not_set'
+          I18n.t("#{prefix}.#{postfix}")
+        end
+
+        def self.genders_for_select
+          default_key = 'activerecord.attributes.user_profile.genders.not_set'
+          genders = [[I18n.t(default_key), '']]
+          genders + GENDERS.keys.map { |k| [gender(k), k] }
+        end
+
+        # Format parameters that have more restrictions than just "string" type
+        #
+        # Change this method in decorator to add other fields with type
+        # enumerable, integer, etc.
+        #
+        # @param [Hash] input
+        def self.normalized_parameters(input)
+          { gender: clean_gender(input['gender']) }
+        end
+
+        # Restrict gender to only available values
+        #
+        # Defined gender is stored as integer.
+        #
+        # @param [Integer] input
+        def self.clean_gender(input)
+          gender_key = input.blank? ? nil : input.to_i
+          GENDERS.key?(gender_key) ? gender_key : nil
+        end
+
+        # @param [Hash] profile_data
+        def profile=(profile_data)
+          user.profile = self.class.clean_parameters(profile_data).to_h
+        end
+
+        # @param [Hash] user_data
+        # @param [Hash] profile_data
+        def create(user_data, profile_data)
+          self.user = User.new(user_data)
+          self.profile = profile_data
+          Biovision::Components::UsersComponent.created_user(user) if user.save
+          user
+        end
+
+        # @param [Hash] user_data
+        # @param [Hash] profile_data
+        def update(user_data, profile_data)
+          return if user.nil?
+
+          self.profile = profile_data
+          user.update(user_data)
+        end
       end
     end
   end
-end
+end

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

@@ -5,48 +5,44 @@ module Biovision
     module Users
       # Handling user registration
       class RegistrationHandler
+        attr_reader :user
+
         # @param [Biovision::Components::UsersComponent] component
         def initialize(component)
           @component = component
         end
 
+        # @param [Hash] parameters
+        # @param [Code|nil] Code
         def handle(parameters, code = nil)
           @user = User.new(parameters)
-          @user.screen_name = @user.email if email_as_login?
           @user.super_user = 1 if User.count < 1
-          @manager = CodeHandler.new(@component, code)
+          @user.code = code
+          @code = code
 
-          use_invites? ? use_code : persist_user
-          persist_user if @component.valid?(@user)
+          @component.use_invites? ? use_code : persist_user
 
           @user
         end
 
-        def open?
-          @component.settings['registration_open']
-        end
-
-        def invite_only?
-          @component.settings['invite_only']
-        end
-
-        def use_invites?
-          @component.settings['use_invites'] || invite_only?
-        end
-
-        def confirm_email?
-          @component.settings['confirm_email']
+        # @param [Hash] parameters
+        # @param [Code|nil] Code
+        def check(parameters, code = nil)
+          @user = User.new(parameters)
+          @user.code = code
+          @user.valid?
+          add_code_error unless acceptable_code?
         end
 
-        def email_as_login?
-          @component.settings['email_as_login']
+        def open?
+          @component.registration_open?
         end
 
-        def require_email?
-          @component.settings['require_email'] || email_as_login?
+        def valid?
+          @user.errors.blank?
         end
 
-        protected
+        private
 
         def persist_user
           return unless @user.save
@@ -54,44 +50,36 @@ module Biovision
           metric = Biovision::Components::UsersComponent::METRIC_NEW_USER
           @component.register_metric(metric)
 
-          # handle_codes
+          Biovision::Components::UsersComponent.created_user(@user)
+          handle_codes
         end
 
-        # Check invitation code and persist user if it's valid
-        def use_code
-          if @manager.valid? || (@manager.code.nil? && !invite_only?)
-            persist_user
-          else
-            error = I18n.t('biovision.components.users.messages.invalid_code')
-
-            # Add "invalid code" error to other model errors, if any
-            @user.valid?
-            @user.errors.add(:code, error)
-          end
+        def valid_invitation?
+          @component.valid_invitation?(@code)
         end
 
-        def handle_codes
-          if confirm_email?
-            code = CodeManager::Confirmation.code_for_user(@user)
-            CodeSender.email(code.id).deliver_later
-          end
+        def acceptable_code?
+          valid_invitation? || (@code.nil? && !@component.invite_only?)
+        end
 
-          return unless use_invites?
+        # Check invitation code and persist user if it's valid
+        def use_code
+          acceptable_code? ? persist_user : add_code_error
+        end
 
-          @manager.activate(@user) if @manager.valid?
-          create_invitations(settings['invite_count'].to_i)
+        def add_code_error
+          @user.valid?
+          @user.errors.add(:code, :invalid)
         end
 
-        # @param [Integer] quantity
-        def create_invitations(quantity = 1)
-          return unless quantity.positive?
+        def handle_codes
+          @component.send_email_confirmation(@user) if @component.confirm_email?
+          @component.send_phone_confirmation(@user) if @component.confirm_phone?
+
+          return unless @component.use_invites?
 
-          parameters = {
-            code_type: CodeManager::Invitation.code_type,
-            user: @user,
-            quantity: quantity
-          }
-          Code.create(parameters)
+          @component.activate_invitation(@code, @user) if valid_invitation?
+          @component.create_invitations_for_user(@user)
         end
       end
     end