elabs 4.0.0 → 5.0.0

data/app/helpers/elabs/form_helper.rb

@@ -1,28 +1,28 @@
 module Elabs
   module FormHelper
     def album_selector(form, field = :album_ids, multiple: true)
-      form.select field, Elabs::Album.by_member(current_user).for_list, {},
-                  multiple: multiple, id: selector_id(form, field)
+      relation_selector(form, field, Elabs::Album.by_member(current_user).for_list, multiple)
     end
 
     def language_selector(form, field = :language_id, multiple: false)
-      form.select field, Elabs::Language.for_list, {},
-                  multiple: multiple, id: selector_id(form, field)
+      relation_selector(form, field, Elabs::Language.for_list, multiple)
     end
 
     def license_selector(form, field = :license_id, multiple: false)
-      form.select field, Elabs::License.for_list, {},
-                  multiple: multiple, id: selector_id(form, field)
+      relation_selector(form, field, Elabs::License.for_list, multiple)
     end
 
-    def project_selector(form, field = :project_ids, multiple: true)
-      form.select field, Elabs::Project.by_member(current_user).for_list, {},
-                  multiple: multiple, id: selector_id(form, field)
+    def projects_selector(form, field = :project_ids, multiple: true)
+      relation_selector(form, field, Elabs::Project.by_member(current_user).for_list, multiple)
     end
 
     def uploads_selector(form, field = :upload_ids, multiple: true)
-      form.select field, Elabs::Upload.by_member(current_user).for_list, {},
-                  multiple: multiple, id: selector_id(form, field)
+      relation_selector(form, field, Elabs::Upload.by_member(current_user).for_list, multiple)
+    end
+
+    def relation_selector(form, field, values, multiple = false)
+      input_class = multiple ? 'is-multiple' : ''
+      form.select field, values, {}, multiple: multiple, id: selector_id(form, field), class: input_class
     end
 
     private

data/app/helpers/elabs/icons_helper.rb

@@ -0,0 +1,63 @@
+module Elabs
+  module IconsHelper
+    CONTENT_TYPE_ICONS = {
+      'Elabs::Album':   'book',
+      'Elabs::Article': 'font',
+      'Elabs::Note':    'sticky-note',
+      'Elabs::Project': 'cog',
+      'Elabs::Upload':  'file'
+    }.freeze
+
+    def icon_text(icon, text, icon_options = [], reverse = false)
+      format(
+        reverse ? _('%<text>s %<icon>s') : _('%<icon>s %<text>s'),
+        icon: icon(icon, icon_options), text: text
+      ).html_safe
+    end
+
+    def boolean_icon_tag(value, true_icon = 'check', false_icon = 'times', false_class = '', true_class = '')
+      icon_class = [
+        "fas fa-#{value ? true_icon : false_icon} fa-fw #{value ? true_class : false_class}"
+      ]
+      content_tag(:i, nil, class: icon_class)
+    end
+
+    def colored_good_or_bad_icon_tag(value, true_icon = 'check', false_icon = 'times', false_is_good = false)
+      if false_is_good
+        false_class = 'is-success'
+        true_class  = 'is-danger'
+      else
+        false_class = 'is-danger'
+        true_class  = 'is-success'
+      end
+      boolean_icon_tag value, true_icon, false_icon, false_class, true_class
+    end
+
+    def icon(name, classes = [], base = 'fas', pack = 'fa')
+      icon_class = ["#{base} #{pack || base}-#{name}"]
+      icon_class += classes.map do |c|
+        if %w[2x 3x 4x fw pulse spin].include? c
+          "#{pack || base}-#{c}"
+        else
+          c
+        end
+      end
+
+      content_tag(:i, nil, class: icon_class)
+    end
+
+    def license_icon(license, classes = ['fw'])
+      icon license.icon, classes, 'li', 'li'
+    end
+
+    def content_type_icon(type, options)
+      type_icon = CONTENT_TYPE_ICONS.key?(type) ? CONTENT_TYPE_ICONS[type] : 'question'
+      icon type_icon, options
+    end
+
+    def content_type_icon_from_entity(entity, options)
+      type = entity.class.name.to_sym
+      content_type_icon type, options
+    end
+  end
+end

