pages_controller.rb 9.95 KB
module Kanjai
  class PagesController < SiteController

    include Admin::PagesHelper

    #after_action :skip_set_cookies_header


    def show
      render_status = @page_data.page == @page_data.page.domain.page_404 ? 401 : 200
      domain = @page_data.page.domain

      if @page_data.page.block?
        render :template => 'kanjai/shared/401', status: 401, layout: false and return
      end
      #expires_in 10.minutes, :public => true
      if @page_data
        if @page_data.page.private_flag == true
          if defined?(warden).to_s == 'method'
            if warden.user.nil?
              if domain.page_404.present?
                page_404_data = domain.page_404.page_data.find_by(lang: I18n.locale)
                render html: GeneratePageContent.new(page_data: page_404_data, session: session, current_admin_user: current_admin_user).call.html_safe, status: 404 and return
              else
                render :template => 'kanjai/shared/401', status: 401, layout: false and return
              end
            end
          end
        end
        #look - exist template or not for page
        if  @page_data.page.page_template
          use_cache = true
          if defined?(warden).to_s == 'method'
            if warden.user.present?
              use_cache = false
            end
          end

          use_cache = false

          if current_admin_user || @page_data.page.private_flag == true || use_cache == false
            layer = @page_data.page.page_template.get_html_content
            content_for_render = setTemplateContent(@page_data.page.domain, @page_data.page.page_template, layer, @page_data, nil)
            if @page_data.page.domain.template.present?
              doc = Nokogiri::HTML(content_for_render)
              layer = @page_data.page.domain.template.get_html_content
              content_for_render = setTemplateContent(@page_data.page.domain, @page_data.page.domain.template, layer, @page_data, doc.at('body').inner_html)
            end

            respond_to do |format|
              format.html{render :plain => content_for_render, status: render_status}
            end

            #render :text => content_for_render and return
          else
            if stale?(last_modified: @page_data.last_modified, etag: @page_data.cache_key_with_version)
              layer = @page_data.page.page_template.get_html_content
              content_for_render = setTemplateContent(@page_data.page.domain, @page_data.page.page_template, layer, @page_data, nil)
              if @page_data.page.domain.template.present?
                doc = Nokogiri::HTML(content_for_render)
                layer = @page_data.page.domain.template.get_html_content
                content_for_render = setTemplateContent(@page_data.page.domain, @page_data.page.domain.template, layer, @page_data, doc.at('body').inner_html)
              end

              respond_to do |format|
                format.html{render :plain => content_for_render, status: render_status}
              end
            end
          end
        else
          page_content = get_html_by_json_client(@page_data, session)
          render :html => page_content.html_safe, status: render_status and return
        end


      else
        if domain.page_404.present?
          page_404_data = domain.page_404.page_data.find_by(lang: I18n.locale)
          render html: GeneratePageContent.new(page_data: page_404_data, session: session, current_admin_user: current_admin_user).call.html_safe, status: 404 and return
        else
          render :template => 'kanjai/shared/404', status: 404, layout: false and return
        end
      end
    end



    private

    def class_exists?(class_name)
      klass = Module.const_get(class_name)
      return klass.is_a?(Class)
    rescue NameError
      return false
    end


    def setTemplateContent(domain, page_template, layer, page_data, page_content_for_insert)

      session[:scheme] = 'http://'

      unless current_admin_user
        layer.gsub!('<meta name="csrf-param" content="###CSRF_PARAM###"/>', '')
        layer.gsub!('<meta name="csrf-token" content="###CSRF_TOKEN###"/>', '')
      end

      domain.page_langs.each do |item|
        if item.code.to_s != I18n.locale.to_s
          layer.gsub!(/<language code=\"#{item.code}\">(.*?)<\/language>/m, '')
        end
      end

      layer.gsub!(/<language code=\"#{I18n.locale.to_s}\">/, '')
      layer.gsub!(/<\/language>/, '')

      


      layer.scan(/(<element name="([\w\W]*?)" type="([\w\W]+?)"><\/element>)/).each do |item|
        content = item[0]
        name = item[1].to_s
        type = item[2]
        code = name.parameterize

        if type == "menu" && name.to_s.empty?
          template_part = nil
          template_part = page_template.template_parts.find_by_code(page_template.menu) if template_part.nil? && page_template.menu.present?
          template_part = page_template.template_parts.where(part_type: 'menu').order(:name).first if template_part.nil?
        else
          template_part = page_template.template_parts.find_by_code(code)
        end

        if template_part
          html = TemplateGenerator::subpart_generate(session, domain, page_template, template_part.part_type, template_part.elements)
          layer.gsub!(content, html)
        end
      end
      
      (0..1).each do |index|
        layer.scan(/(<element name="([\w\W]*?)"><\/element>)/).each do |item|
          content = item[0]
          name = item[1].to_s
          code = name.parameterize

          template_part = page_template.template_parts.find_by_code(code)

          if template_part
            html = TemplateGenerator::subpart_generate(session, domain, page_template, template_part.part_type, template_part.elements)
            layer.gsub!(content, html)
          end
        end
      end

      #try find in static elements
      page_template.page_content_markers.where(lang: I18n.locale).each do |marker|
        layer.gsub!(marker.marker, marker.text_value.to_s)
      end

      markers = PageTemplate.get_marker(layer)

      markers.each do |marker|
        case marker
          when '###CONTENT###'
            if page_content_for_insert.nil?
              page_content = get_html_by_json_client(page_data, session)
              layer.gsub!(marker, page_content)
              layer.gsub!('make-checked="false"', '')
              layer.gsub!("make-checked='false'", '')
              layer.gsub!('make-checked=""', '')
              layer.gsub!("make-checked=''", '')            

              layer.gsub!('make-checked="checked"', 'checked')
              layer.gsub!("make-checked='checked'", 'checked')            
              layer.gsub!('make-checked="true"', 'checked')
              layer.gsub!("make-checked='true'", 'checked')                        
            else
              layer.gsub!(marker, page_content_for_insert)
            end
          when '###META_TITLE###'
            layer.gsub!(marker, page_data.meta_title.to_s)
          when '###META_DESCRIPTION###'
            layer.gsub!(marker, page_data.meta_description.to_s)
          when '###META_KEYWORDS###'
            layer.gsub!(marker, page_data.meta_keywords.to_s)
          when '###BODY_CONTENT_EDIT_CLASS_NAME###'
            body_class_name = ''
            body_class_name = 'editable-content' if current_admin_user
            layer.gsub!(marker, body_class_name)
          when '###VARIABLE_FOR_EDIT_CONTENT###'
            content = ''
            if current_admin_user
              content = show_frontend_editor_admin_page_url(@page_data.page, lang: @page_data.lang)
            end
            layer.gsub!(marker, content)
          when '###CSRF_PARAM###'
            if current_admin_user || (class_exists?('UserSession') && UserSession.current_user)
              layer.gsub!(marker, Rack::Utils.escape_html(request_forgery_protection_token))
            end
          when '###CSRF_TOKEN###'
            if current_admin_user || (class_exists?('UserSession') && UserSession.current_user)
              layer.gsub!(marker, Rack::Utils.escape_html(form_authenticity_token))
            end
          when '###DOMAIN_NAME###'
            layer.gsub!(marker, session[:scheme] + ADMIN_CONFIG['domain_name'])
          when '###INCLUDE_JS_FILE###'
            js_array = []
            if params[:format].to_s != 'pdf'
              if current_admin_user
                js_array << "<script src='#{session[:scheme]}#{ADMIN_CONFIG['domain_name']}#{ActionController::Base.helpers.asset_path('kanjai/frontend.js')}'></script>"
                css_path = "#{session[:scheme]}#{ADMIN_CONFIG['domain_name']}#{ActionController::Base.helpers.asset_path('kanjai/frontend.css')}"
                js_array << "<script type='text/javascript'>$('<link>', {rel: 'stylesheet',type: 'text/css',href: '#{css_path}'}).appendTo('head');</script>"
              else
                js_array << "<script src='#{session[:scheme]}#{ADMIN_CONFIG['domain_name']}#{ActionController::Base.helpers.asset_path('kanjai/frontend_not_login.js')}'></script>"
              end
              js_array << "<script src='#{session[:scheme]}#{ADMIN_CONFIG['domain_name']}#{ActionController::Base.helpers.asset_path('kanjai/frontend_extend.js')}'></script>"
              css_path = "#{session[:scheme]}#{ADMIN_CONFIG['domain_name']}#{ActionController::Base.helpers.asset_path('kanjai/frontend_extend.css')}"
              js_array << "<script type='text/javascript'>$('<link>', {rel: 'stylesheet',type: 'text/css',href: '#{css_path}'}).appendTo('head');</script>"
            end
            layer.gsub!(marker, js_array.join(''))
          else
            #if PageMarker.public_instance_methods.include?("process_#{marker.gsub('###', '')}".to_sym)
            #  page_marker = PageMarker.new
            #  content = page_marker.method("process_#{marker.gsub('###', '')}").call(page_data)
            #  layer.gsub!(marker, content)
            #end

        end
      end

      return layer

    end

    def skip_set_cookies_header
      unless current_admin_user
        request.session_options = {}
      end
    end




  end
end