cas-cms 0.1.0

data/app/controllers/cas/sections/categories_controller.rb

@@ -0,0 +1,47 @@
+require_dependency "cas/application_controller"
+
+module Cas
+  class Sections::CategoriesController < Sections::ApplicationController
+    before_action :set_category, only: [:edit, :update, :destroy]
+
+    def index
+      @categories = @section.categories
+    end
+
+    def new
+      @category = ::Cas::Category.new
+    end
+
+    def edit
+    end
+
+    def create
+      @category = ::Cas::Category.new(category_params)
+      @category.section = @section
+
+      if @category.save
+        redirect_to section_categories_url(@section), notice: 'Categoria salva com sucesso.'
+      else
+        render :new
+      end
+    end
+
+    def update
+      if @category.update(category_params)
+        redirect_to section_categories_url(@section), notice: 'Categoria salva com sucesso.'
+      else
+        render :edit
+      end
+    end
+
+    private
+
+    def set_category
+      @category = ::Cas::Category.find(params[:id])
+    end
+
+    def category_params
+      params.require(:category).permit(:name)
+    end
+  end
+end

data/app/controllers/cas/sections/contents_controller.rb

@@ -0,0 +1,144 @@
+require_dependency "cas/application_controller"
+
+module Cas
+  class Sections::ContentsController < Sections::ApplicationController
+    class FileBelongsToAnotherAttachable < StandardError; end
+    before_action :set_content_type
+
+    def index
+      @contents = scope_content_by_role(@section.contents)
+      @contents = @contents.order('created_at desc').page(params[:page]).per(25)
+    end
+
+    def new
+      @content = ::Cas::Content.new
+      load_categories
+    end
+
+    def create
+      @content = ::Cas::Content.new(content_params)
+
+      success = nil
+      begin
+        ActiveRecord::Base.transaction do
+          @content.author_id = current_user.id
+          @content.section_id = @section.id
+          @content.tag_list = content_params[:tag_list] if content_params[:tag_list]
+          success = @content.save!
+          associate_files(@content, :images)
+          associate_files(@content, :attachments)
+        end
+      rescue ActiveRecord::RecordInvalid
+        success = nil
+      end
+
+      if success
+        redirect_to section_contents_url(@section), notice: 'Noticia salva com sucesso.'
+      else
+        load_categories
+        render :new
+      end
+    end
+
+    def edit
+      @content = scope_content_by_role.friendly.find(params[:id])
+
+      if @content.created_at.present? && @content.date.blank?
+        @default_date = @content.created_at
+      else
+        @default_date = @content.date
+      end
+
+      load_categories
+    end
+
+    def update
+      @content = scope_content_by_role.friendly.find(params[:id])
+
+      success = nil
+      begin
+        ActiveRecord::Base.transaction do
+          @content.tag_list = content_params[:tag_list]
+          success = @content.update!(content_params)
+          associate_files(@content, :images)
+          associate_files(@content, :attachments)
+        end
+      rescue ActiveRecord::RecordInvalid
+        success = nil
+      end
+
+      if success
+        redirect_to section_contents_path
+      else
+        load_categories
+        render :edit
+      end
+    end
+
+    def destroy
+      @content = scope_content_by_role.friendly.find(params[:id])
+      @content.destroy
+
+      redirect_to section_contents_path
+    end
+
+    private
+
+    def set_content_type
+      @content_type = @section.section_type
+    end
+
+    def content_params
+      @content_params ||= begin
+        result = params.require(:content).permit(
+          :category_id,
+          :title,
+          :location,
+          :summary,
+          :published,
+          :date,
+          :text,
+          :url,
+          :embedded,
+          :tag_list
+        )
+
+        unless result.keys.map(&:to_sym).include?(:published)
+          result[:published] = true
+        end
+
+        if params.dig(:content, :metadata).present?
+          # TODO the survey is sending empty questions and these
+          # are being saved anyway. We need to filter these.
+          result[:metadata] = params.dig(:content, :metadata).to_unsafe_h
+        end
+
+        result
+      end
+    end
+
+    # form_key_name could be :images or :attachments
+    def associate_files(item, form_key_name)
+      return if params[form_key_name].blank?
+
+      ActiveRecord::Base.transaction do
+        params[form_key_name][:files].to_unsafe_h.each do |key, value|
+          next if value["id"].blank?
+          begin
+            new_order = key.to_i + 1
+            is_cover = params[form_key_name][:cover_id] == value["id"]
+            image = ::Cas::MediaFile.find(value["id"])
+            if image.attachable.blank?
+              image.update!(cover: is_cover, order: new_order, attachable: item)
+            elsif image.order.to_i != new_order || image.cover != is_cover
+              image.update!(cover: is_cover, order: new_order)
+            elsif image.attachable != item
+              raise FileBelongsToAnotherAttachable, "File already belongs to #{item.attachable.id}"
+            end
+          rescue ActiveRecord::RecordNotFound
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/cas/sections_controller.rb

