biovision 0.0.200518.1 → 0.12.211124.0

data/app/helpers/entity_helper.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+# Helpers for displaying common entity-related blocks
+module EntityHelper
+  # @param [Enumerable] collection
+  # @param [Symbol|String|nil] scope
+  # @param [Biovision::Components::BaseComponent|nil] handler
+  # @param [TrueClass|FalseClass] with_priority
+  def entity_list(collection, scope: nil, handler: component_handler, with_priority: false)
+    scope = controller.class.module_parent_name.to_s.downcase if scope.nil?
+    suffix = with_priority ? '_with_priority' : ''
+
+    render(
+      partial: "shared/entity/list#{suffix}",
+      locals: { collection: collection, handler: handler, scope: scope.to_sym }
+    )
+  end
+
+  # @param [ApplicationRecord] entity
+  # @param [Symbol|String|nil] scope
+  def entity_toggle(entity, scope: nil)
+    scope = controller.class.module_parent_name.to_s.downcase if scope.nil?
+
+    render(
+      partial: 'shared/entity/toggle',
+      locals: { entity: entity, scope: scope.to_sym }
+    )
+  end
+
+  # @param [ApplicationRecord] entity
+  # @param [Symbol|String|nil] scope
+  def entity_priority_icons(entity, scope: nil)
+    scope = controller.class.module_parent_name.to_s.downcase if scope.nil?
+
+    render(
+      partial: 'shared/entity/priority_icons',
+      locals: { entity: entity, scope: scope.to_sym }
+    )
+  end
+
+  # @param [ApplicationRecord] entity
+  # @param [String] text
+  def linked_entity_block(entity, text: nil)
+    return '' if entity.blank?
+
+    render(
+      partial: 'shared/entity/linked_entity',
+      locals: { entity: entity, text: text }
+    )
+  end
+
+  # @param [ApplicationRecord] entity
+  # @param [String|Symbol] types
+  def entity_partial_block(entity, *types)
+    permitted = %i[
+      priority uuid slug timestamps language simple_image meta_texts track
+    ]
+
+    buffer = ''
+    types.select { |i| permitted.include?(i.to_sym)}.each do |type|
+      buffer += render(partial: "shared/entity/#{type}", locals: { entity: entity })
+    end
+
+    raw buffer
+  end
+
+  def entity_form_block(f, *types)
+    permitted = %i[priority entity_flags simple_image]
+
+    buffer = ''
+    types.select { |i| permitted.include?(i.to_sym)}.each do |type|
+      buffer += render partial: "shared/forms/#{type}", locals: { f: f }
+    end
+
+    raw buffer
+  end
+end

data/app/helpers/my_helper.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Helper methods for user context
+module MyHelper
+  # @param [ApplicationRecord] entity
+  # @param [Hash] options
+  def my_edit_icon(entity, options = {})
+    title = options.delete(:title) { t(:edit) }
+    key = entity.respond_to?(:uuid) ? entity.uuid : entity.id
+    path = "/my/#{entity.class.table_name}/#{key}/edit"
+    my_icon_with_link('biovision/icons/edit.svg', path, title.to_s, options)
+  end
+
+  # @param [ApplicationRecord] entity
+  # @param [Hash] options
+  def my_destroy_icon(entity, options = {})
+    title = options.delete(:title) { t(:edit) }
+    key = entity.respond_to?(:uuid) ? entity.uuid : entity.id
+    path = "/my/#{entity.class.table_name}/#{key}"
+    default = {
+      class: 'danger',
+      data: { confirm: t(:are_you_sure) },
+      method: :delete,
+    }
+    my_icon_with_link('biovision/icons/destroy.svg', path, title.to_s, default.merge(options))
+  end
+
+  # @param [String|ApplicationRecord] path
+  # @param [String] title
+  # @param [Hash] options
+  def my_icon_with_link(source, path, title = '', options = {})
+    link_to(image_tag(source, alt: title), path, options)
+  end
+end

