camaleon_cms_rails6 2.5.0

data/app/controllers/camaleon_cms/frontend_controller.rb

@@ -0,0 +1,277 @@
+class CamaleonCms::FrontendController < CamaleonCms::CamaleonController
+  before_action :init_frontent
+  include CamaleonCms::FrontendConcern
+  include CamaleonCms::Frontend::ApplicationHelper
+  layout Proc.new { |controller| args = {layout: (params[:cama_ajax_request].present? ? "cama_ajax" : PluginRoutes.static_system_info['default_layout']), controller: controller}; hooks_run("front_default_layout", args); args[:layout] }
+  before_action :before_hooks
+  after_action :after_hooks
+  # rescue_from ActiveRecord::RecordNotFound, with: :page_not_found
+
+  # home page for frontend
+  def index
+    @cama_visited_home = true
+    if @_site_options[:home_page].present?
+      render_post(@_site_options[:home_page].to_i)
+    else
+      r = {layout: nil, render: "index"}; hooks_run("on_render_index", r)
+      render r[:render], (!r[:layout].nil? ? {layout: r[:layout]} : {})
+    end
+  end
+
+  # render category list
+  def category
+    begin
+      @category = current_site.the_full_categories.find(params[:category_id]).decorate
+      @post_type = @category.the_post_type
+    rescue
+      return page_not_found
+    end
+    @cama_visited_category = @category
+    @children = @category.children.no_empty.decorate
+    @posts = @category.the_posts.paginate(:page => params[:page], :per_page => current_site.front_per_page).eager_load(:metas)
+    r_file = lookup_context.template_exists?("category_#{@category.the_slug}") ? "category_#{@category.the_slug}" : nil  # specific template category with specific slug within a posttype
+    r_file = lookup_context.template_exists?("post_types/#{@post_type.the_slug}/category") ? "post_types/#{@post_type.the_slug}/category" : nil unless r_file.present? # default template category for all categories within a posttype
+    r_file = lookup_context.template_exists?("categories/#{@category.the_slug}") ? "categories/#{@category.the_slug}" : 'category' unless r_file.present?  # default template category for all categories for all posttypes
+
+    layout_ = lookup_context.template_exists?("layouts/post_types/#{@post_type.the_slug}/category") ? "post_types/#{@post_type.the_slug}/category" : nil unless layout_.present? # layout for all categories within a posttype
+    layout_ = lookup_context.template_exists?("layouts/categories/#{@category.the_slug}") ? "categories/#{@category.the_slug}" : nil unless layout_.present? # layout for categories for all post types
+    r = {category: @category, layout: layout_, render: r_file}; hooks_run("on_render_category", r)
+    render r[:render], (!r[:layout].nil? ? {layout: r[:layout]} : {})
+  end
+
+  # render contents from post type
+  def post_type
+    begin
+      @post_type = current_site.post_types.find_by_slug(params[:post_type_slug]).decorate
+    rescue
+      return page_not_found
+    end
+    @object = @post_type
+    @cama_visited_post_type = @post_type
+    @posts = @post_type.the_posts.paginate(:page => params[:page], :per_page => current_site.front_per_page).eager_load(:metas)
+    @categories = @post_type.categories.no_empty.eager_load(:metas).decorate
+    @post_tags = @post_type.post_tags.eager_load(:metas)
+    r_file = lookup_context.template_exists?("post_types/#{@post_type.the_slug}") ? "post_types/#{@post_type.the_slug}" : "post_type"
+    layout_ = lookup_context.template_exists?("layouts/post_types/#{@post_type.the_slug}") ? "post_types/#{@post_type.the_slug}" : nil
+    r = {post_type: @post_type, layout: layout_, render: r_file};  hooks_run("on_render_post_type", r)
+    render r[:render], (!r[:layout].nil? ? {layout: r[:layout]} : {})
+  end
+
+  # render contents for the post tag
+  def post_tag
+    begin
+      if params[:post_tag_slug].present?
+        @post_tag = current_site.post_tags.find_by_slug(params[:post_tag_slug]).decorate
+      else
+        @post_tag = current_site.post_tags.find(params[:post_tag_id]).decorate
+      end
+      @post_type = @post_tag.the_post_type
+    rescue
+      return page_not_found
+    end
+    @object = @post_tag
+    @cama_visited_tag = @post_tag
+    @posts = @post_tag.the_posts.paginate(:page => params[:page], :per_page => current_site.front_per_page).eager_load(:metas)
+    r_file = lookup_context.template_exists?("post_types/#{@post_type.the_slug}/post_tag") ? "post_types/#{@post_type.the_slug}/post_tag" : 'post_tag'
+    layout_ = lookup_context.template_exists?("layouts/post_tag") ? "post_tag" : nil
+    r = {post_tag: @post_tag, layout: layout_, render: r_file}; hooks_run("on_render_post_tag", r)
+    render r[:render], (!r[:layout].nil? ? {layout: r[:layout]} : {})
+  end
+
+  # search contents
+  def search
+    breadcrumb_add(ct("search"))
+    items = params[:post_type_slugs].present? ? current_site.the_posts(params[:post_type_slugs].split(',')) : current_site.the_posts
+    @cama_visited_search = true
+    @param_search = params[:q]
+    layout_ = lookup_context.template_exists?("layouts/search") ? "search" : nil
+    r = {layout: layout_, render: "search", posts: nil}; hooks_run("on_render_search", r)
+    params[:q] = (params[:q] || '').downcase
+    @posts = r[:posts] != nil ? r[:posts] : items.where("LOWER(title) LIKE ? OR LOWER(content_filtered) LIKE ?", "%#{params[:q]}%", "%#{params[:q]}%")
+    @posts_size = @posts.size
+    @posts = @posts.paginate(:page => params[:page], :per_page => current_site.front_per_page)
+    render r[:render], (!r[:layout].nil? ? {layout: r[:layout]} : {})
+  end
+
+  # ajax requests
+  def ajax
+    r = {render_file: nil, render_text: "", layout: nil }
+    @cama_visited_ajax = true
+    hooks_run("on_ajax", r)
+    if r[:render_file]
+      render r[:render_file], (!r[:layout].nil? ? {layout: r[:layout]} : {})
+    else
+      render inline: r[:render_text]
+    end
+  end
+
+  # render a post
+  def post
+    if params[:draft_id].present?
+      draft_render
+    else
+      render_post(@post || params[:slug].to_s.split("/").last, true)
+    end
+  end
+
+  # render user profile
+  def profile
+    begin
+      @user = current_site.users.find(params[:user_id]).decorate
+    rescue
+      return page_not_found
+    end
+    @object = @user
+    @cama_visited_profile = true
+    layout_ = lookup_context.template_exists?("layouts/profile") ? "profile" : nil
+    r = {user: @user, layout: layout_, render: "profile"};  hooks_run("on_render_profile", r)
+    render r[:render], (!r[:layout].nil? ? {layout: r[:layout]} : {})
+  end
+
+  # render page not found
+  def render_page_not_found
+    page_not_found
+  end
+
+  private
+  # render a post from draft
+  def draft_render
+    post_draft = current_site.posts.drafts.find(params[:draft_id])
+    @object = post_draft
+
+    # let a hook override the ability for certain roles see drafts
+    args = { permitted: false }
+    hooks_run("on_render_draft_permitted", args)
+
+    if args[:permitted] || can?(:update, post_draft)
+      render_post(post_draft, false, nil, true)
+    else
+      page_not_found
+    end
+  end
+
+  # render a post
+  # post_or_slug_or_id: slug_post | id post | post object
+  # from_url: true/false => true (true, permit eval hooks "on_render_post")
+  def render_post(post_or_slug_or_id, from_url = false, status = nil, force_visit = false)
+    if post_or_slug_or_id.is_a?(String) # slug
+      @post = current_site.the_posts.find_by_slug(post_or_slug_or_id)
+    elsif post_or_slug_or_id.is_a?(Integer) # id
+      @post = current_site.the_posts.where(id: post_or_slug_or_id).first
+    else # model
+      @post = post_or_slug_or_id
+    end
+
+    @post = @post.try(:decorate)
+    if !@post.present? || !(force_visit || @post.can_visit?)
+      if params[:format] == 'html' || !params[:format].present?
+        page_not_found()
+      else
+        head 404
+      end
+    else
+      @object = @post
+      @cama_visited_post = @post
+      @post_type = @post.the_post_type
+      @comments = @post.the_comments
+      @categories = @post.the_categories
+      @post.increment_visits!
+
+      home_page = @_site_options[:home_page] rescue nil
+      if lookup_context.template_exists?("page_#{@post.id}")
+        r_file = "page_#{@post.id}"
+      elsif @post.get_template(@post_type).present? && lookup_context.template_exists?(@post.get_template(@post_type))
+        r_file = @post.get_template(@post_type)
+      elsif home_page.present? && @post.id.to_s == home_page
+        r_file = "index"
+      elsif lookup_context.template_exists?("post_types/#{@post_type.the_slug}/single")
+        r_file = "post_types/#{@post_type.the_slug}/single"
+      elsif lookup_context.template_exists?("#{@post_type.slug}")
+        r_file = "#{@post_type.slug}"
+      else
+        r_file = "single"
+      end
+
+      layout_ = nil
+      meta_layout = @post.get_layout(@post_type)
+      layout_ = meta_layout if meta_layout.present? && lookup_context.template_exists?("layouts/#{meta_layout}")
+      r = {post: @post, post_type: @post_type, layout: layout_, render: r_file}
+      hooks_run("on_render_post", r) if from_url
+
+      if status.present?
+        render r[:render], (!r[:layout].nil? ? {layout: r[:layout], status: status} : {status: status})
+      else
+        render r[:render], (!r[:layout].nil? ? {layout: r[:layout]} : {})
+      end
+    end
+  end
+
+
+  # render error page
+  def page_not_found()
+    if @_site_options[:error_404].present? && request.format.html? # render a custom error page
+      page_404 = current_site.posts.find(@_site_options[:error_404]) rescue ""
+      if page_404.present?
+        render_post(page_404, false, :not_found)
+        return
+      end
+    end
+    render_error(404)
+  end
+
+  # define frontend locale
+  # if url hasn't a locale, then it will use default locale set on application.rb
+  def init_frontent
+    # preview theme initializing
+    if cama_sign_in? && params[:ccc_theme_preview].present? && can?(:manage, :themes)
+      @_current_theme = (current_site.themes.where(slug: params[:ccc_theme_preview]).first_or_create!.decorate)
+    end
+
+    @_site_options = current_site.options
+    session[:cama_current_language] = params[:cama_set_language].to_sym if params[:cama_set_language].present?
+    session[:cama_current_language] = nil if current_site.get_languages.exclude?(session[:cama_current_language])
+    I18n.locale = params[:locale] || session[:cama_current_language] || current_site.get_languages.first
+    return page_not_found unless current_site.get_languages.include?(I18n.locale.to_sym) # verify if this locale is available for this site
+
+    # define render paths
+    lookup_context.prefixes.delete("frontend")
+    lookup_context.prefixes.delete("application")
+    lookup_context.prefixes.delete("camaleon_cms/frontend")
+    lookup_context.prefixes.delete("camaleon_cms/camaleon")
+    lookup_context.prefixes.delete("camaleon_cms/apps/plugins_front")
+    lookup_context.prefixes.delete("camaleon_cms/apps/themes_front")
+    lookup_context.prefixes.delete_if{|t| t =~ /themes\/(.*)\/views/i || t == "camaleon_cms/default_theme" || t == "themes/#{current_site.id}/views" }
+
+    lookup_context.prefixes.append("themes/#{current_site.id}/views") if Dir.exist?(Rails.root.join('app', 'apps', 'themes', current_site.id.to_s).to_s)
+    lookup_context.prefixes.append("themes/#{current_theme.slug}/views")
+    lookup_context.prefixes.append("camaleon_cms/default_theme")
+
+    lookup_context.prefixes = lookup_context.prefixes.uniq
+    lookup_context.use_camaleon_partial_prefixes = true
+    theme_init()
+  end
+
+  # initialize hooks before to execute action
+  def before_hooks
+    hooks_run("front_before_load")
+  end
+
+  # initialize hooks after executed action
+  def after_hooks
+    hooks_run("front_after_load")
+  end
+
+  # define default options for url helpers
+  # control for default locale
+  def default_url_options(options = {})
+    begin
+      if current_site.get_languages.first.to_s == I18n.locale.to_s
+        options
+      else
+        { locale: I18n.locale }.merge options
+      end
+    rescue
+      options
+    end
+  end
+end

