elabs 2.0.0.pre

data/app/models/elabs/application_content_record.rb

@@ -0,0 +1,10 @@
+module Elabs
+  class ApplicationContentRecord < ApplicationRecord
+    include Elabs::Concerns::ContentEntity
+    include Elabs::Concerns::ActableEntity
+    include Elabs::Concerns::CountableEntity
+    include Elabs::Concerns::Taggable
+
+    self.abstract_class = true
+  end
+end

data/app/models/elabs/application_record.rb

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

data/app/models/elabs/article.rb

@@ -0,0 +1,23 @@
+module Elabs
+  class Article < ApplicationContentRecord
+    self.table_name = 'articles'
+
+    ADDITIONAL_HABTM_COUNTER_CACHES = [
+      %w[projects articles]
+    ].freeze
+
+    validates :title,   presence: true
+    validates :excerpt, presence: true
+    validates :content, presence: true
+    validates_with AssociatedAuthorValidator, relations: %w[project]
+
+    belongs_to :user
+    belongs_to :license
+    belongs_to :language
+    has_many :articles_tags
+    has_many :projects_articles
+    has_many :tags,     through: :articles_tags,     dependent: :destroy
+    has_many :projects, through: :projects_articles, dependent: :destroy
+    has_many :comments, as: 'content'
+  end
+end

data/app/models/elabs/articles_tag.rb

@@ -0,0 +1,21 @@
+module Elabs
+  class ArticlesTag < ApplicationRecord
+    self.table_name = 'articles_tags'
+
+    belongs_to :article
+    belongs_to :tag
+
+    after_create :increment_counter_cache
+    after_destroy :decrement_counter_cache
+
+    private
+
+    def increment_counter_cache
+      tag.increment! :articles_count if article.publicly_visible?
+    end
+
+    def decrement_counter_cache
+      tag.decrement! :articles_count if article.publicly_visible?
+    end
+  end
+end

data/app/models/elabs/comment.rb

@@ -0,0 +1,12 @@
+module Elabs
+  class Comment < ApplicationRecord
+    self.table_name = 'comments'
+
+    validates :comment, presence: true
+    validates :user,    presence: true, unless: :name
+    validates :name,    presence: true, unless: :user
+
+    belongs_to :content, polymorphic: true
+    belongs_to :user,    optional: true
+  end
+end

data/app/models/elabs/concerns/actable_entity.rb

@@ -0,0 +1,52 @@
+module Elabs
+  module Concerns
+    module ActableEntity
+      extend ActiveSupport::Concern
+
+      included do
+        has_many :acts, as: :content
+
+        before_save :update_acts?
+        after_save :update_acts
+
+        before_destroy :update_acts_on_delete
+      end
+
+      private
+
+      def update_acts?
+        @action = if changed.include?('published')
+                    current_publish_action
+                  elsif changed.include?('locked') && published?
+                    current_lock_action
+                  elsif (changed & %w[title name description short_description content excerpt]).any?
+                    current_update_action
+                  else
+                    :nothing
+                  end
+      end
+
+      def current_publish_action
+        published? && unlocked? ? :publish : :unpublish
+      end
+
+      def current_lock_action
+        published? && locked? ? :lock : :unlock
+      end
+
+      def current_update_action
+        published? && unlocked? ? :update : :nothing
+      end
+
+      def update_acts
+        acts.destroy_all if %i[lock unpublish].include? @action
+        Act.create content: self, event: @action unless @action == :nothing
+      end
+
+      # TODO: check if used ? (dependent: destroy may do the trick.)
+      def update_acts_on_delete
+        acts.destroy_all
+      end
+    end
+  end
+end

data/app/models/elabs/concerns/content_entity.rb

