biovision 0.0.200518.1

data/app/models/notification.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# Component notification for user
+#
+# Attributes:
+#   biovision_component_id [BiovisionComponent]
+#   created_at [DateTime]
+#   data [jsonb]
+#   email_sent [boolean]
+#   read [boolean]
+#   updated_at [DateTime]
+#   user_id [User]
+#   uuid [uuid]
+class Notification < ApplicationRecord
+  include HasOwner
+  include HasUuid
+
+  belongs_to :biovision_component
+  belongs_to :user
+
+  scope :recent, -> { order('id desc') }
+  scope :unread, -> { where(read: false) }
+  scope :not_sent, -> { where(email_sent: false) }
+  scope :data_id, ->(v) { where("cast(data->>'id' as integer) = ?", v) }
+  scope :data_type, ->(v) { where("data->>'type' = ?", v) }
+  scope :list_for_owner, ->(v) { owned_by(v).recent }
+
+  # @param [User] user
+  # @param [Integer] page
+  def self.page_for_owner(user, page = 1)
+    list_for_owner(user).page(page)
+  end
+
+  def component_slug
+    biovision_component.slug
+  end
+end

data/app/models/simple_image.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# Universal simple image
+# 
+# Attributes:
+#   agent_id [Agent], optional
+#   biovision_component_id [BiovisionComponent]
+#   caption [string], optional
+#   created_at [DateTime]
+#   image [SimpleImageUploader]
+#   image_alt_text [string]
+#   ip_address_id [IpAddress], optional
+#   object_count [integer]
+#   source_link [string], optional
+#   source_name [string], optional
+#   updated_at [DateTime]
+#   user_id [User], optional
+#   uuid [uuid]
+#   data [jsonb]
+class SimpleImage < ApplicationRecord
+  include Checkable
+  include HasOwner
+  include HasTrack
+  include HasUuid
+
+  CAPTION_LIMIT = 255
+  LINK_LIMIT = 255
+  NAME_LIMIT = 255
+  META_LIMIT = 255
+
+  belongs_to :biovision_component
+  belongs_to :user, optional: true
+
+  validates_presence_of :image
+  validates_length_of :caption, maximum: CAPTION_LIMIT
+  validates_length_of :image_alt_text, maximum: META_LIMIT
+  validates_length_of :source_link, maximum: LINK_LIMIT
+  validates_length_of :source_name, maximum: NAME_LIMIT
+
+  def self.entity_parameters
+    %i[caption image image_alt_text source_link source_name]
+  end
+
+  def name
+    caption.blank? ? File.basename(image.path) : caption
+  end
+end

data/app/models/simple_image_tag.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# Tag for simple image
+# 
+# Attributes:
+#   created_at [DateTime]
+#   name [string]
+#   simple_images_count [integer]
+#   updated_at [DateTime]
+class SimpleImageTag < ApplicationRecord
+  include Checkable
+  NAME_LIMIT = 100
+
+  has_many :simple_image_tag_images, dependent: :delete_all
+
+  before_validation :normalize_name
+  validates_uniqueness_of :name, case_sensitive: false
+
+  scope :list_for_administration, -> { order('name asc') }
+
+  def self.entity_parameters
+    %i[name]
+  end
+
+  private
+
+  def normalize_name
+    self.name = name.to_s[0..NAME_LIMIT]
+  end
+end

data/app/models/simple_image_tag_image.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Link between simple image and tag
+# 
+# Attributes:
+#   simple_image_id [SimpleImage]
+#   simple_image_tag_id [SimpleImageTag]
+class SimpleImageTagImage < ApplicationRecord
+  belongs_to :simple_image
+  belongs_to :simple_image_tag, counter_cache: :simple_images_count
+
+  validates_uniqueness_of :simple_image_tag_id, scope: :simple_image_id
+end

