biovision 0.0.200518.1 → 0.12.211124.0

data/app/lib/biovision/migrations/component_migration.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Biovision
+  module Migrations
+    # Mix-ins for repeated component migration parts
+    module ComponentMigration
+      # Component class
+      def component
+        @component ||= find_component
+      end
+
+      # Create component tables and roles
+      #
+      # Creates new BiovisionComponent
+      # For each dependent model, calls "create_<table_name>" method
+      # Creates roles for new component
+      def up
+        component.create
+        component.dependent_models.each do |model|
+          next if model.table_exists?
+
+          message = "create_#{model.table_name}".to_sym
+          send(message) if respond_to?(message, true)
+        end
+        handler = component[nil]
+        handler.create_roles
+        handler.seed if handler.respond_to?(:seed)
+      end
+
+      # Drops tables for each dependent model
+      # Removes BiovisionComponent
+      def down
+        component.dependent_models.reverse.each do |model|
+          drop_table model.table_name if model.table_exists?
+        end
+        BiovisionComponent[component]&.destroy
+      end
+
+      private
+
+      # Find component class by migration name
+      #
+      # Method relies on naming like Create<:CamelCaseSlug>Component
+      #
+      # Example:
+      #   - Migration class is named CreateFooBarComponent
+      #   - Component slug is "foo_bar"
+      #   - Use base component handler to get "FooBarComponent" class
+      def find_component
+        migration = name.to_s.demodulize.to_s.underscore
+        slug = migration.gsub(/\Acreate_/, '').gsub(/_component\z/, '')
+        Biovision::Components::BaseComponent.handler_class(slug)
+      end
+    end
+  end
+end

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

@@ -20,7 +20,7 @@ module Biovision
       end
 
       def self.slug
-        to_s.demodulize.underscore.gsub('_notifier', '')
+        to_s.demodulize.to_s.underscore.gsub('_notifier', '')
       end
 
       # @param [String] slug
@@ -56,7 +56,7 @@ module Biovision
       def check_and_notify(id, type)
         return if check_chain(id, type).exists?
 
-        notify({id: id, type: type})
+        notify({ id: id, type: type })
       end
 
       # @param [Integer] id

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Biovision
+  module Notifiers
+    # Notification mapper for contact component
+    class ContactNotifier < BaseNotifier
+      TYPE_FEEDBACK_MESSAGE = 'feedback_message'
+
+      # @param [Integer] message_id
+      def new_feedback_message(message_id)
+        check_and_notify(message_id, TYPE_FEEDBACK_MESSAGE)
+      end
+    end
+  end
+end

data/app/lib/biovision/stories/component_story.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Biovision
+  module Stories
+    # Base component story
+    class ComponentStory
+      attr_accessor :component_handler, :entity
+
+      # @param [Biovision::Components::BaseComponent] handler
+      # @param [ApplicationRecord|String|nil] entity
+      def initialize(handler, entity = nil)
+        self.component_handler = handler
+        return if entity.blank?
+
+        if entity.is_a?(ApplicationRecord)
+          self.entity = entity
+        else
+          self.entity_id = entity.to_s
+        end
+      end
+
+      # Get associated model class
+      #
+      # This method should be implemented in children if story name
+      # does not match model name.
+      # The result is used in #entity_id=
+      def model_class
+        model_name = to_s.demodulize.to_s.underscore.gsub('_story', '')
+        model_name.classify.safe_constantize
+      end
+
+      # @param [Hash] parameters
+      def perform(parameters)
+        @parameters = parameters
+        # implement in children and return hash
+        { result: 'Nothing was processed.' }
+      end
+
+      # Set entity identified by value
+      #
+      # This method can be implemented in child classes
+      #
+      # @param [String] value
+      def entity_id=(value)
+        return if model_class.nil?
+
+        if model_class.respond_to?(:[])
+          self.entity = model_class[value]
+        elsif model_class.respond_to?(:find_by)
+          self.entity = model_class.find_by(id: value)
+        end
+      end
+    end
+  end
+end

