biovision-courses 0.0.180221

data/app/helpers/biovision/courses/application_helper.rb

@@ -0,0 +1,6 @@
+module Biovision
+  module Courses
+    module ApplicationHelper
+    end
+  end
+end

data/app/helpers/biovision_courses_helper.rb

@@ -0,0 +1,80 @@
+module BiovisionCoursesHelper
+  # @param [CourseTag] entity
+  # @param [String] text
+  def admin_course_tag_link(entity, text = entity.name)
+    link_to(text, admin_course_tag_path(entity.id))
+  end
+
+  # @param [CourseCategory] entity
+  # @param [String] text
+  def admin_course_category_link(entity, text = entity.name)
+    link_to(text, admin_course_category_path(entity.id))
+  end
+
+  # @param [Course] entity
+  # @param [String] text
+  def admin_course_link(entity, text = entity.title)
+    link_to(text, admin_course_path(entity.id))
+  end
+
+  def course_categories_for_select
+    options = []
+    CourseCategory.for_tree.each do |category|
+      options << [category.name, category.id]
+      if category.child_categories.any?
+        CourseCategory.for_tree(category.id).each do |subcategory|
+          options << ["-#{subcategory.name}", subcategory.id]
+          if subcategory.child_categories.any?
+            CourseCategory.for_tree(subcategory.id).each do |deep_category|
+              options << ["--#{deep_category.name}", deep_category.id]
+            end
+          end
+        end
+      end
+    end
+    options
+  end
+
+  # @param [Course] entity
+  # @param [String] text
+  # @param [Hash] options
+  def course_link(entity, text = entity.title, options = {})
+    link_to(text, course_path(entity.id), options)
+  end
+
+  # Course image preview for displaying in "administrative" lists
+  #
+  # @param [Course] entity
+  def course_image_preview(entity)
+    return '' if entity.image.blank?
+
+    versions = "#{entity.image.preview_2x.url} 2x"
+    image_tag(entity.image.preview.url, alt: entity.title, srcset: versions)
+  end
+
+  # Small course image for displaying in lists of courses and feeds
+  #
+  # @param [Course] entity
+  # @param [Hash] add_options
+  def course_image_small(entity, add_options = {})
+    return '' if entity.image.blank?
+
+    alt_text = entity.image_alt_text.to_s
+    versions = "#{entity.image.medium.url} 2x"
+    options  = { alt: alt_text, srcset: versions }.merge(add_options)
+    image_tag(entity.image.small.url, options)
+  end
+
+  # Medium course image for displaying on course page
+  #
+  # @param [Course] entity
+  # @param [Hash] add_options
+  def course_image_medium(entity, add_options = {})
+    return '' if entity.image.blank?
+
+    alt_text = entity.image_alt_text.to_s
+    versions = "#{entity.image.big.url} 2x"
+    options  = { alt: alt_text, srcset: versions }.merge(add_options)
+    image_tag(entity.image.medium.url, options)
+  end
+end

data/app/jobs/biovision/courses/application_job.rb

@@ -0,0 +1,6 @@
+module Biovision
+  module Courses
+    class ApplicationJob < ActiveJob::Base
+    end
+  end
+end

data/app/mailers/biovision/courses/application_mailer.rb

@@ -0,0 +1,8 @@
+module Biovision
+  module Courses
+    class ApplicationMailer < ActionMailer::Base
+      default from: 'from@example.com'
+      layout 'mailer'
+    end
+  end
+end

data/app/models/application_record.rb

@@ -0,0 +1,3 @@
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+end

data/app/models/biovision/courses/application_record.rb

@@ -0,0 +1,7 @@
+module Biovision
+  module Courses
+    class ApplicationRecord < ActiveRecord::Base
+      self.abstract_class = true
+    end
+  end
+end

data/app/models/course.rb