@@ -0,0 +1,7 @@
+module Cas
+  class SectionsController < ApplicationController
+    def index
+      @sections = Section.all
+    end
+  end
+end

data/app/controllers/cas/users_controller.rb

@@ -0,0 +1,61 @@
+require_dependency "cas/application_controller"
+
+module Cas
+  class UsersController < ApplicationController
+    def index
+      @users = ::Cas::User.order('name ASC')
+    end
+
+    def new
+      @user = ::Cas::User.new
+    end
+
+    def create
+      @user = ::Cas::User.new(user_params)
+      @user.roles = user_params[:roles]
+      if @user.save
+        redirect_to users_path
+      else
+        render :new
+      end
+    end
+
+    def edit
+      @user = ::Cas::User.find(params[:id])
+    end
+
+    def update
+      @user = ::Cas::User.find(params[:id])
+      success = nil
+      if user_params[:password].blank? && user_params[:password_confirmation].blank?
+        without_password = user_params.except(:password, :password_confirmation)
+        success = @user.update_without_password(without_password)
+      else
+        success = @user.update_attributes(user_params)
+      end
+
+      if success
+        redirect_to users_path
+      else
+        render 'edit'
+      end
+    end
+
+    private
+
+    def user_params
+      params
+        .require(:user)
+        .permit(
+          :name,
+          :email,
+          :password,
+          :password_confirmation,
+          :roles
+        )
+        .merge!(
+          roles: [params[:user][:roles]]
+        )
+    end
+  end
+end

data/app/helpers/cas/application_helper.rb

@@ -0,0 +1,4 @@
+module Cas
+  module ApplicationHelper
+  end
+end

data/app/helpers/cas/form_helper.rb

@@ -0,0 +1,11 @@
+module Cas
+  module FormHelper
+    def display_field?(name)
+      ::Cas::SectionConfig.new(@section).form_has_field?(name)
+    end
+
+    def field_properties(name)
+      ::Cas::FormField.new(@section, name)
+    end
+  end
+end

data/app/jobs/cas/application_job.rb

@@ -0,0 +1,4 @@
+module Cas
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/jobs/cas/images/delete_job.rb

@@ -0,0 +1,11 @@
+module Cas
+  module Images
+    class DeleteJob
+      include ::Sidekiq::Worker
+
+      def perform(data)
+        ::Shrine::Attacher.delete(data)
+      end
+    end
+  end
+end

data/app/jobs/cas/images/promote_job.rb

@@ -0,0 +1,11 @@
+module Cas
+  module Images
+    class PromoteJob
+      include ::Sidekiq::Worker
+
+      def perform(data)
+        ::Shrine::Attacher.promote(data)
+      end
+    end
+  end
+end

data/app/jobs/cas/increment_pageviews_job.rb

@@ -0,0 +1,11 @@
+module Cas
+  class IncrementPageviewsJob
+    include ::Sidekiq::Worker
+
+    def perform(id, type)
+      if type == "content"
+        Cas::Content.find(id).increment!(:pageviews)
+      end
+    end
+  end
+end

data/app/models/cas/application_record.rb

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

data/app/models/cas/category.rb

@@ -0,0 +1,6 @@
+module Cas
+  class Category < ApplicationRecord
+    belongs_to :section
+    has_many :contents
+  end
+end

data/app/models/cas/content.rb