data/app/lib/canonizer.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# Helper for canonizing and transliterating strings
+class Canonizer
+  # Keys are not latin letters
+  TRANSLITERATION_MAP = {
+    'а' => 'a', 'б' => 'b', 'в' => 'v', 'г' => 'g', 'д' => 'd', 'е' => 'e',
+    'ё' => 'yo', 'ж' => 'zh', 'з' => 'z', 'и' => 'i', 'й' => 'j', 'к' => 'k',
+    'л' => 'l', 'м' => 'm', 'н' => 'n', 'о' => 'o', 'п' => 'p', 'р' => 'r',
+    'с' => 's', 'т' => 't', 'у' => 'u', 'ф' => 'f', 'х' => 'kh', 'ц' => 'c',
+    'ч' => 'ch', 'ш' => 'sh', 'щ' => 'shh', 'ъ' => '', 'ы' => 'y', 'ь' => '',
+    'э' => 'e', 'ю' => 'yu', 'я' => 'ya',
+    'å' => 'ao', 'ä' => 'ae', 'ö' => 'oe', 'é' => 'e'
+  }.freeze
+
+  # @param [String] text
+  def self.transliterate(text)
+    pattern = Regexp.new "[#{TRANSLITERATION_MAP.keys.join}]"
+    result = text.to_s.downcase.gsub(pattern, TRANSLITERATION_MAP)
+
+    a = /[^-a-z0-9_]/ # non-allowed characters will be replaced with dash
+    b = /\A[-_]*([-a-z0-9_]*[a-z0-9]+)[-_]*\z/ # chop leading and trailing dash
+    result.gsub(a, '-').gsub(b, '\1').gsub(/--+/, '-').gsub(/-+\z/, '')
+  end
+
+  # @param [String] input
+  def self.canonize(input)
+    lowered = input.to_s.downcase.strip
+    canonized = lowered.gsub(/[^a-zа-я0-9ё]/, '')
+    canonized.empty? ? lowered : canonized
+  end
+
+  # @param [String] input
+  def self.urlize(input)
+    lowered = input.to_s.downcase.squish
+    lowered.gsub(/[^a-zа-я0-9ё]/, '-').gsub(/-+\z/, '')
+  end
+end

data/app/lib/carrier_wave/image_optim.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module CarrierWave
+  # Optimizing uploaded images
+  module ImageOptim
+    DEFAULT_OPTIONS = {
+      skip_missing_workers: true,
+      advpng: false,
+      gifsicle: false,
+      jhead: false,
+      jpegrecompress: false,
+      jpegtran: false,
+      pngcrush: false,
+      pngout: false,
+      pngquant: false,
+      svgo: false,
+      jpegoptim: { max_quality: 75 },
+      optipng: { level: 4 }
+    }.freeze
+
+    def optimize(options = {})
+      image_optim = ::ImageOptim.new(optimizer_options(options))
+      image_optim.optimize_image!(current_path)
+    end
+
+    private
+
+    def optimizer_options(options)
+      DEFAULT_OPTIONS.deep_merge(options)
+    end
+  end
+end

data/app/mailers/code_sender.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Mailer for sending codes to users
+class CodeSender < ApplicationMailer
+  # Email confirmation code
+  #
+  # @param [Integer] code_id
+  def email(code_id)
+    @code = Code.find_by(id: code_id)
+    return if @code.nil?
+
+    user = @code.user
+
+    return if user.email.blank? || user.email_confirmed?
+
+    mail to: user.email
+  end
+
+  # Password reset code
+  #
+  # @param [Integer] code_id
+  def password(code_id)
+    @code = Code.find_by(id: code_id)
+
+    return if @code.nil? || @code.user.email.blank?
+
+    mail to: @code.user.email
+  end
+end

