biovision-base 0.22.180920.0 → 0.34.190331.1

data/app/models/privilege_group.rb

@@ -1,4 +1,5 @@
 class PrivilegeGroup < ApplicationRecord
+  include Checkable
   include RequiredUniqueSlug
   include RequiredUniqueName
 
@@ -13,6 +14,8 @@ class PrivilegeGroup < ApplicationRecord
   validates_length_of :slug, maximum: SLUG_LIMIT
   validates_length_of :description, maximum: DESCRIPTION_LIMIT
 
+  scope :list_for_administration, -> { ordered_by_name }
+
   def self.page_for_administration
     ordered_by_name
   end
@@ -23,11 +26,12 @@ class PrivilegeGroup < ApplicationRecord
   def self.ids(slug)
     instance = find_by(slug: slug.to_s)
     return [] if instance.nil?
+
     instance.privileges.map(&:branch_ids).flatten.uniq
   end
 
   def self.entity_parameters
-    %i(name slug description)
+    %i[name slug description]
   end
 
   # @param [String] slug
@@ -44,6 +48,7 @@ class PrivilegeGroup < ApplicationRecord
   def add_privilege(privilege)
     criteria = { privilege_group: self, privilege: privilege }
     return if PrivilegeGroupPrivilege.exists?(criteria)
+
     PrivilegeGroupPrivilege.create(criteria)
   end
 

data/app/models/simple_block.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# Model for simple editable block
+#
+# Attributes:
+#   background_image [Boolean]
+#   body [Text], optional
+#   created_at [DateTime]
+#   image [SimpleImageUploader], optional
+#   image_alt_text [String], optional
+#   name [String]
+#   slug [String]
+#   updated_at [DateTime]
+#   visible [Boolean]
+class SimpleBlock < ApplicationRecord
+  include Checkable
+  include RequiredUniqueSlug
+  include RequiredUniqueName
+  include Toggleable
+
+  BODY_LIMIT = 65_535
+  META_LIMIT = 255
+  NAME_LIMIT = 100
+  SLUG_LIMIT = 30
+  SLUG_PATTERN = /\A[a-z][-_a-z0-9]*[a-z0-9]\z/.freeze
+  SLUG_PATTERN_HTML = '^[a-zA-Z][-_a-zA-Z0-9]*[a-zA-Z0-9]$'
+
+  toggleable :visible, :background_image
+
+  mount_uploader :image, SimpleImageUploader
+
+  before_validation { self.slug = slug.to_s.downcase }
+
+  validates_length_of :body, maximum: BODY_LIMIT
+  validates_length_of :image_alt_text, maximum: META_LIMIT
+  validates_length_of :name, maximum: NAME_LIMIT
+  validates_length_of :slug, maximum: SLUG_LIMIT
+  validates_format_of :slug, with: SLUG_PATTERN
+
+  scope :visible, -> { where(visible: true) }
+  scope :list_for_administration, -> { ordered_by_slug }
+
+  def self.entity_parameters
+    %i[body image image_alt_text name slug] + toggleable_attributes
+  end
+
+  # @param [String] slug
+  def self.partial(slug)
+    for_visitors(slug) || 'simple_blocks/empty'
+  end
+
+  # @param [String] slug
+  def self.for_visitors(slug)
+    visible.find_by(slug: slug)
+  end
+
+  # Get body of visible block with given slug or empty string
+  #
+  # Can be used in views for quick output
+  #
+  # @param [String] slug
+  # @return [String]
+  def self.[](slug)
+    SimpleBlock.visible.find_by(slug: slug)&.body.to_s
+  end
+end

data/app/models/user.rb

@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
+# User
 class User < ApplicationRecord
+  include Checkable
   include Toggleable
 
   METRIC_REGISTRATION            = 'users.registration.hit'
@@ -6,19 +10,18 @@ class User < ApplicationRecord
   METRIC_AUTHENTICATION_FAILURE  = 'users.authentication.failure.hit'
   METRIC_AUTHENTICATION_EXTERNAL = 'users.authentication.external.hit'
 
-  PER_PAGE = 20
-
-  SLUG_LIMIT   = 250
   EMAIL_LIMIT  = 250
   NOTICE_LIMIT = 255
   PHONE_LIMIT  = 50
+  SLUG_LIMIT   = 250
+
+  EMAIL_PATTERN = /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z0-9][-a-z0-9]+)\z/i.freeze
 
-  EMAIL_PATTERN            = /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z0-9][-a-z0-9]+)\z/i
   SCREEN_NAME_LIMIT        = 30
-  SCREEN_NAME_PATTERN      = /\A[a-z0-9_]{1,30}\z/i
-  SCREEN_NAME_PATTERN_HTML = '^[a-zA-Z0-9_]{1,30}$'
+  SCREEN_NAME_PATTERN      = /\A[-a-z0-9_]{1,30}\z/i.freeze
+  SCREEN_NAME_PATTERN_HTML = '^[-a-zA-Z0-9_]{1,30}$'
 