@@ -0,0 +1,70 @@
+module Elabs
+  module Concerns
+    module ContentEntity
+      extend ActiveSupport::Concern
+
+      included do
+        before_save :set_publication_date
+
+        scope :by_member,        ->(user_id) { where(user_id: user_id) }
+        scope :published,        -> { where(published: true) }
+        scope :unlocked,         -> { where(locked: false) }
+        scope :publicly_visible, -> { published.unlocked }
+        scope :for_relation,     -> { published.order(published_at: 'desc').limit(Elabs.max_related_items) }
+      end
+
+      def locked?
+        locked
+      end
+
+      def unlocked?
+        !locked
+      end
+
+      def draft?
+        !published
+      end
+
+      def published?
+        published
+      end
+
+      def publicly_visible?
+        published? && !locked?
+      end
+
+      def not_publicly_visible?
+        draft? || locked?
+      end
+
+      private
+
+      def made_publicly_visible?
+        (changes_include?(:published) || changes_include?(:locked)) && published? && unlocked?
+      end
+
+      def made_publicly_invisible?
+        (changes_include?(:published) && draft?) || (changes_include?(:locked) && locked? && published?)
+      end
+
+      def was_published_before?
+        (changes_include?(:published) && draft?)
+      end
+
+      def set_publication_date
+        self.published_at = Time.new if changed.include?('published') && published?
+        self.published_at = nil if changed.include?('published') && !published?
+      end
+
+      class_methods do
+        def find_publicly_visible(id)
+          entity = where(id: id).published.first
+
+          raise ActiveRecord::RecordNotFound if entity.nil?
+
+          entity
+        end
+      end
+    end
+  end
+end

data/app/models/elabs/concerns/countable_entity.rb

@@ -0,0 +1,81 @@
+module Elabs
+  module Concerns
+    module CountableEntity
+      extend ActiveSupport::Concern
+
+      # List of lists like ['albums', 'uploads'] if 'uploads_counter' is in 'albums' table
+      ADDITIONAL_HABTM_COUNTER_CACHES = [].freeze
+
+      included do
+        before_save :update_counter_caches?
+        after_save :update_counter_caches
+
+        before_destroy :update_counter_caches_on_delete?
+        after_destroy :update_counter_caches
+      end
+
+      private
+
+      def update_counter_caches?
+        @action_on_counter_caches = if made_publicly_visible? && !persisted?
+                                      :increment_but_tags
+                                    elsif made_publicly_visible? && persisted?
+                                      :increment
+                                    elsif made_publicly_invisible?
+                                      :decrement
+                                    else
+                                      :nothing
+                                    end
+      end
+
+      def update_counter_caches_on_delete?
+        @action_on_counter_caches = if publicly_visible?
+                                      :decrement
+                                    else
+                                      :nothing
+                                    end
+      end
+
+      def update_counter_caches
+        if @action_on_counter_caches == :increment
+          increment_counter_caches
+        elsif @action_on_counter_caches == :increment_but_tags
+          increment_counter_caches false
+        elsif @action_on_counter_caches == :decrement
+          decrement_counter_caches
+        end
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def increment_counter_caches(update_created_on_the_fly = true)
+        User.increment_counter "#{self.class.table_name}_count", user.id
+        Language.increment_counter "#{self.class.table_name}_count", language.id
+        License.increment_counter "#{self.class.table_name}_count", license.id
+
+        return unless update_created_on_the_fly
+
+        tags.each { |tag| tag.increment! "#{self.class.table_name}_count" }
+
+        self.class::ADDITIONAL_HABTM_COUNTER_CACHES.each do |relation|
+          send(relation[0]).each { |entity| entity.increment! "#{relation[1]}_count" }
+        end
+      end
+
+      # rubocop:enable Metrics/AbcSize
+
+      # rubocop:disable Metrics/AbcSize
+      def decrement_counter_caches
+        User.decrement_counter "#{self.class.table_name}_count", user.id
+        Language.decrement_counter "#{self.class.table_name}_count", language.id
+        License.decrement_counter "#{self.class.table_name}_count", license.id
+
+        tags.each { |tag| tag.decrement! "#{self.class.table_name}_count" }
+
+        self.class::ADDITIONAL_HABTM_COUNTER_CACHES.each do |relation|
+          send(relation[0]).each { |entity| entity.decrement! "#{relation[1]}_count" }
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+    end
+  end
+end

data/app/models/elabs/concerns/taggable.rb

@@ -0,0 +1,33 @@
+module Elabs
+  module Concerns
+    module Taggable
+      extend ActiveSupport::Concern
+
+      included do
+        attr_writer :tags_list
+
+        after_save :save_tags_list
+      end
+
+      def save_tags_list
+        if @tags_list
+          tags = []
+          @tags_list.split(/, */).each do |t|
+            tags.push Tag.find_or_create_by(name: t.chomp)
+          end
+
+          @tags_list = nil
+
+          update(tags: tags) if tags.count.positive?
+        end
+
+        true
+      end
+
+      # Returns a list of comma-separated tags
+      def tags_list
+        @tags_list || tags.map(&:name).join(', ')
+      end
+    end
+  end
+end