@@ -0,0 +1,109 @@
+class Course < ApplicationRecord
+  include HasOwner
+  include Toggleable
+
+  PER_PAGE = 24
+
+  DESCRIPTION_LIMIT = 50000
+  DURATION_LIMIT    = 50
+  LEAD_LIMIT        = 1000
+  META_LIMIT        = 255
+  PRIORITY_RANGE    = (1..999)
+  SLUG_LIMIT        = 250
+  SLUG_PATTERN      = /\A[a-z][-0-9a-z]*[0-9a-z]\z/i
+  SLUG_PATTERN_HTML = '^[a-zA-Z][-0-9a-zA-Z]*[0-9a-zA-Z]$'
+  TITLE_LIMIT       = 250
+
+  toggleable :visible, :highlight, :online
+
+  mount_uploader :image, CourseImageUploader
+
+  belongs_to :course_category, counter_cache: true
+  belongs_to :user, optional: true
+  belongs_to :agent, optional: true
+  has_many :course_course_tags, dependent: :destroy
+  has_many :course_tags, through: :course_course_tags
+
+  after_initialize :set_next_priority
+  before_validation { self.slug = Canonizer.transliterate(title.to_s) if slug.blank? }
+  before_validation { self.slug = slug.to_s.downcase }
+  before_validation :normalize_priority
+
+  validates_presence_of :title, :slug
+  validates_uniqueness_of :title
+  validates_uniqueness_of :slug
+  validates_length_of :title, maximum: TITLE_LIMIT
+  validates_length_of :subtitle, maximum: TITLE_LIMIT
+  validates_length_of :slug, maximum: SLUG_LIMIT
+  validates_format_of :slug, with: SLUG_PATTERN
+  validates_length_of :image_alt_text, maximum: META_LIMIT
+  validates_length_of :meta_title, maximum: META_LIMIT
+  validates_length_of :meta_keywords, maximum: META_LIMIT
+  validates_length_of :meta_description, maximum: META_LIMIT
+  validates_length_of :lead, maximum: LEAD_LIMIT
+  validates_length_of :description, maximum: DESCRIPTION_LIMIT
+  validates_length_of :duration, maximum: DURATION_LIMIT
+  validates_numericality_of :price, greater_than_or_equal_to: 0, allow_blank: true
+  validates_numericality_of :special_price, greater_than_or_equal_to: 0, allow_blank: true
+
+  scope :ordered_by_priority, -> { order 'priority asc, title asc' }
+  scope :visible, -> { where(visible: true, deleted: false) }
+  scope :for_tree, ->(course_category_id = nil) { siblings(course_category_id).ordered_by_priority }
+  scope :siblings, ->(course_category_id) { where(course_category_id: course_category_id) }
+  scope :list_for_visitors, -> { visible.ordered_by_priority }
+
+  # @param [Integer] page
+  def self.page_for_administration(page = 1)
+    ordered_by_priority.page(page).per(PER_PAGE)
+  end
+
+  # @param [Integer] page
+  def self.page_for_visitors(page = 1)
+    list_for_visitors.page(page).per(PER_PAGE)
+  end
+
+  def self.entity_parameters
+    texts      = %i(title subtitle slug lead description duration)
+    decoration = %i(price special_price special_price_end image image_alt_text)
+    meta_texts = %i(meta_title meta_keywords meta_description metadata)
+    meta_data  = %i(course_category_id priority visible highlight online)
+
+    texts + decoration + meta_texts + meta_data
+  end
+
+  # @param [User] user
+  def editable_by?(user)
+    owned_by?(user) || UserPrivilege.user_has_privilege?(user, :chief_course_manager)
+  end
+
+  # @param [User] user
+  def lockable_by?(user)
+    UserPrivilege.user_has_privilege?(user, :chief_course_manager)
+  end
+
+  # @param [Integer] delta
+  def change_priority(delta)
+    new_priority = priority + delta
+    criteria     = { course_category_id: course_category_id, priority: new_priority }
+    adjacent     = self.class.find_by(criteria)
+    if adjacent.is_a?(self.class) && (adjacent.id != id)
+      adjacent.update!(priority: priority)
+    end
+    self.update(priority: new_priority)
+
+    self.class.for_tree(course_category_id).map { |e| [e.id, e.priority] }.to_h
+  end
+
+  private
+
+  def set_next_priority
+    if id.nil? && priority == 1
+      self.priority = self.class.siblings(course_category_id).maximum(:priority).to_i + 1
+    end
+  end
+
+  def normalize_priority
+    self.priority = PRIORITY_RANGE.first if priority < PRIORITY_RANGE.first
+    self.priority = PRIORITY_RANGE.last if priority > PRIORITY_RANGE.last
+  end
+end