-  toggleable %i(allow_login bot email_confirmed phone_confirmed allow_mail)
+  toggleable %i[allow_login email_confirmed phone_confirmed allow_mail]
 
   has_secure_password
 
@@ -36,7 +39,9 @@ class User < ApplicationRecord
   has_many :login_attempts, dependent: :delete_all
   has_many :user_languages, dependent: :delete_all
 
-  before_save :normalize_slug
+  after_initialize { self.uuid = SecureRandom.uuid if uuid.nil? }
+
+  before_save { self.slug = (native_slug? ? screen_name : slug).downcase }
   before_save :prepare_search_string
   before_save { self.referral_link = SecureRandom.alphanumeric(12) if referral_link.blank? }
 
@@ -55,40 +60,42 @@ class User < ApplicationRecord
   validates_length_of :notice, maximum: NOTICE_LIMIT
 
   scope :with_privilege, ->(privilege) { joins(:user_privileges).where(user_privileges: { privilege_id: privilege.branch_ids }) }
-  scope :with_privilege_ids, -> (privilege_ids) { joins(:user_privileges).where(user_privileges: { privilege_id: privilege_ids }) }
+  scope :with_privilege_ids, ->(privilege_ids) { joins(:user_privileges).where(user_privileges: { privilege_id: privilege_ids }) }
   scope :ordered_by_screen_name, -> { order('screen_name asc') }
-  scope :bots, ->(flag) { where(bot: flag.to_i > 0) unless flag.blank? }
-  scope :email_like, ->(val) { where('email ilike ?', "%#{val}%") unless val.blank? }
-  scope :with_email, ->(email) { where('lower(email) = lower(?)', email) }
-  scope :screen_name_like, ->(val) { where('screen_name ilike ?', "%#{val}%") unless val.blank? }
+  scope :bots, ->(flag) { where(bot: flag.to_i.positive?) unless flag.blank? }
+  scope :email_like, ->(v) { where('email ilike ?', "%#{v}%") unless v.blank? }
+  scope :with_email, ->(v) { where('lower(email) = lower(?)', v) }
+  scope :screen_name_like, ->(v) { where('screen_name ilike ?', "%#{v}%") unless v.blank? }
   scope :search, ->(q) { where('search_string like ?', "%#{q.downcase}%") unless q.blank? }
   scope :filtered, ->(f) { email_like(f[:email]).screen_name_like(f[:screen_name]) }
   scope :list_for_administration, -> { order('id desc') }
+  scope :created_after, ->(v) { where('created_at >= ?', v) unless v.blank? }
+  scope :created_before, ->(v) { where('created_at <= ?', v) unless v.blank? }
 
   # @param [Integer] page
   # @param [String] search_query
   def self.page_for_administration(page, search_query = '')
-    list_for_administration.search(search_query).page(page).per(PER_PAGE)
+    list_for_administration.search(search_query).page(page)
   end
 
   def self.profile_parameters
-    %i(image allow_mail birthday consent)
+    %i[image allow_mail birthday consent]
   end
 
   def self.sensitive_parameters
-    %i(email phone password password_confirmation)
+    %i[email phone password password_confirmation]
   end
 
   # Параметры при регистрации
   def self.new_profile_parameters
-    profile_parameters + sensitive_parameters + %i(screen_name)
+    profile_parameters + sensitive_parameters + %i[screen_name]
   end
 
   # Параметры для администрирования
   def self.entity_parameters
-    flags = %i(bot allow_login email_confirmed phone_confirmed foreign_slug)
+    flags = %i[bot allow_login email_confirmed phone_confirmed foreign_slug]
 
-    new_profile_parameters + flags + %i(screen_name notice balance)
+    new_profile_parameters + flags + %i[screen_name notice balance]
   end
 
   def self.ids_range
@@ -108,14 +115,14 @@ class User < ApplicationRecord
   end
 
   def name_for_letter
-    profile_data['name'].blank? ? profile_name : profile_data['name']
+    data.dig('profile', 'name').blank? ? profile_name : data['profile']['name']
   end
 
   # @param [Boolean] include_patronymic
   def full_name(include_patronymic = false)
     result = [name_for_letter]
-    result << profile_data['patronymic'].to_s.strip if include_patronymic
-    result << profile_data['surname'].to_s.strip
+    result << data.dig('profile', 'patronymic').to_s.strip if include_patronymic
+    result << data.dig('profile', 'surname').to_s.strip
     result.compact.join(' ')
   end
 
@@ -129,10 +136,6 @@ class User < ApplicationRecord
 
   private
 
-  def normalize_slug
-    self.slug = (native_slug? ? screen_name : slug).downcase
-  end
-
   def prepare_search_string
     string = "#{slug} #{email} #{UserProfileHandler.search_string(self)}"
 

data/app/models/user_privilege.rb

@@ -4,7 +4,7 @@ class UserPrivilege < ApplicationRecord
   belongs_to :user
   belongs_to :privilege, counter_cache: :users_count
 