data/app/models/token.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+# Authentication token
+#
+# Attributes:
+#   active [boolean]
+#   agent_id [Agent], optional
+#   created_at [DateTime]
+#   ip_address_id [IpAddress], optional
+#   last_used [datetime]
+#   updated_at [DateTime]
+#   user_id [User]
+#   token [string]
+class Token < ApplicationRecord
+  include Checkable
+  include HasOwner
+  include HasTrack
+  include Toggleable
+
+  TOKEN_LIMIT = 255
+
+  toggleable :active
+
+  has_secure_token
+
+  belongs_to :user
+  validates_uniqueness_of :token
+  validates_length_of :token, maximum: TOKEN_LIMIT
+
+  scope :recent, -> { order('last_used desc nulls last') }
+  scope :active, ->(f) { where(active: f.to_i.positive?) unless f.blank? }
+  scope :filtered, ->(f) { with_user_id(f[:user_id]).active(f[:active]) }
+  scope :list_for_administration, -> { recent }
+  scope :list_for_owner, ->(u) { owned_by(u).recent }
+
+  # @param [Integer] page
+  # @param [Hash] filter
+  def self.page_for_administration(page = 1, filter = {})
+    filtered(filter).list_for_administration.page(page)
+  end
+
+  # @param [User] user
+  # @param [Integer] page
+  def self.page_for_owner(user, page = 1)
+    list_for_owner(user).page(page)
+  end
+
+  def self.entity_parameters
+    %i[active]
+  end
+
+  def self.creation_parameters
+    entity_parameters + %i[user_id]
+  end
+
+  # @param [String] input
+  def self.[](input)
+    find_by(token: input.to_s.split(':')[1].to_s)
+  end
+
+  # @param [String] input
+  # @param [Boolean] touch_user
+  def self.user_by_token(input, touch_user = false)
+    return if input.blank?
+
+    pair = input.split(':')
+    user_by_pair(pair[0], pair[1], touch_user)
+  end
+
+  # @param [Integer] user_id
+  # @param [String] token
+  # @param [Boolean] touch_user
+  def self.user_by_pair(user_id, token, touch_user = false)
+    instance = find_by(user_id: user_id, token: token, active: true)
+    return if instance.nil?
+
+    instance.update_columns(last_used: Time.now)
+    instance.user.update_columns(last_seen: Time.now) if touch_user
+    instance.user
+  end
+
+  def name
+    "[#{id}] #{user.profile_name}"
+  end
+
+  # @param [User] user
+  def editable_by?(user)
+    return true if owned_by?(user)
+
+    Biovision::Components::UsersComponent[user].allow?('edit')
+  end
+
+  def cookie_pair
+    "#{user_id}:#{token}"
+  end
+end

data/app/models/user.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+# User
+# 
+# Attributes:
+#   agent_id [Agent], optional
+#   allow_mail [boolean]
+#   balance [integer]
+#   banned [boolean]
+#   birthday [date], optional
+#   bot [boolean]
+#   consent [boolean]
+#   created_at [DateTime]
+#   data [jsonb]
+#   deleted [boolean]
+#   email [string], optional
+#   email_confirmed [boolean]
+#   image [UserImageUploader]
+#   inviter_id [User], optional
+#   ip_address_id [IpAddress], optional
+#   language_id [Language], optional
+#   last_seen [datetime], optional
+#   notice [string], optional
+#   password_digest [string]
+#   phone_confirmed [boolean]
+#   primary_id [User], optional
+#   screen_name [string]
+#   slug [string]
+#   super_user [boolean]
+#   phone [string], optional
+#   referral_link [string]
+#   updated_at [DateTime]
+#   uuid [uuid]
+class User < ApplicationRecord
+  include Checkable
+  include HasLanguage
+  include HasSimpleImage
+  include HasTrack
+  include HasUuid
+  include Toggleable
+
+  EMAIL_LIMIT = 250
+  EMAIL_PATTERN = /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z0-9][-a-z0-9]+)\z/i.freeze
+  NOTICE_LIMIT = 255
+  PHONE_LIMIT = 50
+  SLUG_LIMIT = 250
+
+  toggleable :banned, :allow_mail, :email_confirmed, :phone_confirmed
+
+  has_secure_password
+  mount_uploader :image, UserImageUploader
+
+  belongs_to :inviter, class_name: User.to_s, optional: true
+  has_many :invitees, class_name: User.to_s, foreign_key: :inviter_id, dependent: :nullify
+  has_many :tokens, dependent: :delete_all
+  has_many :codes, dependent: :delete_all
+  has_many :foreign_users, dependent: :delete_all
+  has_many :login_attempts, dependent: :delete_all
+  has_many :user_languages, dependent: :delete_all
+
+  before_validation :normalize_slug
+
+  validates_acceptance_of :consent
+  validates_presence_of :screen_name
+  validates_format_of :email, with: EMAIL_PATTERN, allow_blank: true
+  validates :screen_name, uniqueness: { case_sensitive: false }
+  validates :email, uniqueness: { case_sensitive: false }, allow_nil: true
+  validates_length_of :slug, maximum: SLUG_LIMIT
+  validates_length_of :screen_name, maximum: SLUG_LIMIT
+  validates_length_of :email, maximum: EMAIL_LIMIT
+  validates_length_of :phone, maximum: PHONE_LIMIT
+  validates_length_of :notice, maximum: NOTICE_LIMIT
+
+  scope :bots, ->(f) { where(bot: f.to_i.positive?) unless f.blank? }
+  scope :email_like, ->(v) { where('email ilike ?', "%#{v}%") unless v.blank? }
+  scope :with_email, ->(v) { where('lower(email) = lower(?)', v) }
+
+  def self.profile_parameters
+    %i[image allow_mail birthday consent]
+  end
+
+  def self.sensitive_parameters
+    %i[email phone password password_confirmation]
+  end
+
+  # Параметры при регистрации
+  def self.new_profile_parameters
+    profile_parameters + sensitive_parameters + %i[screen_name]
+  end
+
+  # Administrative parameters
+  def self.entity_parameters
+    flags = %i[banned bot email_confirmed phone_confirmed foreign_slug]
+
+    new_profile_parameters + flags + %i[screen_name notice balance]
+  end
+
+  def self.ids_range
+    min = User.minimum(:id).to_i
+    max = User.maximum(:id).to_i
+    (min..max)
+  end
+
+  # Name to be shown as profile
+  #
+  # This can be redefined for cases when something other than screen name should
+  # be used.
+  #
+  # @return [String]
+  def profile_name
+    screen_name
+  end
+
+  def name_for_letter
+    data.dig('profile', 'name').blank? ? profile_name : data['profile']['name']
+  end
+
+  # @param [TrueClass|FalseClass] include_patronymic
+  def full_name(include_patronymic = false)
+    result = [name_for_letter]
+    result << data.dig('profile', 'patronymic').to_s.strip if include_patronymic
+    result << data.dig('profile', 'surname').to_s.strip
+    result.compact.join(' ')
+  end
+
+  def can_receive_letters?
+    allow_mail? && !email.blank?
+  end
+
+  private
+
+  def normalize_slug
+    self.slug = screen_name.to_s if slug.nil?
+    self.slug = slug.to_s.downcase
+  end
+end