data/app/models/course_category.rb

@@ -0,0 +1,137 @@
+class CourseCategory < ApplicationRecord
+  include Toggleable
+
+  PRIORITY_RANGE    = (1..500)
+  NAME_LIMIT        = 50
+  SLUG_LIMIT        = 50
+  SLUG_PATTERN      = /\A[a-z][-0-9a-z]*[0-9a-z]\z/i
+  SLUG_PATTERN_HTML = '^[a-zA-Z][-0-9a-zA-Z]*[0-9a-zA-Z]$'
+
+  toggleable :visible
+
+  mount_uploader :image, CourseImageUploader
+
+  belongs_to :parent, class_name: CourseCategory.to_s, optional: true, touch: true
+  has_many :child_categories, class_name: CourseCategory.to_s, foreign_key: :parent_id, dependent: :destroy
+  has_many :courses, dependent: :destroy
+
+  after_initialize :set_next_priority
+  before_validation { self.slug = Canonizer.transliterate(name.to_s) if slug.blank? }
+  before_validation { self.slug = slug.to_s.downcase }
+  before_validation :generate_long_slug
+  before_validation :normalize_priority
+  before_save { self.children_cache.uniq! }
+  after_create :cache_parents!
+  after_save { parent.cache_children! unless parent.nil? }
+
+  validates_presence_of :name, :slug
+  validates_uniqueness_of :name, scope: [:parent_id]
+  validates_uniqueness_of :slug, scope: [:parent_id]
+  validates_length_of :name, maximum: NAME_LIMIT
+  validates_length_of :slug, maximum: SLUG_LIMIT
+  validates_format_of :slug, with: SLUG_PATTERN
+
+  scope :ordered_by_priority, -> { order 'priority asc, name asc' }
+  scope :visible, -> { where(visible: true, deleted: false) }
+  scope :for_tree, ->(parent_id = nil) { siblings(parent_id).ordered_by_priority }
+  scope :siblings, ->(parent_id) { where(parent_id: parent_id) }
+
+  def self.entity_parameters
+    %i(image name slug priority visible)
+  end
+
+  def self.creation_parameters
+    entity_parameters + %i(parent_id)
+  end
+
+  def full_title
+    (parents.map { |parent| parent.name } + [name]).join ' / '
+  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 image_alt_text
+    name
+  end
+
+  def title
+    name
+  end
+
+  def parents
+    return [] if parents_cache.blank?
+    CourseCategory.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
+
+  def cache_children!
+    child_categories.order('id asc').each do |child|
+      self.children_cache += [child.id] + child.children_cache
+    end
+    save!
+  end
+
+  def can_be_deleted?
+    child_categories.count < 1
+  end
+
+  # @param [Course] course
+  def course?(course)
+    course.course_category == self
+  end
+
+  # @param [Integer] delta
+  def change_priority(delta)
+    new_priority = priority + delta
+    criteria     = { parent_id: parent_id, priority: new_priority }
+    adjacent     = self.class.find_by(criteria)
+    if adjacent.is_a?(self.class) && (adjacent.id != id)
+      adjacent.update!(priority: priority)
+    end
+    self.update(priority: new_priority)
+
+    self.class.for_tree(parent_id).map { |e| [e.id, e.priority] }.to_h
+  end
+
+  private
+
+  def set_next_priority
+    if id.nil? && priority == 1
+      self.priority = self.class.siblings(parent_id).maximum(:priority).to_i + 1
+    end
+  end
+
+  def normalize_priority
+    self.priority = PRIORITY_RANGE.first if priority < PRIORITY_RANGE.first
+    self.priority = PRIORITY_RANGE.last if priority > PRIORITY_RANGE.last
+  end
+
+  def generate_long_slug
+    if parent.nil?
+      self.long_slug = slug
+    else
+      self.long_slug = "#{parent.long_slug}_#{slug}"
+    end
+  end
+end