data/app/controllers/concerns/camaleon_cms/frontend_concern.rb

@@ -0,0 +1,66 @@
+module CamaleonCms::FrontendConcern extend ActiveSupport::Concern
+  # visiting sitemap.xml
+  # With hook "on_render_sitemap" you can skip post_types, categories, tags or posts
+  #   you can change render file and layout
+  #   you can add custom sitemap elements in the attr "custom", like: https://github.com/owen2345/camaleon-cms/issues/106#issuecomment-146232211
+  #   you can customize your content for html or xml format
+  def sitemap
+    r = {layout: (params[:format] == "html" ? nil : false), render: "sitemap", custom: {}, format: params[:format], skip_post_ids: [], skip_posttype_ids: [], skip_cat_ids: [], skip_tag_ids: []}
+    hooks_run("on_render_sitemap", r)
+    @r = r
+    render r[:render], (!r[:layout].nil? ? {layout: r[:layout]} : {})
+  end
+
+  # accessing for robots.txt
+  def robots
+    r = {layout: false, render: "robots"}
+    hooks_run("on_render_robots", r)
+    render r[:render], layout: r[:layout]
+  end
+
+  # rss for current site
+  def rss
+    r = {layout: false, render: "rss"}
+    hooks_run("on_render_rss", r)
+    render r[:render], layout: r[:layout], formats: [:rss]
+  end
+
+  # save comment from a post
+  def save_comment
+    flash[:comment_submit] = {}
+    @post = current_site.posts.find_by_id(params[:post_id]).decorate
+    user = cama_current_user
+    comment_data = {}
+    flash[:comment_submit][:error] = t('.comments_not_enabled', default: 'This post can not be commented') if !@post.can_commented?
+    if user.present?
+      comment_data[:author] = user.fullname
+      comment_data[:author_email] = user.email
+    elsif current_site.get_option('permit_anonimos_comment', false)
+      user = current_site.get_anonymous_user
+      comment_data[:is_anonymous] = true
+      comment_data[:author] = params[:post_comment][:name]
+      comment_data[:author_email] = params[:post_comment][:email]
+      flash[:comment_submit][:error] = t('camaleon_cms.admin.users.message.error_captcha', default: 'Invalid captcha value') if current_site.is_enable_captcha_for_comments? && !cama_captcha_verified?
+    end
+
+    unless flash[:comment_submit][:error] 
+      if user.present?
+        comment_data[:user_id] = user.id
+        comment_data[:author_url] = params[:post_comment][:url] || ""
+        comment_data[:author_IP] = request.remote_ip.to_s
+        comment_data[:approved] = current_site.front_comment_status
+        comment_data[:agent] = request.user_agent.force_encoding("ISO-8859-1").encode("UTF-8")
+        comment_data[:content] = params[:post_comment][:content]
+        @comment = params[:post_comment][:parent_id].present? ? @post.comments.find_by_id(params[:post_comment][:parent_id]).children.new(comment_data) :  @post.comments.main.new(comment_data)
+        if @comment.save
+          flash[:comment_submit][:notice] = t('camaleon_cms.admin.comments.message.created')
+        else
+          flash[:comment_submit][:error] = "#{t('camaleon_cms.common.comment_error', default: 'An error was occurred on save comment')}:<br> #{@comment.errors.full_messages.join(', ')}"
+        end
+      else
+        flash[:comment_submit][:error] = t('camaleon_cms.admin.message.unauthorized')
+      end
+    end
+    params[:format] == 'json' ? render(json: flash.discard(:comment_submit).to_hash) : redirect_to(request.referer || @post.the_url(as_path: true))
+  end
+end

