biovision-post 0.2.180325 → 0.21.190513.0

data/app/models/post_layout.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Model for post layout
+#
+# Attributes:
+#   name [String]
+#   posts_count [Integer]
+#   slug [String]
+class PostLayout < ApplicationRecord
+  include RequiredUniqueName
+  include RequiredUniqueSlug
+
+  has_many :posts, dependent: :nullify
+end

data/app/models/post_link.rb

@@ -5,6 +5,8 @@ class PostLink < ApplicationRecord
 
   validates_uniqueness_of :other_post_id, scope: [:post_id]
 
+  scope :list_for_administration, -> { ordered_by_priority }
+
   def self.entity_parameters
     %i(priority)
   end

data/app/models/post_post_category.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# Link between post and post category
+#
+# Attributes:
+#   created_at [DateTime]
+#   post_category_id [PostCategory]
+#   post_id [Post]
+#   updated_at [DateTime]
+class PostPostCategory < ApplicationRecord
+  belongs_to :post
+  belongs_to :post_category, counter_cache: :posts_count
+
+  validates_uniqueness_of :post_category_id, scope: :post_id
+  validate :category_consistency
+
+  private
+
+  def category_consistency
+    return if post_category&.post_type == post&.post_type
+
+    errors.add(:post_category_id, I18n.t('activerecord.errors.messages.mismatches_post_type'))
+  end
+end

data/app/models/post_post_tag.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# Link between post and post tag
+#
+# Attributes:
+#   created_at [DateTime]
+class PostPostTag < ApplicationRecord
+  belongs_to :post
+  belongs_to :post_tag, counter_cache: :posts_count
+
+  validates_uniqueness_of :post_tag_id, scope: [:post_id]
+
+  private
+
+  def matching_post_type
+    unless post.post_type_id == post_tag.post_type_id
+      error = I18n.t('activerecord.errors.messages.mismatches_post_type')
+      errors.add(:post_tag, error)
+    end
+  end
+end

data/app/models/post_tag.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+# Post tag
+class PostTag < ApplicationRecord
+  NAME_LIMIT = 255
+
+  belongs_to :post_type
+  has_many :post_post_tags, dependent: :delete_all
+  has_many :posts, through: :post_post_tags
+
+  before_validation { self.name = name.to_s.squish[0..NAME_LIMIT] }
+  before_validation { self.slug = Canonizer.canonize(name) unless name.blank? }
+
+  validates_presence_of :name, :slug
+  validates_uniqueness_of :slug, scope: :post_type_id
+  validates_length_of :name, maximum: NAME_LIMIT
+
+  scope :ordered_by_slug, -> { order('slug asc') }
+  scope :popular, -> { order('posts_count desc, slug asc') }
+  scope :with_posts, -> { where('posts_count > 0') }
+  scope :with_name_like, ->(v) { where('name ilike ?', "%#{v}%") unless v.blank? }
+  scope :list_for_administration, -> { ordered_by_slug }
+  scope :list_for_visitors, -> { with_posts.ordered_by_slug }
+  scope :ids_for_name, ->(name) { where(slug: Canonizer.canonize(name)).pluck(:id) }
+
+  # @param [Integer] page
+  def self.page_for_administration(page = 1)
+    list_for_administration.page(page)
+  end
+
+  def self.entity_parameters
+    %i[name]
+  end
+
+  def self.creation_parameters
+    entity_parameters + %i[post_type_id]
+  end
+
+  # @param [Integer] post_type_id
+  # @param [String] name
+  def self.match_by_name(post_type_id, name)
+    find_by(post_type_id: post_type_id, slug: Canonizer.canonize(name))
+  end
+
+  # @param [Integer] post_type_id
+  # @param [String] name
+  def self.match_or_create_by_name(post_type_id, name)
+    entity = find_by(post_type_id: post_type_id, slug: Canonizer.canonize(name))
+    entity || create(post_type_id: post_type_id, name: name)
+  end
+
+  def name_for_url
+    Canonizer.urlize name
+  end
+
+  # @param [Post] post
+  def post?(post)
+    post_post_tags.exist?(post: post)
+  end
+
+  # @param [Post] post
+  def add_post(post)
+    post_post_tags.create(post: post) unless post.nil?
+  end
+
+  # @param [Post] post
+  def remove_post(post)
+    post_post_tags.where(post: post).delete_all
+  end
+end

data/app/models/post_translation.rb

@@ -0,0 +1,7 @@
+class PostTranslation < ApplicationRecord
+  belongs_to :post
+  belongs_to :language
+  belongs_to :translated_post, class_name: Post.to_s
+
+  validates_uniqueness_of :language_id, scope: [:post_id]
+end

data/app/models/post_type.rb

@@ -1,14 +1,29 @@
+# frozen_string_literal: true
+
+# Post type
+#
+# Attributes:
+#   active [Boolean]
+#   category_depth [Integer]
+#   created_at [DateTime]
+#   default_category_name [String], optional
+#   name [String]
+#   slug [String]
+#   updated_at [DateTime]
 class PostType < ApplicationRecord
   include RequiredUniqueName
   include RequiredUniqueSlug
 
   NAME_LIMIT = 50
   SLUG_LIMIT = 50
