biovision 0.0.200518.1

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Biovision
+  module Components
+    # Handling users
+    class UsersComponent < BaseComponent
+      include Users::Authentication
+
+      METRIC_NEW_USER = 'users.new_user.hit'
+
+      def self.settings_flags
+        %w[
+          registration_open email_as_login confirm_email require_email
+          invite_only use_invites
+        ]
+      end
+
+      def self.settings_numbers
+        %w[invite_count bounce_count bounce_timeout]
+      end
+
+      # @param [Hash] parameters
+      # @param [Code] code
+      def register_user(parameters, code)
+        handler = Users::RegistrationHandler.new(self)
+        handler.handle(parameters, code)
+      end
+
+      # @param [User] entity
+      def valid?(entity)
+        entity.valid? && valid_slug?(entity)
+      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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Biovision
+  module Notifiers
+    # Base notifier class for dispatching component notifications
+    class BaseNotifier
+      attr_accessor :notification, :user
+
+      # @param [User] user
+      def initialize(user)
+        @user = user
+      end
+
+      # @param [Notification] notification
+      def self.[](notification)
+        slug = notification.component_slug
+        instance = handler_class(slug).new(notification.user)
+        instance.notification = notification
+        instance
+      end
+
+      def self.slug
+        to_s.demodulize.underscore.gsub('_notifier', '')
+      end
+
+      # @param [String] slug
+      def self.handler_class(slug)
+        handler_name = "biovision/notifiers/#{slug}_notifier".classify
+        handler_name.safe_constantize || BaseNotifier
+      end
+
+      def component
+        @component ||= BiovisionComponent[self.class.slug]
+      end
+
+      def entity
+        nil
+      end
+
+      def view
+        return if notification.nil?
+
+        "my/notifications/#{self.class.slug}/#{notification.data['type']}"
+      end
+
+      # @param [Hash] data
+      def notify(data)
+        attributes = { user: user, biovision_component: component, data: data }
+        Notification.create(attributes)
+      end
+
+      protected
+
+      # @param [Integer] id
+      # @param [String] type
+      def check_and_notify(id, type)
+        return if check_chain(id, type).exists?
+
+        notify({id: id, type: type})
+      end
+
+      # @param [Integer] id
+      # @param [String] type
+      def check_chain(id, type)
+        Notification.owned_by(user).unread.data_id(id).data_type(type)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Biovision
+  module Notifiers
+    # Notification mapper for socialization component
+    class SocializationNotifier < BaseNotifier
+      TYPE_FOLLOWER = 'follower'
+      TYPE_MESSAGE = 'message'
+
+      def entity
+        data = notification&.data.to_h
+        case data['type']
+        when TYPE_MESSAGE, TYPE_FOLLOWER
+          User.find_by(id: data['id'])
+        else
+          nil
+        end
+      end
+
+      # @param [Integer] sender_id
+      def new_message(sender_id)
+        check_and_notify(sender_id, TYPE_MESSAGE)
+      end
+
+      # @param [Integer] follower_id
+      def new_follower(follower_id)
+        check_and_notify(follower_id, TYPE_FOLLOWER)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Biovision
+  module Notifiers
+    # Notification mapper for socialization component
+    class UsersNotifier < BaseNotifier
+      TYPE_LOGIN_ATTEMPT = 'login_attempt'
+
+      # @param [Hash] track
+      def new_login_attempt(track)
+        check_and_notify(track[:ip_address]&.id, TYPE_LOGIN_ATTEMPT)
+      end
+    end
+  end
+end

data/app/models/agent.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# User agent
+#
+# Attributes:
+#   banned [boolean]
+#   browser_id [Browser], optional
+#   created_at [DateTime]
+#   object_count [integer]
+#   name [string]
+#   updated_at [DateTime]
+class Agent < ApplicationRecord
+  include RequiredUniqueName
+  include Toggleable
+
+  toggleable :banned
+
+  belongs_to :browser, optional: true, counter_cache: true
+
+  before_validation { self.name = name.to_s[0..254] }
+
+  scope :list_for_administration, -> { ordered_by_name }
+
+  # @param [Integer] page
+  def self.page_for_administration(page = 1)
+    list_for_administration.page(page)
+  end
+
+  # @param [String] name
+  def self.[](name)
+    return if name.blank?
+
+    find_or_create_by(name: name[0..254])
+  end
+end

data/app/models/biovision_component.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# Biovision component entity, settings and parameters
+#
+# Attributes:
+#   active [Boolean]
+#   created_at [DateTime]
+#   parameters [JSON]
+#   priority [Integer]
+#   settings [JSON]
+#   slug [String]
+#   updated_at [DateTime]
+class BiovisionComponent < ApplicationRecord
+  include FlatPriority
+  include RequiredUniqueSlug
+
+  has_many :biovision_component_users, dependent: :delete_all
+  has_many :simple_images, dependent: :destroy
+
+  scope :list_for_administration, -> { ordered_by_priority }
+
+  # Find component by slug
+  #
+  # @param [String] slug
+  def self.[](slug)
+    find_by(slug: slug)
+  end
+
+  # @param [String] slug
+  # @param [String] default_value
+  def get(slug, default_value = '')
+    parameters.fetch(slug.to_s) { default_value }
+  end
+
+  # @param [String] slug
+  # @param value
+  def []=(slug, value)
+    parameters[slug.to_s] = value
+    save!
+  end
+
+  def privileges
+    biovision_component_users.recent
+  end
+end