data/app/mailers/feedback_mailer.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Mailer for sending feedback requests
+class FeedbackMailer < ApplicationMailer
+  # @param [Integer] id
+  def new_feedback_request(id)
+    @entity = FeedbackMessage.find_by(id: id)
+
+    key = Biovision::Components::ContactComponent::SETTING_FEEDBACK_MAIL
+    receiver = Biovision::Components::ContactComponent[nil].settings[key]
+
+    mail to: receiver unless @entity.nil? || receiver.blank?
+  end
+end

data/app/models/agent.rb

@@ -32,4 +32,8 @@ class Agent < ApplicationRecord
 
     find_or_create_by(name: name[0..254])
   end
+
+  def bot?
+    name.downcase.include?('bot')
+  end
 end

data/app/models/biovision_component.rb

@@ -13,17 +13,28 @@
 class BiovisionComponent < ApplicationRecord
   include FlatPriority
   include RequiredUniqueSlug
+  include Toggleable
+
+  SLUG_LIMIT = 250
+  SLUG_PATTERN_HTML = '^[a-zA-Z][-a-zA-Z0-9_]+[a-zA-Z0-9]$'
+
+  toggleable :active
 
-  has_many :biovision_component_users, dependent: :delete_all
   has_many :simple_images, dependent: :destroy
+  has_many :uploaded_files, dependent: :destroy
+  has_many :codes, dependent: :delete_all
+  has_many :roles, dependent: :destroy
+  has_many :groups, dependent: :destroy
 
+  scope :active, -> { where(active: true) }
   scope :list_for_administration, -> { ordered_by_priority }
+  scope :list_for_user, -> { active.ordered_by_priority }
 
   # Find component by slug
   #
-  # @param [String] slug
+  # @param [String|Class] slug
   def self.[](slug)
-    find_by(slug: slug)
+    find_by(slug: slug.respond_to?(:slug) ? slug.slug : slug)
   end
 
   # @param [String] slug
@@ -34,6 +45,8 @@ class BiovisionComponent < ApplicationRecord
 
   # @param [String] slug
   # @param value
+  #
+  # @deprecated use parameters[slug.to_s] = value
   def []=(slug, value)
     parameters[slug.to_s] = value
     save!
@@ -42,4 +55,27 @@ class BiovisionComponent < ApplicationRecord
   def privileges
     biovision_component_users.recent
   end
+
+  # @param [User] user
+  # @param [String] type
+  # @param [Integer] quantity
+  def find_or_create_code(user, type, quantity = 1)
+    code = codes.owned_by(user).with_type(type).active.first
+
+    if code.nil?
+      code = codes.new(user: user, quantity: quantity)
+      code.code_type = type
+      code.save
+    end
+
+    code
+  end
+
+  def text_for_link
+    I18n.t("biovision.components.#{slug}.name", default: slug)
+  end
+
+  def admin_url
+    "/admin/components/#{slug}"
+  end
 end

data/app/models/code.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Code for users
-# 
+#
 # Attributes:
 #   agent_id [Agent], optional
 #   biovision_component_id [BiovisionComponent]
@@ -17,21 +17,22 @@ class Code < ApplicationRecord
   include HasTrack
 
   BODY_LIMIT = 50
-  QUANTITY_RANGE = (0..32_767).freeze
+  QUANTITY_RANGE = (0..32_767)
 
   belongs_to :biovision_component
-  belongs_to :user
+  belongs_to :user, optional: true
 
   after_initialize :generate_body
 
   before_validation :sanitize_quantity
 
   validates_presence_of :body
-  validates_uniqueness_of :body
+  validates_uniqueness_of :body, unless: :phone?
   validates_length_of :body, maximum: BODY_LIMIT
 
   scope :recent, -> { order('id desc') }
   scope :active, -> { where('quantity > 0') }
+  scope :with_type, ->(v) { where("data->>'type' = ?", v) unless v.blank? }
   scope :list_for_administration, -> { recent }
 
   # @param [Integer] page
@@ -40,11 +41,11 @@ class Code < ApplicationRecord
   end
 
   def self.entity_parameters
