biovision 0.0.200518.1 → 0.1.210414.0

data/app/models/language.rb

@@ -28,4 +28,8 @@ class Language < ApplicationRecord
   def self.[](code)
     find_by(code: code)
   end
+
+  def name
+    I18n.t("languages.#{slug}", default: slug)
+  end
 end

data/app/models/navigation_group.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# Navigation group
+#
+# Attributes:
+#   created_at [DateTime]
+#   dynamic_pages_count [integer]
+#   name [string]
+#   slug [string]
+#   updated_at [DateTime]
+class NavigationGroup < ApplicationRecord
+  include Checkable
+  include RequiredUniqueName
+  include RequiredUniqueSlug
+
+  NAME_LIMIT = 100
+  SLUG_LIMIT = 100
+
+  has_many :navigation_group_pages, dependent: :delete_all
+
+  validates_length_of :name, maximum: NAME_LIMIT
+  validates_length_of :slug, maximum: SLUG_LIMIT
+
+  scope :list_for_administration, -> { ordered_by_name }
+
+  def self.entity_parameters(*)
+    %i[name slug]
+  end
+
+  def text_for_link
+    name
+  end
+end

data/app/models/navigation_group_page.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# Page in navigation group
+#
+# Attributes:
+#   created_at [DateTime]
+#   dynamic_page_id [DynamicPage]
+#   navigation_group_id [NavigationGroup]
+#   priority [integer]
+#   updated_at [DateTime]
+class NavigationGroupPage < ApplicationRecord
+  include NestedPriority
+
+  belongs_to :navigation_group, counter_cache: :dynamic_pages_count
+  belongs_to :dynamic_page
+
+  validates_uniqueness_of :dynamic_page_id, scope: :navigation_group_id
+
+  # @param [NavigationGroupPage] entity
+  def self.siblings(entity)
+    where(navigation_group_id: entity&.navigation_group_id)
+  end
+end

data/app/models/role.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# ACL role
+#
+# Attributes:
+#   biovision_component_id [BiovisionComponent]
+#   data [jsonb]
+#   slug [string]
+#   user_count [integer]
+#   uuid [uuid]
+class Role < ApplicationRecord
+  include Checkable
+  include HasUuid
+
+  SLUG_LIMIT = 50
+  SLUG_PATTERN = /\A[a-z][_a-z]*[a-z]\z/.freeze
+
+  belongs_to :biovision_component
+  has_many :role_groups, dependent: :destroy
+  has_many :user_groups, dependent: :destroy
+
+  before_validation { self.slug = slug.to_s.downcase }
+
+  validates_presence_of :slug
+  validates_uniqueness_of :slug, scope: :biovision_component_id
+  validates_format_of :slug, with: SLUG_PATTERN
+
+  # @param [String] slug
+  def self.[](slug)
+    find_by(slug: slug)
+  end
+
+  def groups
+    # group_ids = role_groups.map(&:group).map(&:branch_ids).flatten.uniq
+    # Group.where(id: group_ids)
+    []
+  end
+
+  def users
+    User.where(id: user_ids)
+  end
+
+  def user_ids
+    # direct_inclusive = user_roles.where(inclusive: true).pluck(:user_id).uniq
+    # direct_exclusive = user_roles.where(inclusive: false).pluck(:user_id).uniq
+    # group_inclusive = groups.map(&:user_ids).flatten
+    #
+    # group_inclusive + direct_inclusive - direct_exclusive
+    []
+  end
+
+  def count_users!
+    self.user_count = user_ids.count
+    save
+  end
+end

data/app/models/role_group.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Role in ACL group
+#
+# Attributes:
+#   group_id [Group]
+#   role_id [Role]
+class RoleGroup < ApplicationRecord
+  belongs_to :group
+  belongs_to :role
+
+  validates_uniqueness_of :role_id, scope: :group_id
+end

data/app/models/simple_image.rb

@@ -23,25 +23,39 @@ class SimpleImage < ApplicationRecord
   include HasTrack
   include HasUuid
 
-  CAPTION_LIMIT = 255
-  LINK_LIMIT = 255
-  NAME_LIMIT = 255
   META_LIMIT = 255
 
