biovision 0.0.200518.1 → 0.12.211124.0

data/app/controllers/concerns/toggleable_entity.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# Adds method for toggling entity flags
+module ToggleableEntity
+  extend ActiveSupport::Concern
+
+  # Toggle entity flag when allowed
+  def toggle
+    if entity_is_locked?
+      render json: { errors: { locked: true } }, status: :forbidden
+    elsif entity_is_editable?
+      render json: { data: @entity.toggle_parameter(params[:parameter].to_s) }
+    else
+      head :unauthorized
+    end
+  end
+
+  private
+
+  def entity_is_editable?
+    if @entity.respond_to?(:editable_by?)
+      @entity.editable_by?(current_user)
+    else
+      true
+    end
+  end
+
+  def entity_is_locked?
+    @entity.respond_to?(:locked?) ? @entity.locked? : false
+  end
+end

data/app/controllers/contact_controller.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# Contact and feedback
+class ContactController < ApplicationController
+  # get /contact
+  def index
+    @dynamic_page = DynamicPage['contact']
+  end
+
+  # get /contact/feedback
+  def feedback
+    @dynamic_page = DynamicPage['feedback']
+  end
+
+  # post /contact/feedback_messages
+  def create_feedback_message
+    @entity = FeedbackMessage.new(creation_parameters)
+    if params[:agree]
+      show_result
+    else
+      save_entity
+    end
+  end
+
+  private
+
+  def save_entity
+    if @entity.save
+      show_result
+      FeedbackMailer.new_feedback_request(@entity.id).deliver_later
+    else
+      redirect_to root_path
+    end
+  end
+
+  def show_result
+    respond_to do |format|
+      format.html { redirect_to root_path }
+      format.json { head :no_content }
+      format.js
+    end
+  end
+
+  def creation_parameters
+    permitted = FeedbackMessage.entity_parameters
+    parameters = params.require(:feedback_message).permit(permitted)
+    parameters.merge(owner_for_entity(true))
+  end
+end

data/app/controllers/errors_controller.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# Errors
+class ErrorsController < ApplicationController
+  before_action :set_message
+
+  # get /400
+  def bad_request
+    render :error
+  end
+
+  # get /401
+  def unauthorized
+    render :error
+  end
+
+  # get /403
+  def forbidden
+    render :error
+  end
+
+  # get /422
+  def unprocessable_entity
+    render :error
+  end
+
+  # get /500
+  def internal_server_error
+    render :error
+  end
+
+  private
+
+  def set_message
+    @message = t("application.errors.#{action_name}")
+  end
+end

data/app/controllers/fallback_controller.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# Fallback controller for URL outside router
+class FallbackController < ApplicationController
+  # get (:slug)
+  def show
+    url = params[:slug]
+
+    @dynamic_page = DynamicPage.find_by(url: "/#{url}")
+    handle_http_404 if @dynamic_page.nil?
+  end
+end

data/app/controllers/index_controller.rb

@@ -4,5 +4,6 @@
 class IndexController < ApplicationController
   # get /
   def index
+    @dynamic_page = DynamicPage['frontpage']
   end
 end

data/app/controllers/legal_controller.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Legal information
+class LegalController < ApplicationController
+  # get /tos
+  def tos
+    @dynamic_page = DynamicPage['tos']
+  end
+
+  # get /privacy
+  def privacy
+    @dynamic_page = DynamicPage['privacy']
+  end
+end

data/app/controllers/my/components_controller.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# User-side component handling
+class My::ComponentsController < ProfileController
+  before_action :restrict_component_access, except: :index
+
+  # get /my/components
+  def index
+    @collection = BiovisionComponent.list_for_user
+  end
+
+  # get /my/components/:slug
+  def show
+  end
+
+  private
+
+  def restrict_component_access
+    slug = params[:slug]
+    @handler = Biovision::Components::BaseComponent.handler(slug, current_user)
+    role_name = "#{@handler.slug}.default"
+    error = t('admin.errors.unauthorized.missing_role', role: role_name)
+
+    handle_http_401(error) unless @handler.permit?(role_name)
+  end
+end

data/app/controllers/my/confirmations_controller.rb

@@ -1,2 +1,46 @@
+# frozen_string_literal: true
+
+# Sending and checking email confirmation codes
 class My::ConfirmationsController < ApplicationController