-    %i[body payload quantity]
+    %i[body quantity]
   end
 
   def self.creation_parameters
-    entity_parameters + %i[user_id code_type_id]
+    entity_parameters + %i[user_id biovision_component_id]
   end
 
   def activated?
@@ -55,13 +56,35 @@ class Code < ApplicationRecord
     quantity.positive?
   end
 
+  # @param [String] type_name
+  def type?(type_name)
+    code_type == type_name.to_s
+  end
+
+  def code_type
+    data['type'].to_s
+  end
+
+  # @param [String] new_type
+  def code_type=(new_type)
+    data['type'] = new_type.to_s
+  end
+
+  def phone?
+    type?(Biovision::Components::UsersComponent::CODE_PHONE_CONFIRMATION)
+  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
+    if phone?
+      self.body = SecureRandom.random_number(1_000_000).to_s.rjust(6, '0')
+    else
+      number = SecureRandom.random_number(0xffff_ffff_ffff_ffff)
+      self.body = number.to_s(36).scan(/.{4}/).join('-').upcase
+    end
   end
 
   def sanitize_quantity

data/app/models/concerns/checkable.rb

@@ -13,7 +13,8 @@ module Checkable
       if id.blank?
         entity = new(parameters)
       else
-        entity = find_by(id: id)
+        key = column_names.include?('uuid') && id.include?('-') ? :uuid : :id
+        entity = find_by(key => id)
         entity.assign_attributes(parameters)
       end
       entity

data/app/models/concerns/has_simple_image.rb

@@ -6,6 +6,15 @@ module HasSimpleImage
 
   included do
     belongs_to :simple_image, optional: true, counter_cache: :object_count
+
+    scope :included_image, -> { includes(:simple_image) }
+
+    def image_metadata
+      {
+        url: simple_image&.image&.url,
+        alt: simple_image&.image_alt_text
+      }
+    end
   end
 
   def image

data/app/models/concerns/has_uploaded_file.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Model references to uploaded file
+module HasUploadedFile
+  extend ActiveSupport::Concern
+
+  included do
+    belongs_to :uploaded_file, optional: true, counter_cache: :object_count
+
+    scope :included_file, -> { includes(:uploaded_file) }
+  end
+
+  def attachment_name
+    uploaded_file&.name
+  end
+
+  def attachment_size
+    uploaded_file&.file_size
+  end
+
+  def attachment_url
+    return if uploaded_file&.attachment.blank?
+
+    uploaded_file.attachment.url
+  end
+end

data/app/models/concerns/meta_texts.rb

@@ -5,12 +5,32 @@ module MetaTexts
   extend ActiveSupport::Concern
 
   included do
-    validates_length_of :meta_description, maximum: 500
-    validates_length_of :meta_keywords, maximum: 250
-    validates_length_of :meta_title, maximum: 250
+    def self.meta_keys
+      %w[title keywords description heading]
+    end
+
+    # @param [String] key
+    # @param [String] default
+    def meta(key, default = '')
+      message = "meta_#{key}".to_sym
+      if respond_to?(message)
+        send(message)
+      else
+        data.dig('meta', key.to_s) || default
+      end
+    end
+
+    def meta!
+      data['meta'].to_h
+    end
+
+    # @param [Hash] new_data
+    def meta=(new_data)
+      data['meta'] = {}
 
-    def self.meta_text_fields
-      %i[meta_description meta_keywords meta_title]
+      self.class.meta_keys.each do |key|
+        data['meta'][key] = new_data[key]
+      end
     end
   end
 end

data/app/models/concerns/simple_tag.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# Adds list of toggleable attributes to model
+#
+# @author Maxim Khan-Magomedov <maxim.km@gmail.com>
+module SimpleTag
+  extend ActiveSupport::Concern
+
+  included do
+
+    before_validation :normalize_name
+    validates_uniqueness_of :name, case_sensitive: false
+
+    scope :list_for_administration, -> { order(:name) }
+
+    def self.entity_parameters
+      %i[name]
+    end
+
+    def self.name_limit
+      100
+    end
+
+    private
+
+    def normalize_name
+      self.name = name.to_s[0..name_limit]
+    end
+  end
+end