-  SLUG_PATTERN = /\A[a-z]+[0-9a-z_]*[0-9a-z]\z/
-  DEPTH_RANGE = (0..10)
+  SLUG_PATTERN = /\A[a-z]+[0-9a-z_]*[0-9a-z]\z/.freeze
+  DEPTH_RANGE = (0..10).freeze
 
   has_many :post_categories, dependent: :destroy
   has_many :posts
+  has_many :post_tags, dependent: :delete_all
+  has_many :editorial_member_post_types, dependent: :delete_all
+  has_many :editorial_members, through: :editorial_member_post_types
 
   validates_length_of :name, maximum: NAME_LIMIT
   validates_length_of :slug, maximum: SLUG_LIMIT
@@ -16,6 +31,7 @@ class PostType < ApplicationRecord
   validates_inclusion_of :category_depth, in: DEPTH_RANGE
 
   scope :active, -> { where(active: true) }
+  scope :list_for_administration, -> { active.ordered_by_name }
 
   def self.page_for_administration
     active.ordered_by_name

data/app/models/post_zen_category.rb

@@ -0,0 +1,6 @@
+class PostZenCategory < ApplicationRecord
+  belongs_to :post
+  belongs_to :zen_category, counter_cache: :posts_count
+
+  validates_uniqueness_of :zen_category_id, scope: [:post_id]
+end

data/app/models/zen_category.rb

@@ -0,0 +1,21 @@
+class ZenCategory < ApplicationRecord
+  include RequiredUniqueName
+
+  has_many :post_zen_categories, dependent: :delete_all
+  has_many :posts, through: :post_zen_categories
+
+  # @param [Post] post
+  def post?(post)
+    post_zen_categories.where(post: post).exists?
+  end
+
+  # @param [Post] post
+  def add_post(post)
+    post_zen_categories.create(post: post)
+  end
+
+  # @param [Post] post
+  def remove_post(post)
+    post_zen_categories.where(post: post).destroy_all
+  end
+end

data/app/services/post_manager.rb

@@ -1,34 +1,71 @@
+# frozen_string_literal: true
+
+# Manager for handling post-related cases
 class PostManager
-  # @param [Post] entity
+  # @param [Post|PostCategory] entity
   # @param [Symbol|String] locale
   def initialize(entity, locale = I18n.locale)
     @entity = entity
-    @body   = entity.body.to_s
-    @prefix = locale.nil? ? '' : "/#{locale}"
+    @body = entity.body.to_s if @entity.is_a?(Post)
+    @prefix = locale.nil? || locale == I18n.default_locale ? '' : "/#{locale}"
+    @url_part = entity.post_type.url_part
   end
 
-  # @param [Post] entity
-  # @param [Symbol|String] locale
-  def self.handler(entity, locale = I18n.locale)
-    handler_name  = "post_manager/#{entity.post_type.slug}_handler".classify
-    handler_class = handler_name.safe_constantize || PostManager
-    handler_class.new(entity, locale)
+  # @param [User] user
+  # @param [String|PostType] type
+  def self.editor?(user, type)
+    return true if UserPrivilege.user_has_privilege?(user, :chief_editor)
+
+    type = PostType.find_by(slug: type) unless type.is_a?(PostType)
+
+    EditorialMember.find_by(user: user)&.post_type?(type)
+  end
+
+  # @param [Post] post
+  def self.enclosures(post)
+    post.parsed_body.scan(/<img[^>]+>/).map do |image|
+      image.scan(/src="([^"]+)"/)[0][0]
+    end
   end
 
   def parsed_body
-    @body.gsub(/<script/, '&lt;script')
+    PostParser.new(@entity).parsed_body if @entity.is_a?(Post)
   end
 
   def post_path
-    "#{@prefix}/posts/#{@entity.id}"
+    "#{@prefix}/#{@url_part}/#{@entity.id}-#{@entity.slug}" if @entity.is_a?(Post)
   end
 
   def edit_path
-    "#{@prefix}/posts/#{@entity.id}/edit"
+    "#{@prefix}/posts/#{@entity.id}/edit" if @entity.is_a?(Post)
+  end
+
+  # @param [String] tag_name
+  def tagged_path(tag_name)
+    "#{@prefix}/#{@url_part}/tagged/#{CGI.escape(tag_name)}"
+  end
+
+  def category_path
+    postfix = ''
+    suffix = @entity.is_a?(Post) ? @entity.post_category : @entity
+    postfix += "/#{suffix.long_slug}" unless suffix.nil?
+
+    empty_category_path + postfix
+  end
+
+  def category_name
+    if @entity.is_a?(Post)
+      if @entity.post_category.nil?
+        @entity.post_type.default_category_name
+      else
+        @entity.post_categories.map(&:text_for_link)
+      end
+    else
+      @entity.text_for_link
+    end
   end
 
-  # @param [PostCategory] category
-  def category_path(category)
-    "#{@prefix}/posts/#{category.long_slug}"
+  def empty_category_path
+    "#{@prefix}/#{@url_part}"
   end
 end