+  include Authentication
+
+  before_action :redirect_confirmed_user, only: %i[create update]
+
+  # get /my/confirmation
+  def show
+  end
+
+  # post /my/confirmation
+  def create
+    if current_user.email.blank?
+      redirect_to edit_my_profile_path, notice: t('.set_email')
+    else
+      component_handler.send_email_confirmation(current_user)
+
+      redirect_to my_confirmation_path, notice: t('.success')
+    end
+  end
+
+  # patch /my/confirmation
+  def update
+    code = Code.find_by(body: param_from_request(:code))
+    if component_handler.valid_email_confirmation?(code)
+      component_handler.activate_email_confirmation(code)
+      create_token_for_user(code.user)
+      redirect_to my_path
+    else
+      flash[:error] = t('.invalid_code')
+      redirect_to my_confirmation_path
+    end
+  end
+
+  protected
+
+  def component_class
+    Biovision::Components::UsersComponent
+  end
+
+  def redirect_confirmed_user
+    redirect_to(my_path) if current_user&.email_confirmed?
+  end
 end

data/app/controllers/my/index_controller.rb

@@ -1,8 +1,14 @@
 # frozen_string_literal: true
 
 # Main page for user
-class My::IndexController < ApplicationController
+class My::IndexController < ProfileController
   # get /my
   def index
   end
+
+  private
+
+  def component_class
+    Biovision::Components::UsersComponent
+  end
 end

data/app/controllers/my/profiles_controller.rb

@@ -3,25 +3,30 @@
 # Managing profile for current user
 class My::ProfilesController < ApplicationController
   include Authentication
+  include ProcessedForms
+  include RestrictedAccess
 
   before_action :redirect_authorized_user, only: %i[new create]
   before_action :restrict_anonymous_access, except: %i[check new create]
 
   # post /my/profile/check
   def check
-    @entity = User.new(creation_parameters)
+    code = Code.active.find_by(body: param_from_request(:code))
+    registration_handler.check(creation_parameters.to_h, code)
   end
 
   # get /my/profile/new
   def new
     @entity = User.new
 
-    render :closed unless component_handler.settings['registration_open']
+    render :closed unless component_handler.registration_open?
   end
 
   # post /my/profile
   def create
     if params[:agree]
+      metric = Biovision::Components::UsersComponent::METRIC_REGISTRATION_BOT
+      component_handler.register_metric(metric)
       redirect_to root_path, alert: t('.are_you_bot')
     else
       create_user
@@ -39,7 +44,7 @@ class My::ProfilesController < ApplicationController
   # patch /my/profile
   def update
     @entity = current_user
-    if @entity.update(user_parameters)
+    if component_handler.update_user(@entity, user_parameters, profile_parameters)
       flash[:notice] = t('.success')
       form_processed_ok(my_path)
     else
@@ -47,7 +52,7 @@ class My::ProfilesController < ApplicationController
     end
   end
 
-  protected
+  private
 
   def component_class
     Biovision::Components::UsersComponent
@@ -57,17 +62,20 @@ class My::ProfilesController < ApplicationController
     redirect_to my_path if current_user.is_a?(User)
   end
 
+  def registration_handler
+    handler_class = Biovision::Components::Users::RegistrationHandler
+    @registration_handler ||= handler_class.new(component_handler)
+  end
+
   def create_user
     code = Code.active.find_by(body: param_from_request(:code))
-    @entity = component_handler.register_user(creation_parameters, code)
+    registration_handler.handle(creation_parameters.to_h, code)
+    @entity = registration_handler.user
 
     if @entity.persisted?
-      create_token_for_user(@entity)
-      cookies.delete('r', domain: :all)
-
-      redirect_after_creation
+      user_created
     else
-      form_processed_with_error(:new)
+      form_processed_with_error(:new, @entity.errors.full_messages)
     end
   end
 
@@ -85,13 +93,12 @@ class My::ProfilesController < ApplicationController
     sensitive = sensitive_parameters
     editable = User.profile_parameters + sensitive
     parameters = params.require(:user).permit(editable)
-    new_data = @entity.data.merge(profile: profile_parameters)
 
-    filter_parameters(parameters.merge(data: new_data), sensitive)
+    filter_parameters(parameters.to_h, sensitive)
   end
 
   def sensitive_parameters
-    if current_user.authenticate params[:password].to_s
+    if current_user.authenticate param_from_request(:password)
       User.sensitive_parameters
     else
       []
@@ -99,9 +106,12 @@ class My::ProfilesController < ApplicationController
   end
 
   def profile_parameters
-    permitted = UserProfileHandler.allowed_parameters
-    dirty = params.require(:user_profile).permit(permitted)
-    UserProfileHandler.clean_parameters(dirty)
+    if params.key?(:profile)
+      list = Biovision::Components::Users::ProfileHandler.permitted_for_request
+      params.require(:profile).permit(list)
+    else
+      {}
+    end
   end
 
   # @param [Hash] parameters