data/app/helpers/elabs/{admin_content_helper.rb → links_admin_helper.rb}

@@ -1,5 +1,5 @@
 module Elabs
-  module AdminContentHelper
+  module LinksAdminHelper
     def admin_action_links(singular_model, entity)
       out = []
       out.push(show_online_link(entity))

data/app/helpers/elabs/links_helper.rb

@@ -0,0 +1,58 @@
+module Elabs
+  module LinksHelper
+    def show_online_link(entity)
+      options = {
+        title: _('View online'),
+        class: 'btn btn--small btn--show'
+      }
+      if entity.respond_to?(:publicly_visible?) && !entity.publicly_visible?
+        options[:disabled] = true
+        return content_tag 'a', icon('eye', ['fw']), options
+      end
+      link_to entity, options do
+        icon('eye', ['fw'])
+      end
+    end
+
+    def namespace_show_link(namespace, singular_model, entity)
+      link_to send("#{namespace}_#{singular_model}_path", entity),
+              title: _('View'),
+              class: 'btn btn--small btn--warning' do
+        icon('eye', ['fw'])
+      end
+    end
+
+    def namespace_edit_link(namespace, singular_model, entity)
+      link_to send("edit_#{namespace}_#{singular_model}_path", entity),
+              title: _('Edit'),
+              class: 'btn btn--small btn--edit' do
+        icon('pencil-alt', ['fw'])
+      end
+    end
+
+    def namespace_destroy_link(namespace, singular_model, entity, confirm = true)
+      link_params = {
+        title:  _('Destroy'),
+        method: :delete,
+        class:  'btn btn--small btn--destroy'
+      }
+      link_params[:data] = { confirm: _('Are you sure?') } if confirm
+      link_to send("#{namespace}_#{singular_model}_path".to_sym, entity), link_params do
+        icon('trash', ['fw'])
+      end
+    end
+
+    def entity_nested_resource_url(entity, nested_type)
+      entity_type = singular_type_name entity
+      send "#{entity_type}_#{nested_type}_url", entity
+    end
+
+    def related_content_show_all_link(amount, link)
+      if amount.positive?
+        link_to(_('Show all'), link, class: 'btn btn--small btn--link btn--primary')
+      else
+        content_tag('a', _('Show all'), disabled: true, class: 'btn btn--small btn--link')
+      end
+    end
+  end
+end

data/app/helpers/elabs/{member_content_helper.rb → links_member_helper.rb}

@@ -1,5 +1,5 @@
 module Elabs
-  module MemberContentHelper
+  module LinksMemberHelper
     def member_action_links(singular_model, entity)
       out = []
       out.push show_online_link(entity)
@@ -22,7 +22,7 @@ module Elabs
       link_to send("member_#{singular_model}_toggle_publication_path", entity),
               title:  entity.published? ? _('Unpublish') : _('Publish'),
               method: :put,
-              class:  'btn btn--small btn--' do
+              class:  'btn btn--small' do
         icon(entity.published? ? 'calendar-times' : 'calendar-check', ['fw'])
       end
     end

data/app/helpers/elabs/notification_helper.rb

@@ -48,20 +48,34 @@ module Elabs
       link = case notification.content_type
              when 'Elabs::Report'
                admin_reports_path
+             when 'Elabs::Comment'
+               url_for notification.content.content
              else
                notification.content
              end