data/app/models/concerns/toggleable.rb

@@ -14,7 +14,8 @@ module Toggleable
     def toggle_parameter(attribute)
       return unless toggleable_attributes.include? attribute.to_sym
 
-      toggle! attribute
+      assign_attributes(attribute => !attributes[attribute.to_s])
+      save!
       { attribute => self[attribute] }
     end
   end

data/app/models/concerns/tree_structure.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# Model has parent and children
+module TreeStructure
+  extend ActiveSupport::Concern
+
+  included do
+    belongs_to :parent, class_name: name, optional: true
+    has_many :child_items, class_name: name, foreign_key: :parent_id, dependent: :destroy
+
+    before_save { children_cache.uniq! }
+    after_create :cache_parents!
+    after_destroy { parent&.cache_children! unless ENV['SKIP_CHILDREN_CACHE'] }
+    after_save { parent&.cache_children! unless ENV['SKIP_CHILDREN_CACHE'] }
+
+    scope :with_parent_id, ->(v) { where(parent_id: v) }
+
+    def self.tree(collection)
+      result = {}
+
+      collection.each do |entity|
+        result[entity.id] = {
+          parent_id: entity.parent_id,
+          entity: entity,
+        }
+      end
+
+      result
+    end
+
+    def depth
+      parent_ids.count
+    end
+
+    def parent_ids
+      parents_cache.split(',').compact
+    end
+
+    # @return [Array<Integer>]
+    def branch_ids
+      parents_cache.split(',').map(&:to_i).reject { |i| i < 1 }.uniq + [id]
+    end
+
+    # @return [Array<Integer>]
+    def subbranch_ids
+      [id] + children_cache
+    end
+
+    def parents
+      return [] if parents_cache.blank?
+
+      self.class.where(id: parent_ids).order('id asc')
+    end
+
+    def cache_parents!
+      return if parent.nil?
+
+      self.parents_cache = "#{parent.parents_cache},#{parent_id}".gsub(/\A,/, '')
+      save!
+    end
+
+    # @param [Array] new_cache
+    def cache_children!(new_cache = [])
+      if new_cache.blank?
+        new_cache = child_items.order('id asc').pluck(:id, :children_cache)
+      end
+
+      self.children_cache += new_cache.flatten
+      self.children_cache.uniq!
+
+      save!
+      parent&.cache_children!([id] + children_cache)
+    end
+  end
+end

data/app/models/contact_method.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# Contact method
+#
+# Attributes:
+#   contact_type_id [ContactType]
+#   created_at [DateTime]
+#   data [jsonb]
+#   language_id [Language], optional
+#   name [string], optional
+#   priority [integer]
+#   updated_at [DateTime]
+#   uuid [uuid]
+#   value [string]
+#   visible [boolean]
+class ContactMethod < ApplicationRecord
+  include Checkable
+  include FlatPriority
+  include HasLanguage
+  include HasUuid
+  include Toggleable
+
+  NAME_LIMIT = 50
+  VALUE_LIMIT = 255
+
+  toggleable :visible
+
+  belongs_to :language, optional: true
+  belongs_to :contact_type
+
+  validates_presence_of :value
+  validates_length_of :name, maximum: NAME_LIMIT
+  validates_length_of :value, maximum: VALUE_LIMIT
+
+  scope :visible, -> { where(visible: true) }
+  scope :list_for_administration, -> { ordered_by_priority }
+  scope :list_for_visitors, -> { visible.ordered_by_priority }
+
+  # @param [String] slug
+  def self.[](slug)
+    ContactType[slug]&.contact_methods&.list_for_visitors
+  end
+
+  def self.entity_parameters
+    %i[contact_type_id language_id name priority value visible]
+  end
+end