data/app/decorators/camaleon_cms/application_decorator.rb

@@ -0,0 +1,54 @@
+class CamaleonCms::ApplicationDecorator < Draper::Decorator
+  delegate_all
+  @_deco_locale = nil
+  include CamaleonCms::MetasDecoratorMethods
+
+  # return the keywords for this model
+  def the_keywords
+    k = object.get_option("keywords", "")
+    k = h.current_site.the_keywords if object.class.name != "CamaleonCms::Site" && !k.present?
+    k.to_s.translate(get_locale)
+  end
+
+  def the_slug(locale = nil)
+    object.slug.translate(get_locale(locale))
+  end
+
+  # return the identifier
+  def the_id
+    "#{object.id}"
+  end
+
+  # return created at date formatted
+  def the_created_at(format = :long)
+    h.l(object.created_at, format: format.to_sym)
+  end
+
+  # return updated at date formatted
+  def the_updated_at(format = :long)
+    h.l(object.updated_at, format: format.to_sym)
+  end
+
+  # draw breadcrumb for this model
+  # add_post_type: true/false to include post type link
+  def the_breadcrumb(add_post_type = true)
+    generate_breadcrumb(add_post_type)
+    h.breadcrumb_draw
+  end
+
+  # ---------------------
+  def set_decoration_locale(locale)
+    @_deco_locale = locale.to_sym
+  end
+
+  # get the locale for current decorator
+  def get_locale(locale = nil)
+    locale || @_deco_locale || (h.cama_get_i18n_frontend rescue nil) || I18n.locale
+  end
+
+  # return the current locale prefixed to add in frontend routes
+  def _calc_locale(_l)
+    _l = (_l || @_deco_locale || (h.cama_get_i18n_frontend rescue nil) || I18n.locale).to_s
+    "_#{_l}"
+  end
+end