@@ -0,0 +1,59 @@
+module Cas
+  class Content < ApplicationRecord
+    include ::PgSearch
+    extend ::FriendlyId
+
+    friendly_id :title, use: :slugged
+    acts_as_taggable
+
+    serialize :metadata
+
+    belongs_to :section
+    belongs_to :category
+    belongs_to :author, class_name: Cas::User
+    has_many :images, ->{ where(media_type: :image).order("cas_media_files.order ASC") }, class_name: Cas::MediaFile, as: :attachable, dependent: :destroy
+    has_many :attachments, ->{ where(media_type: :attachment).order("cas_media_files.order ASC") }, class_name: Cas::MediaFile, as: :attachable, dependent: :destroy
+    has_one :cover_image, ->{ where(media_type: :image, cover: true) }, class_name: Cas::MediaFile, as: :attachable
+
+    validates :title, presence: true
+
+    before_validation :set_published_at
+    before_save :cache_tags
+
+    scope :published, ->{ where(published: true) }
+
+    pg_search_scope :search, ->(query) do
+      {
+        query: query,
+        against: [:title, :text, :location, :tags_cache],
+        order_within_rank: "cas_contents.published_at DESC"
+      }
+    end
+
+    def date_year
+      date.year
+    end
+
+    def metadata
+      if self[:metadata].is_a?(String)
+        JSON.parse(self[:metadata])
+      else
+        super
+      end
+    end
+
+    private
+
+    def set_published_at
+      if published_at.blank? && published
+        self.published_at = Time.now
+      end
+    end
+
+    # so we can fulltext search appropriatelly with pg_search
+    def cache_tags
+      category_name = "#{category.name if category.present?}"
+      self.tags_cache = (tag_list + category_name).flatten.join(", ")
+    end
+  end
+end

data/app/models/cas/media_file.rb

@@ -0,0 +1,77 @@
+module Cas
+  class MediaFile < ApplicationRecord
+    include FileUploader::Attachment.new(:file)
+
+    class UnknownPath < StandardError; end
+    class UnknownFileService < StandardError; end
+
+    belongs_to :attachable, polymorphic: true
+    belongs_to :author, class_name: "Cas::User"
+
+    before_validation :set_media_type
+    before_save :set_image_as_unique_cover
+
+    scope :cover, ->{ where(cover: true) }
+    scope :non_cover, ->{ where(cover: false) }
+    scope :usable, -> { where.not(attachable_id: nil) }
+
+    def url(version:, use_cdn: true)
+      cdn = ENV.fetch("CDN_HOST", nil) if use_cdn
+
+      # When `path` is present, it means no gem was used for uploads, therefore
+      # the image has to be treat as raw URL.
+      if path.present?
+        if service.downcase == "s3"
+          bucket = ENV.fetch('S3_BUCKET')
+          region = ENV.fetch('S3_REGION', "s3")
+          if cdn
+            host = cdn
+          else
+            host = "https://s3-#{region}.amazonaws.com/#{bucket}"
+          end
+
+          [host, path].join("/").gsub(/([^:])\/\//, '\1/')
+        else
+          raise UnknownFileService
+        end
+
+      # Shrine gem uses `file_data`
+      elsif JSON.parse(file_data).present?
+        if cdn.present?
+          file_url(version.to_sym, host: cdn, public: true)
+        else
+          file_url(version.to_sym, public: true).gsub(/\?.*/, "")
+        end
+      else
+        raise UnknownPath
+      end
+    end
+
+    private
+
+    def set_media_type
+      if self.media_type.blank?
+        nature = mime_type.scan(/([a-z]*)\/.*/)[0][0]
+        if nature == 'image'
+          self.media_type = 'image'
+        else
+          self.media_type = 'attachment'
+        end
+      end
+    end
+
+    # Only images can have a `cover`
+    def set_image_as_unique_cover
+      return unless media_type == 'image'
+      cover_file = MediaFile
+        .where(attachable: self.attachable, cover: true)
+        .where.not(id: id)
+
+      if cover?
+        cover_file.update_all(cover: false)
+      elsif cover_file.blank?
+        self.cover = true
+      end
+    end
+  end
+end