data/app/services/post_parser.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+# Parser for post body
+class PostParser
+  # @param [Post] entity
+  def initialize(entity)
+    @entity = entity
+    @body   = entity.body.clone
+  end
+
+  def parsed_body
+    unless @entity.avoid_parsing?
+      @body = escape_scripts
+      @body = convert_video_links
+      @body = convert_asides
+    end
+
+    @body
+  end
+
+  def escape_scripts
+    @body.gsub(/<script/, '&lt;script')
+  end
+
+  def convert_video_links
+    pattern = %r(<p>{video:(?<url>[^}]{1,100})}</p>)i
+    @body.gsub(pattern) do
+      iframe = video_url_to_iframe($LAST_MATCH_INFO[:url])
+      %(<div class="proportional-container r-16x9">#{iframe}</div>)
+    end
+  end
+
+  def convert_asides
+    pattern = %r{<p>~~\s*(.+?)</p>}i
+    @body.gsub(pattern) do
+      "<aside>#{$LAST_MATCH_INFO[1]}</aside>"
+    end
+  end
+
+  private
+
+  # @param [String] url
+  def video_url_to_iframe(url)
+    src = video_iframe_url(url)
+
+    src.blank? ? url : %(<iframe src="#{src}" allowfullscreen></iframe>)
+  end
+
+  # @param [String] url
+  def video_iframe_url(url)
+    if url.match?(%r{\Ahttps?://vimeo\.com})
+      process_vimeo_link(url)
+    elsif url.match?(%r{\Ahttps?://www\.youtube\.com/watch})
+      process_youtube_link(url)
+    elsif url.match?(%r{\Ahttps?://youtu\.be/.+})
+      process_youtu_be_link(url)
+    end
+  end
+
+  # @param [String] url
+  def process_vimeo_link(url)
+    video_id  = url.gsub(%r{\A\D+/(\d+)/?}, '\\1')
+    api_url   = "https://vimeo.com/api/v2/video/#{video_id}.json"
+    json_data = JSON.parse(URI.open(api_url)).first
+
+    json_data.blank? ? '' : "https://player.vimeo.com/video/#{json_data['id']}"
+  end
+
+  # @param [String] url
+  def process_youtube_link(url)
+    video_id = CGI.parse(URI.parse(url).query)['v'].first
+    "//www.youtube.com/embed/#{video_id}"
+  end
+
+  # @param [String] url
+  def process_youtu_be_link(url)
+    video_id = URI.parse(url).path.delete('/')
+    "//www.youtube.com/embed/#{video_id}"
+  end
+end

data/app/uploaders/post_image_uploader.rb

@@ -1,18 +1,22 @@
+# frozen_string_literal: true
+
+# Image uploader for posts
 class PostImageUploader < CarrierWave::Uploader::Base
   include CarrierWave::MiniMagick
   include CarrierWave::BombShelter
 
   storage :file
+  process :auto_orient
 
   def max_pixel_dimensions
-    [3840, 3840]
+    [9600, 9600]
   end
 
   def store_dir
-    "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id/10000.floor}/#{model.id/100.floor}/#{model.id}"
-  end
+    slug = "#{model.id / 10_000}/#{model.id / 100}/#{model.id}"
 
-  process :auto_orient
+    "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{slug}"
+  end
 
   def auto_orient
     manipulate! do |image|
@@ -45,10 +49,6 @@ class PostImageUploader < CarrierWave::Uploader::Base
   end
 
   def extension_white_list
-    %w(jpg jpeg png)
-  end
-
-  def filename
-    "#{model.uuid}.#{file.extension}" if original_filename
+    %w[jpg jpeg png]
   end
 end

data/app/views/admin/editorial_members/_nav_item.html.erb

@@ -0,0 +1,2 @@
+<div><%= link_to(t('.text'), admin_editorial_members_path) %></div>
+<div class="description"><%= t('.description') %></div>

data/app/views/admin/editorial_members/entity/_in_list.html.erb

@@ -0,0 +1,37 @@
+<div class="image">
+  <%= profile_avatar(entity.user) %>
+</div>
+<div class="data">
+  <div><%= admin_editorial_member_link(entity) %></div>
+  <div class="info">
+    <%= entity.title %>
+  </div>
+  <% unless entity.lead.blank? %>
+    <div class="secondary info">
+      <%= entity.lead %>
+    </div>
+  <% end %>
+
+  <%=
+    render(
+        partial: 'shared/admin/toggleable',
+        locals:  {
+            entity: entity,
+            url:    toggle_admin_editorial_member_path(id: entity.id)
+        }
+    )
+  %>
+
+  <ul class="actions">
+    <% if entity.visible? %>
+      <li><%= world_icon(author_path(slug: entity.slug)) %></li>
+    <% end %>
+    <li><%= edit_icon(edit_editorial_member_path(id: entity.id)) %></li>
+    <%=
+      render(
+          partial: 'shared/actions/priority_changer',
+          locals:  { path: priority_admin_editorial_member_path(id: entity.id) }
+      )
+    %>
+  </ul>
+</div>