-      link_to("##{notification.content_id}", link).html_safe
+      title = notification_link_title notification
+
+      link_to(title, link).html_safe
+    end
+
+    def notification_link_title(notification)
+      case notification.content_type
+      when 'Elabs::Comment'
+        notification.content.content.title_to_display
+      else
+        "##{notification.content_id}"
+      end
     end
 
     def notification_string(notification)
       strings = {
-        'Elabs::Album' => _('%<user>s %<action>s your album %<link>s'),
+        'Elabs::Album'   => _('%<user>s %<action>s your album %<link>s'),
         'Elabs::Article' => _('%<user>s %<action>s your article %<link>s'),
         'Elabs::Note'    => _('%<user>s %<action>s your note %<link>s'),
         'Elabs::Project' => _('%<user>s %<action>s your project %<link>s'),
         'Elabs::Upload'  => _('%<user>s %<action>s your file %<link>s'),
-        'Elabs::Report'  => _('%<user>s %<action>s %<link>s')
+        'Elabs::Report'  => _('%<user>s %<action>s %<link>s'),
+        'Elabs::Comment' => _('%<user>s %<action>s %<link>s')
       }.freeze
       strings[notification.content_type] || '%<user> %<action>s something (<%link>)'
     end

data/app/helpers/elabs/shortcodes_helper.rb