data/app/decorators/camaleon_cms/category_decorator.rb

@@ -0,0 +1,58 @@
+class CamaleonCms::CategoryDecorator < CamaleonCms::TermTaxonomyDecorator
+  delegate_all
+
+  # return the public url for this category
+  def the_url(*args)
+    args = args.extract_options!
+    args[:category_id] = the_id
+    args[:label] = I18n.t("routes.category", default: "category")
+    args[:title] = the_title.parameterize.presence || the_slug
+    args[:locale] = @_deco_locale unless args.include?(:locale)
+    args[:format] = args[:format] || "html"
+    as_path = args.delete(:as_path)
+    h.cama_url_to_fixed("cama_category_#{as_path.present? ? "path" : "url"}", args)
+  end
+
+  # return edit url for this category
+  def the_edit_url
+    h.edit_cama_admin_post_type_category_url(object.post_type.id, object)
+  end
+
+  # return all children categories for the current category (active_record) filtered by permissions + hidden posts + roles + etc...
+  # in return object, you can add custom where's or pagination like here:
+  # http://edgeguides.rubyonrails.org/active_record_querying.html
+  def the_categories
+    object.children
+  end
+
+  # return a child category from this category with id (integer) or by slug (string)
+  def the_category(slug_or_id)
+    return object.categories.where(id: slug_or_id).first if slug_or_id.is_a?(Integer)
+    return object.categories.find_by_slug(slug_or_id) if slug_or_id.is_a?(String)
+  end
+
+  # ---------------------
+  # add_post_type: true/false to include post type link
+  # is_parent: true/false (internal control)
+  def generate_breadcrumb(add_post_type = true, is_parent = false)
+    _parent = object.parent
+    if _parent.present?
+      _parent.decorate.generate_breadcrumb(add_post_type, true)
+    else
+      object.post_type_parent.decorate.generate_breadcrumb(add_post_type, true)
+    end
+    h.breadcrumb_add(self.the_title, is_parent ? self.the_url : nil)
+  end
+
+  # return thumbnail for this post type
+  # default: if thumbnail is not present, will render default
+  def the_thumb_url(default = nil)
+    th = object.get_option("thumb")
+    th.present? ? th : (default || h.asset_path("camaleon_cms/category-icon.png"))
+  end
+
+  # return the post type of this post tag
+  def the_post_type
+    object.post_type.decorate
+  end
+end