@@ -118,6 +128,13 @@ class My::ProfilesController < ApplicationController
     parameters
   end
 
+  def user_created
+    create_token_for_user(@entity)
+    cookies.delete('r', domain: :all)
+
+    redirect_after_creation
+  end
+
   def redirect_after_creation
     return_path = cookies['return_path'].to_s
     return_path = my_profile_path unless return_path[0] == '/'

data/app/controllers/oembed_controller.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# Receiving oembed data by URLs
+class OembedController < ApplicationController
+  # get /oembed?url=
+  def code
+    url = param_from_request(:url)
+    receiver = Biovision::Components::Content::Oembed::Receiver[url]
+
+    render json: { meta: { code: receiver.code } }
+  end
+end

data/app/controllers/profile_controller.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Controllers for logged-in users only
+class ProfileController < ApplicationController
+  include RestrictedAccess
+
+  before_action :restrict_access
+
+  protected
+
+  def restrict_access
+    restrict_anonymous_access
+  end
+end

data/app/controllers/users_controller.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+# Users for visitors
+class UsersController < ApplicationController
+  include RestrictedAccess
+
+  before_action :restrict_anonymous_access, only: %i[ban follow unban unfollow]
+  before_action :set_socialization, only: %i[ban follow unban unfollow]
+  before_action :set_entity
+
+  # get /u/:slug
+  def show
+  end
+
+  # get /u/:slug/followees
+  def followees
+    @filter     = params[:filter] || Hash.new
+    @collection = UserLink.filtered(:followee, @filter).with_follower(@entity).page_for_user(current_page)
+  end
+
+  # put /u/:slug/follow
+  def follow
+    @socialization.follow(@entity)
+
+    head :no_content
+  end
+
+  # delete /u/:slug/follow
+  def unfollow
+    @socialization.unfollow(@entity)
+
+    head :no_content
+  end
+
+  # put /u/:slug/ban
+  def ban
+    @socialization.ban(@entity)
+
+    head :no_content
+  end
+
+  # delete /u/:slug/ban
+  def unban
+    @socialization.unban(@entity)
+
+    head :no_content
+  end
+
+  private
+
+  def component_class
+    Biovision::Components::UsersComponent
+  end
+
+  def set_socialization
+    @socialization = Biovision::Components::SocializationComponent[current_user]
+  end
+
+  def set_entity
+    @entity = User.find_by(slug: params[:slug].downcase, deleted: false)
+    handle_http_404('Cannot find user') if @entity.nil?
+  end
+end

data/app/helpers/biovision_components_helper.rb

@@ -6,9 +6,13 @@ module BiovisionComponentsHelper
   # @param [String] text
   # @param [Hash] options
   def admin_biovision_component_link(entity, text = nil, options = {})
-    if text.nil?
-      text = t("biovision.components.#{entity.slug}.name", default: entity.slug)
-    end
+    text ||= component_name(entity.slug)
     link_to(text, admin_component_path(slug: entity.slug), options)
   end
+
+  # @param [String|BiovisionComponent] slug
+  def component_name(slug)
+    slug = slug.respond_to?(:slug) ? slug.slug : slug
+    t("biovision.components.#{slug}.name", default: slug)
+  end
 end

