camaleon_cms_rails6 2.5.0

data/app/helpers/camaleon_cms/session_helper.rb

@@ -0,0 +1,161 @@
+module CamaleonCms::SessionHelper
+  # log in the user in to system
+  # user: User model
+  # remember_me: true/false (remember session permanently)
+  # redirect_url (default nil): after initialized the session, this will be redirected to
+  #   "redirect_url" if defined
+  #   it doesn't redirect if redirect_url === false
+  #   return to previous page if defined the cookie['return_to'] or login url received extra param: return_to=http://mysite.com
+  def login_user(user, remember_me = false, redirect_url = nil)
+    c = {value: [user.auth_token, request.user_agent, request.ip], expires: 24.hours.from_now}
+    c[:domain] = :all if PluginRoutes.system_info["users_share_sites"].present? && CamaleonCms::Site.count > 1
+    c[:expires] = 1.month.from_now if remember_me
+
+    # fix to overwrite a cookie
+    cookies.delete(:auth_token, domain: :all)
+    cookies.delete(:auth_token)
+
+    user.update({last_login_at: Time.zone.now})
+    cookies[:auth_token] = c
+
+    # user redirection
+    flash[:notice] = t('camaleon_cms.admin.login.message.success', locale: current_site.get_admin_language)
+    return if redirect_url === false
+    if redirect_url.present?
+      redirect_to redirect_url
+    elsif (return_to = cookies.delete(:return_to)).present?
+      redirect_to return_to
+    else
+      redirect_to cama_admin_dashboard_path
+    end
+  end
+
+  # login a user using username and password
+  # return boolean: true => authenticated, false => authentication failed
+  def login_user_with_password(username, password)
+    @user = current_site.users.find_by_username(username)
+    r = {user: @user, params: params, password: password, captcha_validate: true}; hooks_run('user_before_login', r)
+    @user && @user.authenticate(password)
+  end
+
+  ##
+  # User registration.
+  #
+  # user_data must contain:
+  # - first_name
+  # - email
+  # - username
+  # - password
+  # - password_confirmation
+
+  def cama_register_user(user_data, meta)
+    @user = current_site.users.new(user_data)
+    r = {user: @user, params: params}; hook_run('user_before_register', r)
+
+    if current_site.security_user_register_captcha_enabled? && !cama_captcha_verified?
+      {:result => false, :type => :captcha_error, :message => t('camaleon_cms.admin.users.message.error_captcha')}
+    else
+      if @user.save
+        @user.set_metas(meta)
+        message = current_site.need_validate_email? ? t('camaleon_cms.admin.users.message.created_pending_validate_email') : t('camaleon_cms.admin.users.message.created')
+        r = {user: @user, message: message, redirect_url: cama_admin_login_path}; hooks_run('user_after_register', r)
+        {:result => true, :message => r[:message], :redirect_url => r[:redirect_url]}
+      else
+        {:result => false, :type => :no_saved}
+      end
+    end
+  end
+
+  # check if current host is heroku
+  def cama_on_heroku?
+    ENV.keys.any? { |var_name| var_name.match(/(heroku|dyno)/i) }
+  end
+
+  # switch current session user into other (user)
+  # after switched, this will be redirected to redirect_url or admin dashboard
+  def session_switch_user(user, redirect_url = nil)
+    if cama_sign_in?
+      session[:parent_auth_token] = cookies[:auth_token]
+      login_user(user, false, redirect_url)
+    end
+  end
+
+  # switch current session into parent session called by session_switch_user
+  # after returned into parent session, this will be redirected to redirect_url or admin dashboard
+  def session_back_to_parent(redirect_url = nil)
+    if cama_sign_in? && session[:parent_auth_token].present?
+      cookies[:auth_token] = session[:parent_auth_token]
+      session.delete(:parent_auth_token)
+      redirect_to (redirect_url || cama_admin_dashboard_path), notice: "Welcome back!"
+    end
+  end
+
+  # logout current user
+  def cama_logout_user
+    cookies.delete(:auth_token, domain: :all)
+    cookies.delete(:auth_token, domain: nil)
+    c_data = {value: nil, expires: 24.hours.ago}
+    c_data[:domain] = :all if PluginRoutes.system_info["users_share_sites"].present? && CamaleonCms::Site.count > 1
+    cookies[:auth_token] = c_data
+    redirect_to params[:return_to].present? ? params[:return_to] : cama_admin_login_path, :notice => t('camaleon_cms.admin.logout.message.closed')
+  end
+
+  # check if current user is already signed
+  def cama_sign_in?
+    !cama_current_user.nil?
+  end
+
+  alias_method :signin?, :cama_sign_in?
+
+  # return the role for current user
+  # if not logged in, then return 'public'
+  def cama_current_role
+    current_site.visitor_role
+  end
+
+  # return current user logged in
+  def cama_current_user
+    return @cama_current_user if defined?(@cama_current_user)
+    # api current user...
+    @cama_current_user = cama_calc_api_current_user
+    return @cama_current_user if @cama_current_user
+
+    return nil unless cookies[:auth_token].present?
+    c = cookies[:auth_token].split("&")
+    return nil unless c.size == 3
+
+    @cama_current_user = current_site.users_include_admins.find_by_auth_token(c[0]).try(:decorate)
+  end
+
+  # check if a visitor was logged in
+  # if the user was not logged in, then redirect to login url
+  def cama_authenticate(redirect_uri = nil)
+    params[:return_to] = redirect_uri
+    unless cama_sign_in?
+      flash[:error] = t('camaleon_cms.admin.login.please_login')
+      cookies[:return_to] = params[:return_to].present? ? params[:return_to] : ((request.get? && params[:controller] != "admin/sessions") ? request.original_url : nil)
+      redirect_to cama_admin_login_path
+    end
+  end
+
+  # return the session id
+  def cama_get_session_id
+    session[:autor] = "Owen Peredo Diaz" unless request.session_options[:id].present?
+    id = request.session_options[:id]
+    id = id.public_id if id && id.class.name == 'Rack::Session::SessionId'
+    id
+  end
+
+  private
+  # calculate the current user for API
+  def cama_calc_api_current_user
+    begin
+      doorkeeper_token
+    rescue NameError
+      # hack, this method should be called from a context which has
+      # doorkeeper_token defined
+      return nil
+    end
+    current_site.users_include_admins.find_by_id(doorkeeper_token.resource_owner_id).try(:decorate) if doorkeeper_token
+  end
+end

