biovision 0.0.200518.1 → 0.12.211124.0

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

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,137 @@ 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
+        [
+          User, Token, LoginAttempt, UserLanguage, BiovisionComponentUser, Code,
+          Notification
+        ]
+      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
+
+      def self.default_settings
+        {
+          SETTING_OPEN => true,
+          SETTING_EMAIL_AS_LOGIN => false,
+          SETTING_PHONE_AS_LOGIN => false,
+          SETTING_CONFIRM_EMAIL => false,
+          SETTING_REQUIRE_EMAIL => false,
+          SETTING_USE_PHONE => false,
+          SETTING_REQUIRE_PHONE => false,
+          SETTING_CONFIRM_PHONE => false,
+          SETTING_INVITE_ONLY => false,
+          SETTING_USE_INVITES => false,
+          SETTING_INVITE_COUNT => 5,
+          SETTING_BOUNCE_COUNT => 10,
+          SETTING_BOUNCE_TIMEOUT => 3,
+        }
+      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
+
+      def role_tree
+        result = super
+        result['users'] << 'log_in'
+        result
+      end
+
+      def crud_table_names
+        super - %w[user_languages biovision_component_users]
+      end
+
+      def administrative_parts
+        %w[users tokens login_attempts codes notifications]
       end
     end
   end

data/app/lib/biovision/helpers/data_helper.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Biovision
+  module Helpers
+    # Helper for receiving model data in controllers
+    class DataHelper
+      attr_reader :model_class
+
+      # @param [ApplicationRecord] model_class
+      # @param [Hash] filters
+      def initialize(model_class, filters = {})
+        @model_class = model_class
+        @filters = filters
+      end
+
+      # @param [Integer] page
+      def administrative_collection(page = 1)
+        paginates = model_class.respond_to?(:page_for_administration)
+        paginates ? administrative_page(page) : administrative_list
+      end
+
+      # @param [User] user
+      # @param [Integer] page
+      def personal_collection(user, page = 1)
+        paginates = model_class.respond_to?(:page_for_owner)
+        paginates ? personal_page(user, page) : personal_list(user)
+      end
+
+      private
+
+      def administrative_list
+        if model_class.respond_to?(:filtered)
+          model_class.filtered(@filters).list_for_administration
+        else
+          model_class.list_for_administration
+        end
+      end
+
+      # @param [Integer] page
+      def administrative_page(page)
+        reflection = model_class.singleton_method(:page_for_administration)
+        if reflection.parameters.include?(%i[key filters])
+          model_class.page_for_administration(page, filters: @filters)
+        else
+          model_class.page_for_administration(page)
+        end
+      end
+
+      # @param [User] user
+      def personal_list(user)
+        if model_class.respond_to?(:filtered)
+          model_class.filtered(@filters).list_for_owner(user)
+        else
+          model_class.list_for_owner(user)
+        end
+      end
+
+      # @param [User] user
+      # @param [Integer] page
+      def personal_page(user, page)
+        reflection = model_class.singleton_method(:page_for_owner)
+        if reflection.parameters.include?(%i[key filters])
+          model_class.page_for_owner(user, page, filters: @filters)
+        else
+          model_class.page_for_owner(user, page)
+        end
+      end
+    end
+  end
+end

data/app/lib/biovision/helpers/export_helper.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Biovision
+  module Helpers
+    # Helper for exporting model data
+    class ExportHelper
+      EXPORT_DIR = "#{Rails.root}/tmp/export"
+      SPECIAL_FIELDS = %w[id agent_id ip_address_id image attachment].freeze
+
+      # @param [Class] model
+      def export_model(model)
+        puts "Exporting model #{model}..."
+        FileUtils.mkdir_p(EXPORT_DIR) unless Dir.exist?(EXPORT_DIR)
+        file_name = "#{EXPORT_DIR}/#{model.table_name}.yml"
+        File.open(file_name, 'wb') do |file|
+          @file = file
+          model.order(:id).each do |entity|
+            @entity = entity
+            export_entity
+          end
+        end
+      end
+
+      private
+
+      def export_entity
+        print "\r#{@entity.id}  "
+        @file.puts "#{@entity.id}:"
+        export_attributes
+      end
+
+      def export_attributes
+        filtered = @entity.attributes.reject { |a, v| ignored?(a) || v.nil? }
+        filtered.each do |attribute, value|
+          export_attribute(attribute, value)
+        end
+        export_track
+        export_media('image') if @entity.attributes.key?('image')
+        export_media('attachment') if @entity.attributes.key?('attachment')
+      end
+
+      # @param [String] attribute
+      # @param value
+      def export_attribute(attribute, value)
+        @file.print "  #{attribute}: "
+        if value.is_a?(Hash)
+          if value.blank?
+            @file.puts '{}'
+          else
+            @file.puts value.to_yaml.gsub(/\A---|\n\z/, '').gsub("\n", "\n    ")
+          end
+        else
+          @file.puts value.inspect
+        end
+      end
+
+      def export_track
+        return unless @entity.is_a?(HasTrack)
+
+        unless @entity.ip_address.nil?
+          @file.puts "  ip_address: #{@entity.ip_address.ip.to_s.inspect}"
+        end
+
+        return if @entity.agent.blank?
+
+        @file.puts "  agent: #{@entity.agent.name.inspect}"
+      end
+
+      def media_dir
+        "#{EXPORT_DIR}/#{@entity.class.table_name}"
+      end
+
+      def export_media(type)
+        media = @entity.send(type.to_sym)
+
+        return if media.blank?
+
+        media_name = File.basename(media.path)
+        dir_name = "#{media_dir}/#{@entity.id}"
+        FileUtils.mkdir_p(dir_name) unless Dir.exist?(dir_name)
+        FileUtils.copy(media.path, "#{dir_name}/#{media_name}")
+        @file.puts "  #{type}: #{media_name.inspect}"
+      end
+
+      # @param [String] attribute
+      def ignored?(attribute)
+        return true if SPECIAL_FIELDS.include?(attribute)
+
+        %w[count cache].each do |ending|
+          return true if attribute.end_with?("_#{ending}")
+        end
+
+        false
+      end
+    end
+  end
+end