+  mount_uploader :image, SimpleImageUploader
+
+  belongs_to :agent, optional: true
   belongs_to :biovision_component
   belongs_to :user, optional: true
+  has_many :simple_image_tag_images, dependent: :destroy
+  has_many :simple_image_tags, through: :simple_image_tag_images
 
   validates_presence_of :image
-  validates_length_of :caption, maximum: CAPTION_LIMIT
+  validates_length_of :caption, maximum: META_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
+  validates_length_of :source_link, maximum: META_LIMIT
+  validates_length_of :source_name, maximum: META_LIMIT
+
+  scope :in_component, ->(v) { where(biovision_component: v) }
+  scope :filtered, ->(v) { where('image ilike ? or caption ilike ?', "%#{v}%", "%#{v}%") unless v.blank? }
+  scope :list_for_administration, -> { order('image asc') }
 
-  def self.entity_parameters
+  def self.entity_parameters(*)
     %i[caption image image_alt_text source_link source_name]
   end
 
   def name
-    caption.blank? ? File.basename(image.path) : caption
+    File.basename(image.path)
+  end
+
+  def file_size
+    File.size(image.path)
+  end
+
+  def image_slug
+    "#{uuid[0..2]}/#{uuid[3..5]}/#{uuid}"
   end
 end

data/app/models/simple_image_tag.rb

@@ -18,7 +18,7 @@ class SimpleImageTag < ApplicationRecord
 
   scope :list_for_administration, -> { order('name asc') }
 
-  def self.entity_parameters
+  def self.entity_parameters(*)
     %i[name]
   end
 

data/app/models/token.rb

@@ -45,11 +45,11 @@ class Token < ApplicationRecord
     list_for_owner(user).page(page)
   end
 
-  def self.entity_parameters
+  def self.entity_parameters(*)
     %i[active]
   end
 
-  def self.creation_parameters
+  def self.creation_parameters(*)
     entity_parameters + %i[user_id]
   end
 
@@ -64,7 +64,7 @@ class Token < ApplicationRecord
     return if input.blank?
 
     pair = input.split(':')
-    user_by_pair(pair[0], pair[1], touch_user)
+    user_by_pair(pair[0].to_i, pair[1], touch_user)
   end
 
   # @param [Integer] user_id
@@ -87,7 +87,7 @@ class Token < ApplicationRecord
   def editable_by?(user)
     return true if owned_by?(user)
 
-    Biovision::Components::UsersComponent[user].allow?('edit')
+    Biovision::Components::UsersComponent[user].permit?('edit', self)
   end
 
   def cookie_pair

data/app/models/user.rb

@@ -5,17 +5,15 @@
 # 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]
+#   image [SimpleImageUploader], optional
 #   inviter_id [User], optional
 #   ip_address_id [IpAddress], optional
 #   language_id [Language], optional
@@ -24,6 +22,7 @@
 #   password_digest [string]
 #   phone_confirmed [boolean]
 #   primary_id [User], optional
+#   profile [Jsonb]
 #   screen_name [string]
 #   slug [string]
 #   super_user [boolean]
@@ -34,46 +33,64 @@
 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
+  FLAG_SKIP_SCREEN_NAME = 'skip_screen_name_validation'
   NOTICE_LIMIT = 255
   PHONE_LIMIT = 50
-  SLUG_LIMIT = 250
+  SLUG_LIMIT = 36
+  SLUG_PATTERN = /\A[_a-z0-9][-_a-z0-9]{0,34}[_a-z0-9]\z/i.freeze
+  SLUG_PATTERN_HTML = '^[_a-zA-Z0-9][-_a-zA-Z0-9]{0,34}[_a-zA-Z0-9]$'
 
-  toggleable :banned, :allow_mail, :email_confirmed, :phone_confirmed
+  attr_accessor :code
+
+  toggleable :email_confirmed, :allow_mail, :phone_confirmed
 
   has_secure_password
-  mount_uploader :image, UserImageUploader
+  mount_uploader :image, SimpleImageUploader
 
   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 :foreign_users, dependent: :delete_all if Gem.loaded_specs.key?('biovision-oauth')
   has_many :login_attempts, dependent: :delete_all
   has_many :user_languages, dependent: :delete_all
 