data/app/models/elabs/language.rb

@@ -0,0 +1,17 @@
+module Elabs
+  class Language < ApplicationRecord
+    self.table_name = 'languages'
+
+    validates :iso639_1, presence: true
+    validates :name,     presence: true
+
+    has_many :albums
+    has_many :articles
+    has_many :notes
+    has_many :projects
+    has_many :uploads
+
+    scope :with_content_only, -> { where.not(albums_count: 0).or(where.not(articles_count: 0)).or(where.not(notes_count: 0)).or(where.not(projects_count: 0)).or(where.not(uploads_count: 0)) }
+    scope :available_site_translations, -> { select(:id, :name, :iso639_1).where(iso639_1: I18n.available_locales) }
+  end
+end

data/app/models/elabs/license.rb

@@ -0,0 +1,15 @@
+module Elabs
+  class License < ApplicationRecord
+    self.table_name = 'licenses'
+
+    validates :name, presence: true
+    validates :url,  presence: true
+    validates :icon, presence: true
+
+    has_many :albums
+    has_many :articles
+    has_many :notes
+    has_many :projects
+    has_many :uploads
+  end
+end

data/app/models/elabs/note.rb

@@ -0,0 +1,21 @@
+module Elabs
+  class Note < ApplicationContentRecord
+    self.table_name = 'notes'
+
+    ADDITIONAL_HABTM_COUNTER_CACHES = [
+      %w[projects notes]
+    ].freeze
+
+    validates :content, presence: true
+    validates_with AssociatedAuthorValidator, relations: %w[project]
+
+    belongs_to :user
+    belongs_to :license
+    belongs_to :language
+    has_many :notes_tags
+    has_many :projects_notes
+    has_many :tags,     through: :notes_tags,     dependent: :destroy
+    has_many :projects, through: :projects_notes, dependent: :destroy
+    has_many :comments, as: 'content'
+  end
+end

data/app/models/elabs/notes_tag.rb

@@ -0,0 +1,21 @@
+module Elabs
+  class NotesTag < ApplicationRecord
+    self.table_name = 'notes_tags'
+
+    belongs_to :note
+    belongs_to :tag
+
+    after_create :increment_counter_cache
+    after_destroy :decrement_counter_cache
+
+    private
+
+    def increment_counter_cache
+      tag.increment! :notes_count if note.publicly_visible?
+    end
+
+    def decrement_counter_cache
+      tag.decrement! :notes_count if note.publicly_visible?
+    end
+  end
+end

data/app/models/elabs/preference.rb

@@ -0,0 +1,9 @@
+module Elabs
+  class Preference < ApplicationRecord
+    self.table_name = 'preferences'
+
+    validates :locale, inclusion: { in: %w[en fr] }, allow_blank: true
+
+    belongs_to :user
+  end
+end

data/app/models/elabs/project.rb

@@ -0,0 +1,25 @@
+module Elabs
+  class Project < ApplicationContentRecord
+    self.table_name = 'projects'
+
+    validates :name,              presence: true
+    validates :short_description, presence: true
+    validates :description,       presence: true
+    validates_with AssociatedAuthorValidator, relations: %w[album article note upload]
+
+    belongs_to :user
+    belongs_to :license
+    belongs_to :language
+    has_many :projects_tags
+    has_many :projects_albums
+    has_many :projects_articles
+    has_many :projects_notes
+    has_many :projects_uploads
+    has_many :tags,     through: :projects_tags,     dependent: :destroy
+    has_many :albums,   through: :projects_albums,   dependent: :destroy
+    has_many :articles, through: :projects_articles, dependent: :destroy
+    has_many :notes,    through: :projects_notes,    dependent: :destroy
+    has_many :uploads,  through: :projects_uploads,  dependent: :destroy
+    has_many :comments, as: 'content'
+  end
+end

data/app/models/elabs/projects_album.rb

@@ -0,0 +1,21 @@
+module Elabs
+  class ProjectsAlbum < ApplicationRecord
+    self.table_name = 'projects_albums'
+
+    belongs_to :project
+    belongs_to :album
+
+    after_create :increment_counter_cache
+    after_destroy :decrement_counter_cache
+
+    private
+
+    def increment_counter_cache
+      project.increment! :albums_count if album.publicly_visible?
+    end
+
+    def decrement_counter_cache
+      project.decrement! :albums_count if album.publicly_visible?
+    end
+  end
+end