data/app/helpers/camaleon_cms/short_code_helper.rb

@@ -0,0 +1,283 @@
+module CamaleonCms::ShortCodeHelper
+  # Internal method
+  def shortcodes_init
+    @_shortcodes = []
+    @_shortcodes_template = {}
+    @_shortcodes_descr = {}
+
+    shortcode_add("widget", nil, "Renderize the widget content in this place.
+                Don't forget to create and copy the shortcode of your widgets in appearance -> widgets
+                Sample: [widget widget_key]")
+
+    shortcode_add("load_libraries",
+                  lambda{|attrs, args|
+                    return args[:shortcode] unless attrs.present?
+                    cama_load_libraries(*attrs["data"].to_s.split(",")); return "";
+                  },
+                  "Permit to load libraries on demand, sample: [load_libraries data='datepicker,tinymce']")
+
+    shortcode_add("asset",
+                  lambda{|attrs, args|
+                    return args[:shortcode] unless attrs.present?
+                    url = attrs["as_path"].present? ? ActionController::Base.helpers.asset_url(attrs["file"]) : ActionController::Base.helpers.asset_url(attrs["file"])
+                    if attrs["image"].present?
+                      ActionController::Base.helpers.image_tag(attrs["file"], class: attrs["class"], style: attrs["style"])
+                    else
+                      url
+                    end
+                  },
+                  "Permit to generate an asset url (
+                    add file='' asset file path,
+                    add as_path='true' to generate only the path and not the full url,
+                    add class='my_class' to setup image class,
+                    add style='height: 100px; width: 200px;...' to setup image style,
+                    add image='true' to generate the image tag with this url),
+                  sample: <img src=\"[asset as_path='true' file='themes/my_theme/assets/img/signature.png']\" /> or [asset image='true' file='themes/my_theme/assets/img/signature.png' style='height: 50px;']")
+
+    shortcode_add("data",
+                  lambda{|attrs, args|
+                    attrs.present? ? (cama_shortcode_data(attrs, args)) : args[:shortcode]
+                  },
+                  "Permit to generate specific data of a post.
+                  Attributes:
+                    object: (String, defaut post) Model name: post | posttype | category | posttag | site | user |theme | navmenu
+                    id: (Integer) Post id
+                    key: (String) Post slug
+                    field: (String) Custom field key, you can add render_field='true' to render field as html element, also you can add index=2 to indicate the value in position 2 for multitple values
+                    attrs: (String) attribute name
+                            post: title | created_at | excerpt | url | link | thumb | updated_at | author_name | author_url | content
+                            posttype: title | created_at | excerpt | url | link | thumb | updated_at
+                            category: title | created_at | excerpt | url | link | thumb | updated_at
+                            posttag: title | created_at | excerpt | url | link | thumb | updated_at
+                            site: title | created_at | excerpt | url | link | thumb | updated_at
+                            user: title | created_at | excerpt | url | link | thumb | updated_at
+                            theme: title | created_at | excerpt | url | link | thumb | updated_at
+                            navmenu: title | created_at | excerpt | url | link | thumb | updated_at
+                    Note: If id and key is not present, then will be rendered for current model
+                  Sample:
+                    [data id='122' attr='title'] ==> return the title of post with id = 122
+                    [data key='contact' attr='url'] ==> return the url of post with slug = contact
+                    [data key='contact' attr='link'] ==> return the link with title as text of the link of post with slug = contact
+                    [data object='site' attr='url'] ==> return the url of currrent site
+                    [data key='page' object='posttype' attr='url'] ==> return the url of post_type with slug = page
+                    [data field=icon index=2] ==> return the second value (multiple values) for this custom field with key=icon of current object
+                    [data key='contact' field='sub_title'] ==> return the value of the custom_field with key=sub_title registered for post.slug = contact
+                    [data object='site' field='sub_title'] ==> return the value of the custom_field with key=sub_title registered for current_site")
+  end
+
+  # add shortcode
+  # key: shortcode key
+  # template: template to render, if nil will render "shortcode_templates/<key>"
+  # Also can be a function to execute that instead a render, sample: lambda{|attrs, args| return "my custom content"; }
+  # descr: description for shortcode
+  def shortcode_add(key, template = nil, descr = '')
+    @_shortcodes << key
+    @_shortcodes_template = @_shortcodes_template.merge({"#{key}"=> template}) if template.present?
+    @_shortcodes_descr[key] = descr if descr.present?
+  end
+
+  # add or update shortcode template
+  # key: chortcode key to add or update
+  # template: template to render, if nil will render "shortcode_templates/<key>"
+  def shortcode_change_template(key, template = nil)
+    @_shortcodes_template[key] = template
+  end
+
+  # delete shortcode
+  # key: chortcode key to delete
+  def shortcode_delete(key)
+    @_shortcodes.delete(key)
+  end
+
+  # run all shortcodes in the content
+  # content: (string) text to find a short codes
+  # args: custom arguments to pass for short codes render, sample: {owner: my_model, a: true}
+  #   if args != Hash, this will re send as args = {owner: args}
+  #   args should be include the owner model who is doing the action to optimize DB queries
+  # sample: do_shortcode("hello [greeting 'world']!", @my_post) ==> "hello world!"
+  # sample: do_shortcode("hello [greeting 'world']", {attr1: 'asd', owner: @my_post})
+  # return rendered string
+  def do_shortcode(content, args = {})
+    args = {owner: args} unless args.is_a?(Hash)
+    content.scan(/#{cama_reg_shortcode}/) do |item|
+      content = _cama_replace_shortcode(content, item, args)
+    end
+    content
+  end
+
+  # remove all shortcodes from text
+  # Arguments
+  #   text: String that contains shortcodes
+  # return String
+  def cama_strip_shortcodes(text)
+    text.gsub(/#{cama_reg_shortcode}/, "")
+  end
+
+  # render direct a shortcode
+  # text: text that contain the shortcode
+  # key: shortcode key
+  # template: template to render, if nil this will render default render file
+  # Also can be a function to execute that instead a render, sample: lambda{|attrs, args| return "my custom content"; }
+  # render_shortcode("asda dasdasdas[owen a='1'] [bbb] sdasdas dasd as das[owen a=213]", "owen", lambda{|attrs, args| puts attrs; return "my test"; })
+  def render_shortcode(text, key, template = nil)
+    text.scan(/#{cama_reg_shortcode(key)}/).each do |item|
+      text = _cama_replace_shortcode(text, item, {}, template)
+    end
+    text
+  end
+
+  private
+  # helper to replace shortcodes adding support for closed shortcodes, sample: [title]my title[/title]
+  def _cama_replace_shortcode(content, item, args = {}, template = nil)
+    shortcode, code, attrs = item
+    close_code = "[/#{code}]"
+    if content.include?(close_code)
+      shortcode_bk = shortcode
+      tmp_content = content[content.index(shortcode)..-1]
+      shortcode =  tmp_content[0..(tmp_content.index(close_code) + close_code.size - 1)]
+      args[:shortcode_content] = shortcode.sub(shortcode_bk, '').sub(close_code, '')
+    end
+    args[:shortcode] = shortcode
+    args[:code] = code
+    content.sub(shortcode, _eval_shortcode(code, attrs, args, template))
+  end
+
+  # create the regexpression for shortcodes
+  # codes: (String) shortcode keys separated by |
+  # sample: load_libraries|asset
+  # if empty, codes will be replaced with all registered shortcodes
+  # Return: (String) reg expression string
+  def cama_reg_shortcode(codes = nil)
+    # "(\\[(#{codes || (@_shortcodes || []).join("|")})(\s|\\]){0}(.*?)\\])" # doesn't support for similar names, like: [media] and [media_gallery]
+    "(\\[(#{codes || (@_shortcodes || []).join("|")})((\s)((?!\\]).)*|)\\])"
+  end
+
+  # determine the content to replace instead the shortcode
+  # return string
+  def _eval_shortcode(code, attrs, args={}, template = nil)
+    template ||= (@_shortcodes_template[code].present? ? @_shortcodes_template[code] : "camaleon_cms/shortcode_templates/#{code}")
+    if @_shortcodes_template[code].class.name == "Proc"
+      res = @_shortcodes_template[code].call(_shortcode_parse_attr(attrs), args)
+    else
+      res = render :file => template, :locals => {attributes: _shortcode_parse_attr(attrs), args: args}, formats: [:html]
+    end
+    res
+  end
+
+  # parse the attributes of a shortcode
+  def _shortcode_parse_attr(text)
+    res = {}
+    return res unless text.present?
+    text.scan(/(\w+)\s*=\s*"([^"]*)"(?:\s|$)|(\w+)\s*=\s*\'([^\']*)\'(?:\s|$)|(\w+)\s*=\s*([^\s\'"]+)(?:\s|$)|"([^"]*)"(?:\s|$)|(\S+)(?:\s|$)/).each do |item|
+      item.each_with_index do |c, index|
+        if c.present?
+          res[c] = item[index+1]
+          break
+        end
+      end
+    end
+    res
+  end
+
+  # execute shortcode data
+  def cama_shortcode_data(attrs, args)
+    res = args[:shortcode]
+    object = (attrs["object"].presence || "post").downcase
+    attr = attrs["attr"] || "title"
+    if attrs['id'].present? || attrs['key'].present?
+      model = cama_shortcode_model_parser(object, attrs)
+    else
+      model = args[:owner]
+    end
+    return res unless model.present?
+    
+    if attrs["field"].present? # model custom fields
+      field = model.get_field_object(attrs["field"])
+      if attrs["render_field"].present?
+        return render_to_string(template: "custom_fields/#{field.options["field_key"]}", layout: false, :locals => {object: model, field: field, field_key: attrs["field"], attibutes: attrs}) 
+      else
+        if attrs["index"]
+          res = model.the_fields(attrs["field"])[attrs["index"].to_i-1] rescue ""
+        else
+          res = model.the_field(attrs["field"])
+        end
+        return res
+      end
+
+    else # model attributes
+      case attr
+        when "title"
+          res = model.the_title
+        when "created_at"
+          res = model.the_created_at
+        when "updated_at"
+          res = model.the_updated_at
+        when "excerpt"
+          res = model.the_excerpt rescue ""
+        when "url"
+          res = model.the_url rescue ""
+        when "link"
+          res = model.the_link rescue ""
+        when "thumb"
+          case object
+            when "site"
+              res =  model.the_logo
+            when "user"
+              res =  model.the_avatar
+            else
+              res =  model.the_thumb_url
+          end
+        else
+          case object
+            when 'post'
+              case attr
+                when "content"
+                  res = model.try(:the_content)
+                when "author_name"
+                  res = model.try(:the_author).try(:the_name)
+                when "author_url"
+                  res = model.try(:the_author).try(:the_name)
+              end
+          end
+      end
+    end
+    res
+  end
+
+  # return the model object according to the type
+  def cama_shortcode_model_parser(object, attrs)
+    model = nil
+    case object.downcase
+      when "post"
+        model = current_site.the_post(attrs["id"].to_i) if attrs["id"].present?
+        model = current_site.the_post(attrs["key"].to_s) if attrs["key"].present?
+
+      when "posttype"
+        model = current_site.the_post_type(attrs["id"].to_i) if attrs["id"].present?
+        model = current_site.the_post_type(attrs["key"].to_s) if attrs["key"].present?
+
+      when "category"
+        model = current_site.the_category(attrs["id"].to_i) if attrs["id"].present?
+        model = current_site.the_category(attrs["key"].to_s) if attrs["key"].present?
+
+      when "posttag"
+        model = current_site.the_tag(attrs["id"].to_i) if attrs["id"].present?
+        model = current_site.the_tag(attrs["key"].to_s) if attrs["key"].present?
+
+      when "site"
+        model = current_site
+
+      when "theme"
+        model = current_theme
+
+      when "navmenu"
+        model = current_site.nav_menu_items.find(attrs["id"]) if attrs["id"].present?
+        model = current_site.nav_menu_items.find_by_slug(attrs["key"]) if attrs["key"].present?
+
+      when "user"
+        model = current_site.the_user(attrs["id"].to_i) if attrs["id"].present?
+        model = current_site.the_user(attrs["key"].to_s) if attrs["key"].present?
+    end
+    model
+  end
+end