data/app/models/course_course_tag.rb

@@ -0,0 +1,13 @@
+class CourseCourseTag < ApplicationRecord
+  after_create :update_course_tags_cache
+  after_destroy :update_course_tags_cache
+
+  belongs_to :course
+  belongs_to :course_tag, counter_cache: :courses_count
+
+  private
+
+  def update_course_tags_cache
+    course.update tags_cache: course.course_tags.ordered_by_name.map(&:name)
+  end
+end

data/app/models/course_tag.rb

@@ -0,0 +1,49 @@
+class CourseTag < ApplicationRecord
+  include RequiredUniqueName
+  include RequiredUniqueSlug
+  include Toggleable
+
+  PER_PAGE          = 20
+  NAME_LIMIT        = 50
+  SLUG_LIMIT        = 50
+  SLUG_PATTERN      = /\A[a-z][-0-9a-z]*[0-9a-z]\z/i
+  SLUG_PATTERN_HTML = '^[a-zA-Z][-0-9a-zA-Z]*[0-9a-zA-Z]$'
+
+  toggleable :visible
+
+  mount_uploader :image, CourseImageUploader
+
+  has_many :course_course_tags, dependent: :destroy
+  has_many :courses, through: :course_course_tags
+
+  before_validation { self.slug = Canonizer.transliterate(name.to_s) if slug.blank? }
+  before_validation { self.slug = slug.to_s.downcase }
+  validates_length_of :name, maximum: NAME_LIMIT
+  validates_length_of :slug, maximum: SLUG_LIMIT
+  validates_format_of :slug, with: SLUG_PATTERN
+
+  scope :visible, -> { where(visible: true) }
+  scope :list_for_visitors, -> { visible.ordered_by_name }
+
+  # @param [Integer] page
+  def self.page_for_administration(page = 1)
+    ordered_by_name.page(page).per(PER_PAGE)
+  end
+
+  # @param [Integer] page
+  def self.page_for_visitors(page = 1)
+    list_for_visitors.page(page).per(PER_PAGE)
+  end
+
+  def self.entity_parameters
+    %i(visible image name slug)
+  end
+
+  def image_alt_text
+    name
+  end
+
+  def title
+    name
+  end
+end

data/app/uploaders/course_image_uploader.rb

@@ -0,0 +1,46 @@
+class CourseImageUploader < CarrierWave::Uploader::Base
+  include CarrierWave::MiniMagick
+  include CarrierWave::BombShelter
+
+  storage :file
+
+  def max_pixel_dimensions
+    [3840, 3840]
+  end
+
+  def store_dir
+    "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id/10000.floor}/#{model.id/100.floor}/#{model.id}"
+  end
+
+  process :auto_orient
+
+  def auto_orient
+    manipulate! do |image|
+      image.tap(&:auto_orient)
+    end
+  end
+
+  version :big do
+    resize_to_fit(1280, 1280)
+  end
+
+  version :medium, from_version: :big do
+    resize_to_fit(640, 640)
+  end
+
+  version :small, from_version: :medium do
+    resize_to_fit(320, 320)
+  end
+
+  version :preview_2x, from_version: :small do
+    resize_to_fit(160, 160)
+  end
+
+  version :preview, from_version: :preview_2x do
+    resize_to_fit(80, 80)
+  end
+
+  def extension_white_list
+    %w(jpg jpeg png)
+  end
+end