-  before_validation :normalize_slug
+  after_initialize :prepare_referral_link
+
+  before_validation { self.email = nil if email.blank? }
+  before_validation { self.phone = nil if phone.blank? }
+  after_validation :normalize_slug
+
+  validate do |entity|
+    Biovision::Components::UsersComponent[entity].validate
+  end
 
   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 :screen_name, presence: true, 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 :phone, uniqueness: { case_sensitive: false }, allow_nil: true
   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) }
+  scope :with_email, ->(v) { where('lower(email) = lower(?)', v.to_s) }
+  scope :list_for_administration, -> { order('id desc') }
+
+  def self.[](login)
+    find_by(slug: login) || find_by_contact(login)
+  end
+
+  # @param [Integer] page
+  def self.page_for_administration(page = 1)
+    list_for_administration.page(page)
+  end
 
   def self.profile_parameters
     %i[image allow_mail birthday consent]
@@ -83,16 +100,25 @@ class User < ApplicationRecord
     %i[email phone password password_confirmation]
   end
 
-  # Параметры при регистрации
-  def self.new_profile_parameters
+  # @param [String] login
+  def self.find_by_contact(login)
+    if login.index('@').to_i.positive?
+      User.with_email(login).first
+    elsif login[0] == '+'
+      User.find_by(phone: login)
+    end
+  end
+
+  # Parameters for registration
+  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]
+  def self.entity_parameters(*)
+    flags = %i[banned bot email_confirmed phone_confirmed]
 
-    new_profile_parameters + flags + %i[screen_name notice balance]
+    new_profile_parameters + flags + %i[notice screen_name slug]
   end
 
   def self.ids_range
@@ -101,6 +127,15 @@ class User < ApplicationRecord
     (min..max)
   end
 
+  # @param [String] role_name
+  def role?(role_name)
+    return true if super_user?
+
+    parts = role_name.split('.')
+    handler = Biovision::Components::BaseComponent.handler(parts.shift, self)
+    handler.role?(parts.join)
+  end
+
   # Name to be shown as profile
   #
   # This can be redefined for cases when something other than screen name should
@@ -108,18 +143,22 @@ class User < ApplicationRecord
   #
   # @return [String]
   def profile_name
-    screen_name
+    email_as_login? ? email.to_s.split('@').first : screen_name
+  end
+
+  def text_for_link
+    profile_name
   end
 
   def name_for_letter
-    data.dig('profile', 'name').blank? ? profile_name : data['profile']['name']
+    profile['name'].blank? ? profile_name : 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 << profile['patronymic'].to_s.strip if include_patronymic
+    result << profile['surname'].to_s.strip
     result.compact.join(' ')
   end
 
@@ -127,10 +166,39 @@ class User < ApplicationRecord
     allow_mail? && !email.blank?
   end
 
+  def email_as_login?
+    !data[Biovision::Components::UsersComponent::SETTING_EMAIL_AS_LOGIN].blank?
+  end
+
+  def phone_as_login?
+    !data[Biovision::Components::UsersComponent::SETTING_PHONE_AS_LOGIN].blank?
+  end
+
+  # @param [String|Symbol] component_slug
+  def component_data(component_slug)
+    data.dig('components', component_slug.to_s).to_h
+  end
+
+  # @param [String|Symbol] component_slug
+  # @param [Hash] component_data
+  def new_component_data(component_slug, component_data)
+    data['components'] ||= {}
+    data['components'][component_slug.to_s] = component_data.to_h
+  end
+
+  def world_url
+    key = screen_name.downcase == slug ? screen_name : slug
+    "/u/#{CGI.escape(key)}"
+  end
+
   private
 
+  def prepare_referral_link
+    self.referral_link = SecureRandom.alphanumeric(12) if referral_link.blank?
+  end
+
   def normalize_slug
-    self.slug = screen_name.to_s if slug.nil?
+    self.slug = screen_name.to_s if slug.blank?
     self.slug = slug.to_s.downcase
   end
 end