data/app/helpers/biovision_helper.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+# Helper methods for common cases
+module BiovisionHelper
+  # @param [ApplicationRecord] entity
+  # @param [Biovision::Components::BaseComponent] handler
+  # @param [Hash] options
+  def admin_entity_link(entity, handler: nil, **options)
+    return '∅' if entity.nil?
+
+    component = (handler || component_handler)
+    text = options.delete(:text) { component.text_for_link(entity) }
+
+    if handler.nil? || handler.permit?('view', entity)
+      href = component.entity_link(entity, :admin)
+      link_to(text, href, options)
+    else
+      text
+    end
+  end
+
+  # @param [ApplicationRecord] entity
+  # @param [Hash] options
+  def my_entity_link(entity, **options)
+    return '∅' if entity.nil?
+
+    handler = Biovision::Components::BaseComponent[]
+    text = options.delete(:text) { handler.text_for_link(entity) }
+    href = handler.entity_link(entity, :my)
+
+    link_to(text, href, options)
+  end
+
+  # @param [ApplicationRecord] entity
+  # @param [Hash] options
+  def entity_link(entity, **options)
+    return '' if entity.nil?
+    return '' if entity.respond_to?(:visible?) && !entity.visible?
+
+    handler = Biovision::Components::BaseComponent[]
+    text = options.delete(:text) { handler.text_for_link(entity) }
+    href = handler.entity_link(entity)
+
+    link_to(text, href, options)
+  end
+
+  # @param [Hash] options
+  def my_home_link(options = {})
+    link_to(t('my.index.index.nav_text'), my_path, options)
+  end
+
+  # @param [String|ApplicationRecord] path
+  # @param [String] title
+  # @param [Hash] options
+  def world_icon(path, title = t(:view_as_visitor), options = {})
+    if path.is_a? ApplicationRecord
+      return '' if path.respond_to?(:visible?) && !path.visible?
+
+      table_name = path.class.table_name
+      path = path.respond_to?(:world_url) ? path.world_url : "/#{table_name}/#{path.id}"
+    end
+    icon_with_link('biovision/icons/world.svg', path, title, options)
+  end
+
+  # @param [String|ApplicationRecord] path
+  # @param [String] title
+  # @param [Hash] options
+  def gear_icon(path, title = t(:view_settings), options = {})
+    path = "/admin/#{path.class.table_name}/#{path.id}" if path.is_a? ApplicationRecord
+    icon_with_link('biovision/icons/gear.svg', path, title, options)
+  end
+
+  # @param [String] path
+  # @param [String] title
+  # @param [Hash] options
+  def create_icon(path, title = t(:create), options = {})
+    icon_with_link('biovision/icons/create.svg', path, title, options)
+  end
+
+  # @param [String] path
+  # @param [String] title
+  # @param [Hash] options
+  def back_icon(path, title = t(:back), options = {})
+    icon_with_link('biovision/icons/back.svg', path, title, options)
+  end
+
+  # @param [String] path
+  # @param [String] title
+  # @param [Hash] options
+  def return_icon(path, title = t(:back), options = {})
+    icon_with_link('biovision/icons/return.svg', path, title, options)
+  end
+
+  # @param [String|ApplicationRecord] path
+  # @param [String] title
+  # @param [Hash] options
+  def edit_icon(path, title = t(:edit), options = {})
+    path = "/admin/#{path.class.table_name}/#{path.id}/edit" if path.is_a? ApplicationRecord
+    icon_with_link('biovision/icons/edit.svg', path, title, options)
+  end
+
+  # @param [String|ApplicationRecord] path
+  # @param [String] title
+  # @param [Hash] options
+  def destroy_icon(path, title = t(:delete), options = {})
+    path = "/admin/#{path.class.table_name}/#{path.id}" if path.is_a? ApplicationRecord
+    default = {
+      class: 'danger',
+      data: { confirm: t(:are_you_sure) },
+      method: :delete,
+    }
+    icon_with_link('biovision/icons/destroy.svg', path, title, default.merge(options))
+  end
+
+  # @param [String|ApplicationRecord] path
+  # @param [String] title
+  # @param [Hash] options
+  def icon_with_link(source, path, title, options = {})
+    link_to(image_tag(source, alt: title), path, options)
+  end
+
+  # @param [String] path
+  # @param [String] text
+  def create_button(path, text = t(:create))
+    link_to(text, path, class: 'button button-save')
+  end
+
+  # @param [String|ApplicationRecord] path
+  # @param [String] text
+  def edit_button(path, text = t(:edit))
+    path = "/admin/#{path.class.table_name}/#{path.id}/edit" if path.is_a? ApplicationRecord
+    link_to(text, path, class: 'button button-secondary')
+  end
+
+  # @param [String|ApplicationRecord] path
+  # @param [String] text
+  def destroy_button(path, text = t(:delete))
+    path = "/admin/#{path.class.table_name}/#{path.id}" if path.is_a? ApplicationRecord
+    options = {
+      class: 'button button-danger',
+      data: { confirm: t(:are_you_sure) },
+      method: :delete
+    }
+    link_to(text, path, options)
+  end
+
+  # @param [String] phone
+  # @param [Hash] options
+  def phone_link(phone, options = {})
+    link_to(phone, "tel:#{phone.gsub(/[^+0-9]/, '')}", options)
+  end
+
+  # @param [String] email
+  # @param [Hash] options
+  def email_link(email, options = {})
+    link_to(email, "mailto:#{email}", options)
+  end
+
+  # @param [ApplicationRecord] entity
+  # @deprecated use #entity_priority_icons
+  def admin_priority_icons(entity)
+    render(partial: 'shared/admin/priority', locals: { entity: entity })
+  end
+
+  # @param [ApplicationRecord] entity
+  # @deprecated use #entity_toggle
+  def admin_toggle_block(entity)
+    render(partial: 'shared/admin/toggle', locals: { entity: entity })
+  end
+end