-  validates_uniqueness_of :privilege_id, scope: [:user_id, :region_id]
+  validates_uniqueness_of :privilege_id, scope: [:user_id]
 
   # @param [User] user
   # @return [Array<Integer>]

data/app/services/biovision/components/base_component.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Biovision
+  module Components
+    # Base biovision component
+    class BaseComponent
+      attr_reader :component, :slug, :name
+
+      # @param [BiovisionComponent] component
+      def initialize(component)
+        @component = component
+        @slug      = component.slug
+
+        @name = I18n.t("biovision.components.#{@slug}.name", default: @slug)
+      end
+
+      # Receive component-specific handler by component slug
+      #
+      # @param [String] slug
+      # @return [BaseComponent]
+      def self.handler(slug)
+        entity = BiovisionComponent.find_by!(slug: slug)
+
+        handler_name  = "biovision/components/#{slug}_component".classify
+        handler_class = handler_name.safe_constantize || BaseComponent
+        handler_class.new(entity)
+      end
+
+      # @param [Hash] data
+      def settings=(data)
+        @component.settings.merge!(normalize_settings(data))
+        @component.save!
+      end
+
+      def settings
+        @component.settings
+      end
+
+      def parameters
+        @component.biovision_parameters.list_for_administration
+      end
+
+      # Get instance of BiovisionParameter with given slug
+      #
+      # @param [String] slug
+      def parameter(slug)
+        @component.biovision_parameters.find_by(slug: slug)
+      end
+
+      # Create or update parameter values
+      #
+      # @param [String] slug
+      # @param [String] value
+      # @param [String] name
+      # @param [String] description
+      def set_parameter(slug, value, name = '', description = '')
+        @component[slug] = value
+
+        item = parameter(slug)
+        item.update(name: name, description: description) if item.deletable?
+
+        item
+      end
+
+      # Delete parameter with given slug (if it is deletable)
+      #
+      # @param [String] slug
+      def delete_parameter(slug)
+        item = parameter(slug)
+
+        return unless item&.deletable?
+
+        item.destroy
+      end
+
+      # Receive parameter value with default
+      #
+      # Returns value of component's parameter or default value 
+      # when it's not found
+      #
+      # @param [String] key
+      # @param [String] default
+      # @return [String]
+      def receive(key, default = '')
+        @component.receive!(key, default)
+      end
+
+      # Receive parameter value or nil
+      #
+      # Returns value of component's parameter of nil when it's not found
+      #
+      # @param [String] key
+      # @return [String|nil]
+      def [](key)
+        @component.receive(key)
+      end
+
+      # Set parameter
+      #
+      # @param [String] key
+      # @param [String] value
+      def []=(key, value)
+        @component[key] = value
+      end
+
+      protected
+
+      # @param [Hash] data
+      # @return [Hash]
+      def normalize_settings(data)
+        data.to_h
+      end
+    end
+  end
+end

data/app/services/biovision/components/registration_component.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Biovision
+  module Components
+    # Handler for registration component
+    class RegistrationComponent < BaseComponent
+      # @param [Hash] parameters
+      # @param [Code] code
+      def handle(parameters, code)
+        @user    = User.new(parameters)
+        @manager = CodeManager::Invitation.new(code)
+
+        use_invites? ? use_code : persist_user
+
+        @user
+      end
+
+      def open?
+        @component.settings['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']
+      end
+
+      def require_email?
+        @component.settings['require_email']
+      end
+
+      protected
+
+      # @param [Hash] data
+      # @return [Hash]
+      def normalize_settings(data)
+        result = {}
+        flags  = %w[open invite_only use_invites confirm_email require_email]
+        flags.each { |f| result[f] = data[f].to_i == 1 }
+        numbers = %w[invite_count]
+        numbers.each { |f| result[f] = data[f].to_i }
+
+        result
+      end
+
+      def persist_user
+        return unless @user.save
+
+        Metric.register(User::METRIC_REGISTRATION)
+
+        handle_codes
+      end
+
+      # Check invitation code and persist user if it's valid
+      def use_code
+        if @manager.code_is_valid? || (@manager.code.nil? && !invite_only?)
+          persist_user
+        else
+          error = I18n.t('biovision.components.registration.invalid_code')
+
+          # Add "invalid code" error to other model errors, if any
+          @user.valid?
+          @user.errors.add(:code, error)
+        end
+      end
+
+      def handle_codes
+        if confirm_email?
+          code = CodeManager::Confirmation.code_for_user(@user)
+          CodeSender.email(code.id).deliver_later
+        end
+
+        if use_invites?
+          @manager.activate(@user) if @manager.code_is_valid?
+          create_invitations(settings['invite_count'].to_i)
+        end
+      end
+
+      # @param [Integer] quantity
+      def create_invitations(quantity = 1)
+        return unless quantity.positive?
+
+        parameters = {
+          code_type: CodeManager::Invitation.code_type,
+          user:      @user,
+          quantity:  quantity,
+        }
+        Code.create(parameters)
+      end
+    end
+  end
+end