data/app/helpers/simple_image_helper.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+# Helper methods for displaying versions for SimpleImageUploader
+module SimpleImageHelper
+  # Tiny (48x48) version of simple image
+  #
+  # @param [ApplicationRecord|SimpleImageUploader] entity
+  # @param [Hash] options
+  def simple_image_tiny(entity, options = {})
+    return '' if entity.nil?
+
+    image = entity.is_a?(SimpleImageUploader) ? entity : entity.image
+    default_image = options.delete(:default_image).to_s
+
+    return default_image if image.blank?
+
+    default = {
+      alt: image.alt_text,
+      load: 'lazy'
+    }
+    image_tag(image.tiny_url, default.merge(options))
+  end
+
+  # Preview (160x160) version of simple image
+  #
+  # @param [ApplicationRecord|SimpleImageUploader] entity
+  # @param [Hash] options
+  def simple_image_preview(entity, options = {})
+    return '' if entity.nil?
+
+    image = entity.is_a?(SimpleImageUploader) ? entity : entity.image
+    default_image = options.delete(:default_image).to_s
+
+    return default_image if image.blank?
+
+    default = {
+      alt: image.alt_text,
+      load: 'lazy'
+    }
+    image_tag(image.preview_url, default.merge(options))
+  end
+
+  # Small (320x320) version of simple image
+  #
+  # @param [ApplicationRecord|SimpleImageUploader] entity
+  # @param [Hash] options
+  def simple_image_small(entity, options = {})
+    return '' if entity.nil?
+
+    image = entity.is_a?(SimpleImageUploader) ? entity : entity.image
+    default_image = options.delete(:default_image).to_s
+
+    return default_image if image.blank?
+
+    default = {
+      alt: image.alt_text,
+      load: 'lazy'
+    }
+    default[:srcset] = "#{image.medium.url} 2x" if image.raster?
+
+    image_tag(image.small_url, default.merge(options))
+  end
+
+  # Medium (640x640) version of simple image
+  #
+  # @param [ApplicationRecord|SimpleImageUploader] entity
+  # @param [Hash] options
+  def simple_image_medium(entity, options = {})
+    return '' if entity.nil?
+
+    image = entity.is_a?(SimpleImageUploader) ? entity : entity.image
+    default_image = options.delete(:default_image).to_s
+
+    return default_image if image.blank?
+
+    default = {
+      alt: image.alt_text,
+      load: 'lazy'
+    }
+    default[:srcset] = "#{image.large.url} 2x" if image.raster?
+
+    image_tag(image.medium_url, default.merge(options))
+  end
+
+  # Large (1280x1280) version of simple image
+  #
+  # @param [ApplicationRecord|SimpleImageUploader] entity
+  # @param [Hash] options
+  def simple_image_large(entity, options = {})
+    return '' if entity.nil?
+
+    image = entity.is_a?(SimpleImageUploader) ? entity : entity.image
+    default_image = options.delete(:default_image).to_s
+
+    return default_image if image.blank?
+
+    default = {
+      alt: image.alt_text,
+      load: 'lazy'
+    }
+    default[:srcset] = "#{image.hd.url} 2x" if image.raster?
+
+    image_tag(image.large_url, default.merge(options))
+  end
+
+  # HD (1920x1920) version of simple image
+  #
+  # @param [ApplicationRecord|SimpleImageUploader] entity
+  # @param [Hash] options
+  def simple_image_hd(entity, options = {})
+    return '' if entity.nil?
+
+    image = entity.is_a?(SimpleImageUploader) ? entity : entity.image
+    default_image = options.delete(:default_image).to_s
+
+    return default_image if image.blank?
+
+    default = {
+      alt: image.alt_text,
+      load: 'lazy'
+    }
+
+    image_tag(image.hd_url, default.merge(options))
+  end
+end

data/app/jobs/application_job.rb

@@ -0,0 +1,7 @@
+class ApplicationJob < ActiveJob::Base
+  # Automatically retry jobs that encountered a deadlock
+  # retry_on ActiveRecord::Deadlocked
+
+  # Most jobs are safe to ignore if the underlying records are no longer available
+  # discard_on ActiveJob::DeserializationError
+end

data/app/jobs/send_phone_confirmation_job.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Send phone confirmation code via SMS gateway
+class SendPhoneConfirmationJob < ApplicationJob
+  queue_as :default
+
+  # @param [Integer] id
+  def perform(id)
+    code = Code.find_by(id: id)
+
+    return if code.nil?
+
+    # To be implemented: use actual gateway
+    code.user.phone
+  end
+end

data/app/lib/biovision/components/base/component_parameters.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Biovision
+  module Components
+    module Base
+      # Getting and setting component parameters
+      module ComponentParameters
+        def use_parameters?
+          false
+        end
+
+        def use_files?
+          false
+        end
+
+        def manage_settings?
+          use_parameters? || component.settings.any?
+        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.get(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]
+        def [](key)
+          @component.get(key, nil)
+        end
+
+        # Set parameter
+        #
+        # @param [String] key
+        # @param [String] value
+        def []=(key, value)
+          return if key.blank?
+
+          @component.parameters[key.to_s] = value
+          @component.save!
+        end
+      end
+    end
+  end
+end