@@ -0,0 +1,108 @@
+module Elabs
+  module ShortcodesHelper
+    SHORT_CODES = {
+      /\[album:([\w-]+)\]/                                       => [:shortcode_content, { type: :album, size: :inline }],
+      /\[article:([\w-]+)\]/                                     => [:shortcode_content, { type: :article, size: :inline }],
+      /\[note:([\w-]+)\]/                                        => [:shortcode_content, { type: :note, size: :inline }],
+      /\[project:([\w-]+)\]/                                     => [:shortcode_content, { type: :project, size: :inline }],
+      /\[upload:([\w-]+)\]/                                      => [:shortcode_content, { type: :upload, size: :inline }],
+      /\[user:([a-zA-Z0-9]+([_-]?[a-zA-Z0-9]+)?)\]/              => [:shortcode_content, { type: :user, size: :inline }],
+      /\[album-card:([\w-]+)\]/                                  => [:shortcode_content, { type: :album, size: :large }],
+      /\[article-card:([\w-]+)\]/                                => [:shortcode_content, { type: :article, size: :large }],
+      /\[note-card:([\w-]+)\]/                                   => [:shortcode_content, { type: :note, size: :large }],
+      /\[project-card:([\w-]+)\]/                                => [:shortcode_content, { type: :project, size: :large }],
+      /\[upload-card:([\w-]+)\]/                                 => [:shortcode_content, { type: :upload, size: :large }],
+      /\[user-card:([a-zA-Z0-9]+([_-]?[a-zA-Z0-9]+)?)\]/         => [:shortcode_content, { type: :user, size: :large }],
+      %r{\[github-repo:([a-zA-Z0-9\-_]+/[a-zA-Z0-9\-_]+)\]}      => [:shortcode_github_repo_inline, { size: :inline }],
+      %r{\[github-repo-card:([a-zA-Z0-9\-_]+/[a-zA-Z0-9\-_]+)\]} => [:shortcode_github_repo, {}],
+      /\[github-user-card:([a-zA-Z0-9\-_]+)\]/                   => [:shortcode_github_user, {}],
+      %r{\[gitlab-repo:(https://.*)\]}                           => [:shortcode_gitlab_repo_inline, { size: :inline }],
+      %r{\[gitlab-repo-card:(https://.*)\]}                      => [:shortcode_gitlab_repo, {}],
+      %r{\[gitlab-user-card:(https://.*)\]}                      => [:shortcode_gitlab_user, {}],
+      %r{\[gitlab-group-card:(https://.*)\]}                     => [:shortcode_gitlab_group, {}]
+    }.freeze
+
+    def process_short_codes(text, original_entity = nil, display = true)
+      SHORT_CODES.each do |key, method|
+        text.gsub! key do |match|
+          size = method[1].key?(:size) ? method[1][:size] : :inline
+          if display || size == :inline
+            send(method[0], original_entity, match.sub(key, '\1'), method[1])
+          else
+            render(partial: 'elabs/layouts/shortcodes/open_to_see') unless display
+          end
+        end
+      end
+      text.html_safe
+    end
+
+    private
+
+    def shortcode_content(original_entity, slug, options = { size: :large })
+      type = options[:type].to_s
+      model       = model_from_entity type
+      widget_size = options[:size] == :inline ? '_inline' : ''
+
+      return render "elabs/layouts/shortcodes/infinite_loop#{widget_size}", format: :html if shortcode_may_cause_loop?(model, slug, original_entity)
+
+      entity = find_entity_for_shortcode(model, slug)
+      return render "elabs/layouts/shortcodes/missing_content#{widget_size}", format: :html unless entity
+
+      render_shortcode_widget(model, type, entity, widget_size)
+    end
+
+    def shortcode_github_repo(_original_entity, repo_url, _options = {})
+      render partial: 'elabs/layouts/shortcodes/widgets/github_repo_card', locals: { repo_url: repo_url }
+    end
+
+    def shortcode_github_repo_inline(_original_entity, repo_url, _options = {})
+      url_matches = %r{([a-zA-Z0-9\-_]+)/([a-zA-Z0-9\-_]+)}.match repo_url
+      render partial: 'elabs/layouts/shortcodes/widgets/github_repo_inline', locals: { url_matches: url_matches }
+    end
+
+    def shortcode_github_user(_original_entity, user_name, _options = {})
+      render partial: 'elabs/layouts/shortcodes/widgets/github_user_card', locals: { user_name: user_name }
+    end
+
+    def shortcode_gitlab_repo(_original_entity, repo_url, _options = {})
+      url_matches = %r{(?:https://)?([a-z0-9\-_\.]+)/(.+)}.match repo_url
+      render partial: 'elabs/layouts/shortcodes/widgets/gitlab_repo_card', locals: { url_matches: url_matches }
+    end
+
+    def shortcode_gitlab_repo_inline(_original_entity, repo_url, _options = {})
+      url_matches = %r{(.*)/([a-zA-Z0-9\-_]+)/([a-zA-Z0-9\-_]+)}.match repo_url
+      render partial: 'elabs/layouts/shortcodes/widgets/gitlab_repo_inline', locals: { url_matches: url_matches }
+    end
+
+    def shortcode_gitlab_user(_original_entity, user_url, _options = {})
+      url_matches = %r{(?:https://)?([a-z0-9\-_\.]*)/([a-zA-Z0-9\-_]+)}.match user_url
+      render partial: 'elabs/layouts/shortcodes/widgets/gitlab_user_card', locals: { url_matches: url_matches }
+    end
+
+    def shortcode_gitlab_group(_original_entity, group_url, _options = {})
+      url_matches = %r{(?:https://)?([a-z0-9\-_\.]*)/([a-zA-Z0-9\-_]+)}.match group_url
+      render partial: 'elabs/layouts/shortcodes/widgets/gitlab_group_card', locals: { url_matches: url_matches }
+    end
+
+    def shortcode_may_cause_loop?(model, slug, original_entity)
+      original_entity && original_entity[model::SLUG_FIELD] == slug && original_entity.class == model
+    end
+
+    def find_entity_for_shortcode(model, slug)
+      return model.where("#{model::SLUG_FIELD}": slug).publicly_visible.first if shortcode_for_content? model
+
+      model.find_by("#{model::SLUG_FIELD}": slug)
+    end
+
+    def shortcode_for_content?(model)
+      %w[Elabs::Article Elabs::Album Elabs::Note Elabs::Project Elabs::Upload].include? model.to_s
+    end
+
+    def render_shortcode_widget(model, type, entity, widget_size)
+      return render partial: "elabs/#{type.pluralize}/#{type}_inline", locals: { type.to_sym => entity }, format: :html if widget_size == '_inline'
+      return render partial: 'elabs/layouts/content_card', locals: { entity: entity }, format: :html if shortcode_for_content? model
+
+      render partial: "elabs/#{type.pluralize}/#{type}#{widget_size}", locals: { type.to_sym => entity }, format: :html
+    end
+  end
+end

data/app/helpers/elabs/thumbnails_helper.rb

@@ -18,7 +18,7 @@ module Elabs
     end
 
     def thumbnail_preview_placeholder_file
-      'elabs/preview_placeholder.png'
+      '/assets/elabs/preview_placeholder.png'
     end
 
     def image_resize_properties(size = :page)

data/app/models/elabs/album.rb

@@ -22,7 +22,21 @@ module Elabs
     has_many :projects, through: :projects_albums, dependent: :destroy
     has_many :uploads,  through: :albums_uploads,  dependent: :destroy
     has_many :comments, as: 'content'
+    has_many :visible_projects, -> { where(published: true, locked: false) },
+             through: :projects_albums, source: :project
 
     scope :for_list, -> { order(:name).pluck(:name, :id) }
+
+    def title_to_display
+      name
+    end
+
+    def short_text_to_display
+      nil
+    end
+
+    def long_text_to_display
+      description
+    end
   end
 end

data/app/models/elabs/announcement.rb

@@ -0,0 +1,33 @@
+module Elabs
+  class Announcement < ApplicationRecord
+    self.table_name = 'announcements'
+
+    validates :level, inclusion: { in: %w[info warning danger] }, presence: true
+    validates :target, inclusion: { in: %w[global public member admin] }, presence: true
+    validates :content, presence: true
+
+    before_save :clean_dates
+
+    belongs_to :user
+
+    scope :visible, lambda {
+      now = Time.now
+      where('start_at <= ? OR start_at IS NULL', now).where('end_at >= ? OR end_at IS NULL', now)
+    }
+
+    def self.for_user(user)
+      return visible.where('target = ? OR target = ?', :global, :member) if user&.role == 'user'
+
+      return visible.where('target = ? OR target = ? OR target = ?', :global, :member, :admin) if user&.role == 'admin'
+
+      visible.where(target: :global)
+    end
+
+    private
+
+    def clean_dates
+      self.start_at = nil if start_at == ''
+      self.end_at   = nil if end_at == ''
+    end
+  end
+end

data/app/models/elabs/article.rb

@@ -21,5 +21,19 @@ module Elabs
     has_many :tags,     through: :articles_tags,     dependent: :destroy
     has_many :projects, through: :projects_articles, dependent: :destroy
     has_many :comments, as: 'content'
+    has_many :visible_projects, -> { where(published: true, locked: false) },
+             through: :projects_articles, source: :project
+
+    def title_to_display
+      title
+    end
+
+    def short_text_to_display
+      excerpt
+    end
+
+    def long_text_to_display
+      content
+    end
   end
 end

data/app/models/elabs/comment.rb

@@ -6,21 +6,27 @@ module Elabs
     validates :user,    presence: true, unless: :name
     validates :name,    presence: true, unless: :user
 
-    belongs_to :content, polymorphic: true
-    belongs_to :user,    optional: true
+    belongs_to :content,       polymorphic: true
+    belongs_to :user,          optional: true
+    has_many   :notifications, as: :content, dependent: :destroy
 
-    after_save :notify_author, if: :notify_author?
+    after_create :notify_author, if: :notify_author?
 
     def notify_author?
       user_id ? content.user_id != user_id : true
     end
 
     def notify_author
-      notification = { content: content,
+      notification = { content: self,
                        event:   :comment,
                        user_id: content.user_id }
       notification[:source_user] = user if user_id
       Elabs::Notification.create! notification
     end
+
+    def archive!
+      update(archived: true)
+      notifications.destroy_all
+    end
   end
 end