data/app/models/user_language.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Language for user
+# 
+# Attributes:
+#   created_at [DateTime]
+#   language_id [Language]
+#   updated_at [DateTime]
+#   user_id [User]
+class UserLanguage < ApplicationRecord
+  include HasOwner
+
+  belongs_to :user
+  belongs_to :language
+end

data/app/uploaders/simple_image_uploader.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+# Uploader for universal simple images
+class SimpleImageUploader < CarrierWave::Uploader::Base
+  include CarrierWave::MiniMagick
+
+  storage :file
+
+  def store_dir
+    "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{path_slug}"
+  end
+
+  def default_url(*)
+    ActionController::Base.helpers.asset_path('biovision/placeholders/1x1.svg')
+  end
+
+  version :hd, if: :raster_image? do
+    resize_to_fit(1920, 1920)
+  end
+
+  version :large, from_version: :hd, if: :raster_image? do
+    resize_to_fit(1280, 1280)
+  end
+
+  version :medium, from_version: :large, if: :raster_image? do
+    resize_to_fit(640, 640)
+  end
+
+  version :small, from_version: :medium, if: :raster_image? do
+    resize_to_fit(320, 320)
+  end
+
+  version :preview, from_version: :small, if: :raster_image? do
+    resize_to_fit(160, 160)
+  end
+
+  # Add a white list of extensions which are allowed to be uploaded.
+  # For images you might use something like this:
+  def extension_whitelist
+    %w[jpg jpeg png svg svgz]
+  end
+
+  # Text for image alt attribute
+  #
+  # @param [String] default
+  # @return [String]
+  def alt_text(default = '')
+    method_name = "#{mounted_as}_alt_text".to_sym
+    if model.respond_to?(method_name)
+      model.send(method_name)
+    else
+      default
+    end
+  end
+
+  # @param [SanitizedFile]
+  def raster_image?(new_file)
+    !new_file.extension.match?(/svgz?\z/i)
+  end
+
+  def raster?
+    !File.extname(path).match?(/\.svgz?\z/i)
+  end
+
+  def preview_url
+    raster? ? preview.url : url
+  end
+
+  def small_url
+    raster? ? small.url : url
+  end
+
+  def medium_url
+    raster? ? medium.url : url
+  end
+
+  def large_url
+    raster? ? large.url : url
+  end
+
+  def hd_url
+    raster? ? hd.url : url
+  end
+
+  private
+
+  def path_slug
+    if model.respond_to?(:uuid)
+      uuid = model&.uuid.to_s
+      "#{uuid[0..2]}/#{uuid[3..5]}/#{uuid[6..7]}/#{uuid}"
+    else
+      id = model&.id.to_i
+      "#{id / 1000}/#{id}"
+    end
+  end
+end