data/app/lib/biovision/components/base/component_privileges.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Biovision
+  module Components
+    module Base
+      # Handling component privileges
+      module ComponentPrivileges
+        # @param [String] action
+        # @param [Object] context
+        def permit?(action = 'default', context = nil)
+          return false if user.nil?
+
+          parts = [slug]
+          model = model_from_context(context)
+          parts << model.table_name if model.respond_to?(:table_name)
+          parts << action
+          owner?(context) || role?(parts.join('.')) || role?("#{slug}.all")
+        end
+
+        # @param [ApplicationRecord|nil] entity
+        def owner?(entity)
+          return false unless entity.respond_to?(:owned_by?)
+
+          entity.owned_by?(user)
+        end
+
+        # @param [String] role_name
+        def role?(role_name)
+          return false if user.nil?
+          return true if user.super_user?
+
+          role = Role[role_name]
+          return false if role.nil?
+
+          user.role_ids.include?(role.id)
+        end
+
+        # @param [Class|Object] context
+        # @return Class
+        def model_from_context(context)
+          context.is_a?(Class) ? context : context.class
+        end
+
+        def crud_table_names
+          tables = administrative_parts
+          tables << 'simple_images' if use_images?
+          tables << 'uploaded_files' if use_files?
+          tables
+        end
+
+        def role_tree
+          tree = { nil => %w[all default view] }
+          tree['settings'] = %w[view edit] if use_settings?
+          crud_table_names.each do |table_name|
+            tree[table_name] = %w[view edit]
+          end
+          tree
+        end
+
+        def create_roles
+          role_tree.each do |prefix, postfixes|
+            postfixes.each do |postfix|
+              slug = prefix.blank? ? postfix : "#{prefix}.#{postfix}"
+              Role.create(biovision_component: component, slug: slug)
+            end
+          end
+        end
+
+        def administrative_parts
+          self.class.dependent_models.map(&:table_name)
+        end
+      end
+    end
+  end
+end

data/app/lib/biovision/components/base/component_settings.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Biovision
+  module Components
+    module Base
+      # Normalizing component settings
+      module ComponentSettings
+        def settings_flags
+          []
+        end
+
+        def settings_numbers
+          []
+        end
+
+        def settings_strings
+          []
+        end
+
+        def default_settings
+          {}
+        end
+
+        def reset_settings
+          BiovisionComponent[slug]&.update(settings: default_settings)
+        end
+
+        # @param [Hash] data
+        def normalize_settings(data)
+          result = {}
+          settings_flags.each { |f| result[f] = data[f].to_i == 1 }
+          settings_numbers.each { |n| result[n] = data[n].to_i }
+          settings_strings.each { |s| result[s] = data[s].to_s }
+
+          result
+        end
+      end
+    end
+  end
+end

data/app/lib/biovision/components/base/component_stories.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Biovision
+  module Components
+    module Base
+      # Methods for handling component stories
+      module ComponentStories
+        # @param [String] story_slug
+        def story_class(story_slug)
+          namespace = "biovision/components/#{self.class.slug}"
+          handler_name = "#{namespace}/stories/#{story_slug}_story".classify
+          handler_name.safe_constantize || Biovision::Stories::ComponentStory
+        end
+
+        # @param [String] story_slug
+        # @param [ApplicationRecord|nil] entity
+        def story(story_slug, entity = nil)
+          story_class(story_slug).new(self, entity)
+        end
+
+        # @param [String] story_slug
+        # @param [Hash] story_parameters
+        # @param [ApplicationRecord|String|nli] entity
+        def perform_story(story_slug, story_parameters, entity = nil)
+          story(story_slug, entity).perform(story_parameters)
+        end
+      end
+    end
+  end
+end

data/app/lib/biovision/components/base/entity_links.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Biovision
+  module Components
+    module Base
+      # Links for entities in context of current user
+      module EntityLinks
+        # @param [ApplicationRecord] entity
+        def text_for_link(entity)
+          entity.respond_to?(:text_for_link) ? entity.text_for_link : entity.id
+        end
+
+        # @param [ApplicationRecord] entity
+        # @param [Symbol|String] scope
+        def entity_link(entity, scope = '')
+          prefix = %i[admin my].include?(scope.to_sym) ? scope : 'world'
+          message = "#{prefix}_url".to_sym
+          if entity.respond_to?(message)
+            entity.send(message)
+          else
+            rest_entity_link(entity, scope.to_sym)
+          end
+        end
+
+        # @param [ApplicationRecord] entity
+        # @param [Symbol] scope
+        def rest_entity_link(entity, scope)
+          collection = "/#{scope}/#{entity.class.table_name}".gsub('//', '/')
+          if entity.attributes.key?('uuid') && scope != :admin
+            "#{collection}/#{entity.uuid}"
+          else
+            "#{collection}/#{entity.id}"
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/biovision/components/base/image_handling.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Biovision
+  module Components
+    module Base
+      # Handling simple images
+      module ImageHandling
+        def use_images?
+          false
+        end
+
+        # @param [Hash] parameters
+        def upload_image(parameters)
+          return if parameters[:image].blank?
+
+          checksum = Digest::SHA256.file(parameters[:image].path).hexdigest
+          SimpleImage[checksum] || create_image(parameters, checksum)
+        end
+
+        private
+
+        # @param [Hash] parameters
+        # @param [String] checksum
+        def create_image(parameters, checksum)
+          image = component.simple_images.new(parameters)
+          image.data[SimpleImage::ORIGINAL_CHECKSUM] = checksum
+          image.save
+          image
+        end
+      end
+    end
+  end
+end