data/app/helpers/camaleon_cms/site_helper.rb

@@ -0,0 +1,103 @@
+module CamaleonCms::SiteHelper
+  # return current site or assign a site as a current site
+  def current_site(site = nil)
+    @current_site = site.decorate if site.present?
+    return $current_site if defined?($current_site)
+    return @current_site if defined?(@current_site)
+    if PluginRoutes.get_sites.size == 1
+      site = CamaleonCms::Site.first.decorate rescue nil
+    else
+      host = [request.original_url.to_s.parse_domain]
+      host << request.subdomain if request.subdomain.present?
+      site = CamaleonCms::Site.where(slug: host).first.decorate rescue nil
+    end
+    r = {site: site, request: (request rescue nil)};
+    cama_current_site_helper(r) rescue nil
+    Rails.logger.error 'Camaleon CMS - Please define your current site: $current_site = CamaleonCms::Site.first.decorate or map your domains: http://camaleon.tuzitio.com/documentation/category/139779-examples/how.html'.cama_log_style(:red) if !r[:site].present?
+    @current_site = r[:site]
+  end
+
+  # return current theme model for current site
+  def current_theme
+    @_current_theme ||= current_site.get_theme.decorate
+  end
+
+  # get list templates files of current theme
+  def cama_get_list_template_files(post_type)
+    contained_files = []
+    Dir[File.join(current_theme.settings["path"], "views", '*')].each do |path|
+      f_name = File.basename(path)
+      contained_files << f_name.split(".").first if f_name.include?('template_')
+    end
+    _args={tempates: contained_files, post_type: post_type}; hooks_run("post_get_list_templates", _args)
+    _args[:tempates]
+  end
+
+  # get list layouts files of current theme
+  # return an array of layouts for current theme
+  def cama_get_list_layouts_files(post_type)
+    contained_files = []
+    Dir[File.join(current_theme.settings["path"], "views", "layouts", '*')].each do |path|
+      f_name = File.basename(path)
+      contained_files << f_name.split(".").first unless f_name.start_with?('_')
+    end
+    _args={layouts: contained_files, post_type: post_type}; hooks_run("post_get_list_layouts", _args)
+    _args[:layouts]
+  end
+
+
+
+  # get locale language
+  def current_locale
+    I18n.locale.to_s
+  end
+
+  #***************** administration HELPERS ***********************
+  # do common actions after site installation
+  # theme_key: theme slug of the theme for site
+  def site_after_install(site, theme_key = nil)
+    theme_key ||= site.get_theme_slug
+    _s = current_site
+    current_site(site)
+    PluginRoutes.system_info["default_plugins"].each{|p| plugin_install(p) } # auto install plugins
+    site_install_theme(theme_key)
+    current_site(_s) if _s.present?
+  end
+
+  # install theme for current site
+  def site_install_theme(key)
+    #uninstall previous theme
+    site_uninstall_theme()
+
+    # new theme
+    current_site.set_option('_theme', key)
+    theme = PluginRoutes.theme_info(key)
+    current_site.themes.update_all(status: "inactive")
+    theme_model = current_site.themes.where(slug: key).first_or_create!{|t| t.name = theme[:name]; }
+    theme_model.update(status: nil)
+    hook_run(theme, "on_active", theme_model)
+    PluginRoutes.reload
+  end
+
+  # uninstall current theme form current site
+  def site_uninstall_theme()
+    key = current_site.get_theme_slug
+    theme = PluginRoutes.theme_info(key)
+    theme_model = current_site.get_theme(key)
+    hook_run(theme, "on_inactive", theme_model) if theme_model.present?
+    # theme_model.destroy
+  end
+
+  # add host + port to args of the current site visited (only if the request is coming from console or tasks i.e. not web browser)
+  # args: Hash
+  # sample: {} will return {host: 'localhost', port: 3000}
+  def cama_current_site_host_port(args)
+    args[:host], args[:port] = current_site.try(:get_domain).to_s.split(':') if cama_is_test_request?
+    args
+  end
+
+  # check if the request created by draper or request is not defined
+  def cama_is_test_request?
+    (request && defined?(ActionController::TestRequest) && request.is_a?(ActionController::TestRequest)) || !request
+  end
+end