data/app/models/biovision_component_user.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# User data in biovision component
+# 
+# Attributes:
+#   administrator [boolean]
+#   biovision_component_id [BiovisionComponent]
+#   created_at [DateTime]
+#   data [jsonb]
+#   updated_at [DateTime]
+#   user_id [User]
+class BiovisionComponentUser < ApplicationRecord
+  include HasOwner
+
+  belongs_to :biovision_component
+  belongs_to :user
+
+  validates_uniqueness_of :user_id, scope: :biovision_component_id
+
+  scope :recent, -> { order('updated_at desc') }
+end

data/app/models/browser.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Browser
+#
+# Attributes:
+#   agents_count [integer]
+#   banned [boolean]
+#   created_at [DateTime]
+#   mobile [boolean]
+#   name [string]
+#   updated_at [DateTime]
+#   version [string]
+class Browser < ApplicationRecord
+  include Checkable
+  include Toggleable
+
+  NAME_LIMIT = 50
+  VERSION_LIMIT = 10
+
+  toggleable :banned
+
+  has_many :agents, dependent: :nullify
+
+  validates_presence_of :name, :version
+  validates_uniqueness_of :version, scope: :name
+  validates_length_of :name, maximum: NAME_LIMIT
+  validates_length_of :version, maximum: VERSION_LIMIT
+
+  scope :list_for_administration, -> { order('name asc, version asc') }
+
+  def self.entity_parameters
+    %i[banned mobile name version]
+  end
+end

data/app/models/code.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# Code for users
+# 
+# Attributes:
+#   agent_id [Agent], optional
+#   biovision_component_id [BiovisionComponent]
+#   body [string]
+#   created_at [DateTime]
+#   data [jsonb]
+#   ip_address_id [IpAddress], optional
+#   quantity [integer]
+#   updated_at [DateTime]
+#   user_id [User]
+class Code < ApplicationRecord
+  include HasOwner
+  include HasTrack
+
+  BODY_LIMIT = 50
+  QUANTITY_RANGE = (0..32_767).freeze
+
+  belongs_to :biovision_component
+  belongs_to :user
+
+  after_initialize :generate_body
+
+  before_validation :sanitize_quantity
+
+  validates_presence_of :body
+  validates_uniqueness_of :body
+  validates_length_of :body, maximum: BODY_LIMIT
+
+  scope :recent, -> { order('id desc') }
+  scope :active, -> { where('quantity > 0') }
+  scope :list_for_administration, -> { recent }
+
+  # @param [Integer] page
+  def self.page_for_administration(page = 1)
+    list_for_administration.page(page)
+  end
+
+  def self.entity_parameters
+    %i[body payload quantity]
+  end
+
+  def self.creation_parameters
+    entity_parameters + %i[user_id code_type_id]
+  end
+
+  def activated?
+    quantity < 1
+  end
+
+  def active?
+    quantity.positive?
+  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
+  end
+
+  def sanitize_quantity
+    self.quantity = QUANTITY_RANGE.first if quantity < QUANTITY_RANGE.first
+    self.quantity = QUANTITY_RANGE.last if quantity > QUANTITY_RANGE.last
+  end
+end

data/app/models/concerns/checkable.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Adds method for validating model in controllers
+#
+# @author Maxim Khan-Magomedov <maxim.km@gmail.com>
+module Checkable
+  extend ActiveSupport::Concern
+
+  included do
+    # @param id
+    # @param [Hash] parameters
+    def self.instance_for_check(id, parameters)
+      if id.blank?
+        entity = new(parameters)
+      else
+        entity = find_by(id: id)
+        entity.assign_attributes(parameters)
+      end
+      entity
+    end
+  end
+end

data/app/models/concerns/flat_priority.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# Model has flat priority field
+#
+# Adds sorting items by priority
+# @author Maxim Khan-Magomedov <maxim.km@gmail.com>
+module FlatPriority
+  extend ActiveSupport::Concern
+
+  included do
+    after_initialize :set_next_priority
+    before_validation :normalize_priority
+
+    scope :ordered_by_priority, -> { order('priority asc, id asc') }
+
+    def self.priority_range
+      (1..32_767)
+    end
+  end
+
+  # @param [Integer] delta
+  def change_priority(delta)
+    swap_priority_with_adjacent(priority + delta)
+
+    self.class.ordered_by_priority.map { |e| [e.id, e.priority] }.to_h
+  end
+
+  protected
+
+  # @param [Integer] new_priority
+  def swap_priority_with_adjacent(new_priority)
+    adjacent = self.class.find_by(priority: new_priority)
+    if adjacent.is_a?(self.class) && (adjacent.id != id)
+      adjacent.update!(priority: priority)
+    end
+    update!(priority: new_priority)
+  end
+
+  def set_next_priority
+    return unless id.nil? && priority == 1
+
+    self.priority = self.class.maximum(:priority).to_i + 1
+  end
+
+  def normalize_priority
+    range = self.class.priority_range
+    self.priority = range.first if priority < range.first
+    self.priority = range.last if priority > range.last
+  end
+end