camaleon_cms_rails6 2.5.0

data/app/helpers/camaleon_cms/theme_helper.rb

@@ -0,0 +1,95 @@
+module CamaleonCms::ThemeHelper
+  def theme_init()
+    @_front_breadcrumb = []
+  end
+
+  # return theme full asset path
+  # theme_name: theme name, if nil, then will use current theme
+  # asset: asset file name, if asset is present return full path to this asset
+  # sample: <script src="<%= theme_asset_path("js/admin.js") %>"></script> => return: /assets/themes/my_theme/assets/js/admin-54505620f.js
+  def theme_asset_path(asset = nil, theme_name = nil)
+    if theme_name.present? && theme_name.include?("/")
+      return theme_asset_url(theme_name, current_theme.slug)
+    end
+
+    settings = theme_name.present? ? PluginRoutes.theme_info(theme_name) : current_theme.settings
+    folder_name = settings["key"]
+    if settings["gem_mode"]
+      p = "themes/#{folder_name}/#{asset}"
+    else
+      p = "themes/#{folder_name}/assets/#{asset}"
+    end
+    p
+  end
+  alias_method :theme_asset, :theme_asset_path
+  alias_method :theme_gem_asset, :theme_asset_path
+
+  # return the full url for asset of current theme:
+  # asset: (String) asset name
+  # theme_name: (optional) theme name, default (current theme caller to this function)
+  # sample:
+  #   theme_asset_url("css/main.css") => return: http://myhost.com/assets/themes/my_theme/assets/css/main-54505620f.css
+  def theme_asset_url(asset, theme_name = nil)
+    p = theme_asset_path(asset, theme_name)
+    begin
+      ActionController::Base.helpers.asset_url(p)
+    rescue NoMethodError => e
+      p
+    end
+  end
+
+  # return theme view path including the path of current theme
+  # view_name: name of the view or template
+  # sample: theme_view("index") => "themes/my_theme/index"
+  def theme_view(view_name, deprecated_attr = "")
+    view_name = deprecated_attr if deprecated_attr.present?
+    if current_theme.settings["gem_mode"]
+      "themes/#{current_theme.slug}/#{view_name}"
+    else
+      "themes/#{current_theme.slug}/views/#{view_name}"
+    end
+  end
+
+  # assign the layout for this request
+  # asset: asset file name, if asset is present return full path to this asset
+  # layout_name: layout name
+  def theme_layout(layout_name, theme_name = nil)
+    if current_theme.settings["gem_mode"]
+      "themes/#{current_theme.slug}/layouts/#{layout_name}"
+    else
+      "themes/#{current_theme.slug}/views/layouts/#{layout_name}"
+    end
+  end
+
+  # return theme key for current theme file (helper|controller|view)
+  # DEPRECATED, instead use: current_theme
+  # index: internal control
+  def self_theme_key(index = 0)
+    k = "/themes/"
+    f = caller[index]
+    if f.include?(k)
+      f.split(k).last.split("/").first
+    end
+  end
+
+  # returns file system path to theme asset
+  # theme_name: theme name, if nil, then will use current theme
+  # asset: asset file name, if asset is present return full path to this asset
+  # sample: theme_asset_file_path('images/foo.jpg') => return: /home/camaleon/my-site/app/apps/themes/default/assets/images/foo.jpg
+  def theme_asset_file_path(asset = nil, theme_name = nil)
+    theme_path = current_theme.settings['path']
+    if theme_name && theme = Theme.where(name: theme_name).first
+      theme_path = theme.settings['path']
+    end
+    "#{theme_path}/assets/#{asset}"
+  end
+
+  # Returns a default message if no pages exist
+  def theme_home_page
+    current_site.the_post(current_theme.get_field("home_page")) ||
+      current_site.the_posts("page").first ||
+      CamaleonCms::Post.new(title: 'Hello World!',
+                          content: 'Please add a page.',
+                           status: 'published')
+  end
+end

data/app/helpers/camaleon_cms/uploader_helper.rb

@@ -0,0 +1,329 @@
+module CamaleonCms::UploaderHelper
+  include ActionView::Helpers::NumberHelper
+  include CamaleonCms::CamaleonHelper
+  # upload a file into server
+  # settings:
+  #   folder: Directory where the file will be saved (default: "")
+  #     sample: temporal => will save in /rails_path/public/temporal
+  #   generate_thumb: true, # generate thumb image if this is image format (default true)
+  #   maximum: maximum bytes permitted to upload (default: 1000MG)
+  #   dimension: dimension for the image (sample: 30x30 | x30 | 30x | 300x300?)
+  #   formats: extensions permitted, sample: jpg,png,... or generic: images | videos | audios | documents (default *)
+  #   remove_source: Boolean (delete source file after saved if this is true, default false)
+  #   same_name: Boolean (save the file with the same name if defined true, else search for a non used name)
+  #   versions: (String) Create addtional multiple versions of the image uploaded, sample: '300x300,505x350' ==> Will create two extra images with these dimensions
+  #       sample "test.png", versions: '200x200,450x450' will generate: thumb/test-png_200x200.png, test-png_450x450.png
+  #   thumb_size: String (redefine the dimensions of the thumbnail, sample: '100x100' ==> only for images)
+  #   temporal_time: if great than 0 seconds, then this file will expire (removed) in that time (default: 0)
+  #     To manage jobs, please check http://edgeguides.rubyonrails.org/active_job_basics.html
+  #     Note: if you are using temporal_time, you will need to copy the file to another directory later
+  # sample: upload_file(params[:my_file], {formats: "images", folder: "temporal"})
+  # sample: upload_file(params[:my_file], {formats: "jpg,png,gif,mp3,mp4", temporal_time: 10.minutes, maximum: 10.megabytes})
+  def upload_file(uploaded_io, settings = {})
+    cached_name = uploaded_io.is_a?(ActionDispatch::Http::UploadedFile) ? uploaded_io.original_filename : nil
+    return {error: "File is empty", file: nil, size: nil} unless uploaded_io.present?
+    if uploaded_io.is_a?(String) && uploaded_io.match(/^https?:\/\//).present? # download url file
+      tmp = cama_tmp_upload(uploaded_io)
+      return tmp if tmp[:error].present?
+      settings[:remove_source] = true
+      uploaded_io = tmp[:file_path]
+    end
+    uploaded_io = File.open(uploaded_io) if uploaded_io.is_a?(String)
+    uploaded_io = File.open(cama_resize_upload(uploaded_io.path, settings[:dimension])) if settings[:dimension].present? # resize file into specific dimensions
+
+    settings = settings.to_sym
+    settings[:uploaded_io] = uploaded_io
+    settings = {
+        folder: "",
+        maximum: current_site.get_option('filesystem_max_size', 100).to_f.megabytes,
+        formats: "*",
+        generate_thumb: true,
+        temporal_time: 0,
+        filename: ((cached_name || uploaded_io.original_filename) rescue uploaded_io.path.split("/").last).cama_fix_filename,
+        file_size: File.size(uploaded_io.to_io),
+        remove_source: false,
+        same_name: false,
+        versions: '',
+        thumb_size: nil
+    }.merge(settings)
+    hooks_run("before_upload", settings)
+    res = {error: nil}
+
+    # formats validations
+    return {error: "#{ct("file_format_error")} (#{settings[:formats]})"} unless cama_uploader.class.validate_file_format(uploaded_io.path, settings[:formats])
+
+    # file size validations
+    if settings[:maximum] < settings[:file_size]
+      res[:error] = "#{ct("file_size_exceeded", default: "File size exceeded")} (#{number_to_human_size(settings[:maximum])})"
+      return res
+    end
+    # save file
+    key = File.join(settings[:folder], settings[:filename]).to_s.cama_fix_slash
+    res = cama_uploader.add_file(settings[:uploaded_io], key, {same_name: settings[:same_name]})
+    {} if settings[:temporal_time] > 0 # temporal file upload (always put as local for temporal files) (TODO: use delayjob)
+
+    # generate image versions
+    if res['file_type'] == 'image'
+      settings[:versions].to_s.gsub(' ', '').split(',').each do |v|
+        version_path = cama_resize_upload(settings[:uploaded_io].path, v, {replace: false})
+        cama_uploader.add_file(version_path, cama_uploader.version_path(res['key'], v), is_thumb: true, same_name: true)
+        FileUtils.rm_f(version_path)
+      end
+    end
+
+    # generate thumb
+    cama_uploader_generate_thumbnail(uploaded_io.path, res['key'], settings[:thumb_size], settings[:remove_source]) if settings[:generate_thumb] && res['thumb'].present?
+    FileUtils.rm_f(uploaded_io.path) if File.exist?(uploaded_io.path) if settings[:remove_source]
+
+    hooks_run('after_upload', settings)
+    res
+  end
+
+  # generate thumbnail of a existent image
+  # key: key of the current file
+  # the thumbnail will be saved in my_images/my_img.png => my_images/thumb/my_img.png
+  def cama_uploader_generate_thumbnail(uploaded_io, key, thumb_size = nil, remove_source = false)
+    w, h = cama_uploader.thumb[:w], cama_uploader.thumb[:h]
+    w, h = thumb_size.split('x') if thumb_size.present?
+    uploaded_io = File.open(uploaded_io) if uploaded_io.is_a?(String)
+    path_thumb = cama_resize_and_crop(uploaded_io.path, w, h)
+    thumb = cama_uploader.add_file(path_thumb, cama_uploader.version_path(key).sub('.svg', '.jpg'), is_thumb: true, same_name: true)
+    FileUtils.rm_f(path_thumb) if remove_source
+    thumb
+  end
+
+  # helper to find an available filename for file_path in that directory
+  # sample: uploader_verify_name("/var/www/my_image.jpg")
+  #   return "/var/www/my_image_1.jpg" => if "/var/www/my_image.jpg" exist
+  #   return "/var/www/my_image.jpg" => if "/var/www/my_image.jpg" doesn't exist
+  def uploader_verify_name(file_path)
+    dir, filename = File.dirname(file_path), File.basename(file_path).to_s.cama_fix_filename
+    files = Dir.entries(dir)
+    if files.include?(filename)
+      i, _filename = 1, filename
+      while files.include?(_filename) do
+        _filename = "#{File.basename(filename, File.extname(filename))}_#{i}#{File.extname(filename)}"
+        i += 1
+      end
+      filename = _filename
+    end
+    "#{File.dirname(file_path)}/#{filename}"
+  end
+
+  # convert downloaded file path into public url
+  def cama_file_path_to_url(file_path)
+    file_path.sub(Rails.public_path.to_s, (root_url rescue cama_root_url))
+  end
+
+  # convert public url to file path
+  def cama_url_to_file_path(url)
+    File.join(Rails.public_path, URI(url.to_s).path)
+  end
+
+  # crop and image and saved as imagename_crop.ext
+  # file: file path
+  # w:  new width
+  # h: new height
+  # w_offset: left offset
+  # w_offset: top offset
+  # resize: true/false
+  #   (true => resize the image to this dimension)
+  #   (false => crop the image with this dimension)
+  # replace: Boolean (replace current image or create another file)
+  def cama_crop_image(file_path, w=nil, h=nil, w_offset = 0, h_offset = 0, resize = false , replace = true)
+    force = ""
+    force = "!" if w.present? && h.present? && !w.include?("?") && !h.include?("?")
+    img = MiniMagick::Image.open(file_path)
+    w = img[:width].to_f > w.sub('?', '').to_i ? w.sub('?', "") : img[:width] if w.present? && w.to_s.include?('?')
+    h = img[:height].to_f > h.sub('?', '').to_i ? h.sub('?', "") : img[:height] if h.present? && h.to_s.include?('?')
+    data = {img: img, w: w, h: h, w_offset: w_offset, h_offset: h_offset, resize: resize, replace: replace}; hooks_run("before_crop_image", data)
+    data[:img].combine_options do |i|
+      i.resize("#{w if w.present?}x#{h if h.present?}#{force}") if data[:resize]
+      i.crop "#{w if w.present?}x#{h if h.present?}+#{w_offset}+#{h_offset}#{force}" unless data[:resize]
+    end
+
+    res = file_path
+    unless data[:replace]
+      ext = File.extname(file_path)
+      res = file_path.gsub(ext, "_crop#{ext}")
+    end
+    data[:img].write res
+    res
+  end
+
+  # resize and crop a file
+  # SVGs are converted to JPEGs for editing
+  # Params:
+  #   file: (String) File path
+  #   w: (Integer) width
+  #   h: (Integer) height
+  #   settings:
+  #     gravity: (Sym, default :north_east) Crop position: :north_west, :north, :north_east, :east, :south_east, :south, :south_west, :west, :center
+  #     overwrite: (Boolean, default true) true for overwrite current image with resized resolutions, false: create other file called with prefix "crop_"
+  #     output_name: (String, default prefixd name with crop_), permit to define the output name of the thumbnail if overwrite = true
+  # Return: (String) file path where saved this cropped
+  # sample: cama_resize_and_crop(my_file, 200, 200, {gravity: :north_east, overwrite: false})
+  def cama_resize_and_crop(file, w, h, settings = {})
+    settings = {gravity: :north_east, overwrite: true, output_name: ""}.merge(settings)
+    img = MiniMagick::Image.open(file)
+    if file.end_with? '.svg'
+      img.format 'jpg'
+      file.sub! '.svg', '.jpg'
+      settings[:output_name].sub!('.svg', '.jpg') if settings[:output_name]
+    end
+    w = img[:width].to_f > w.sub('?', '').to_i ? w.sub('?', "") : img[:width] if w.present? && w.to_s.include?('?')
+    h = img[:height].to_f > h.sub('?', '').to_i ? h.sub('?', "") : img[:height] if h.present? && h.to_s.include?('?')
+    w_original, h_original = [img[:width].to_f, img[:height].to_f]
+    w = w.to_i if w.present?
+    h = h.to_i if h.present?
+
+    # check proportions
+    if w_original * h < h_original * w
+      op_resize = "#{w.to_i}x"
+      w_result = w
+      h_result = (h_original * w / w_original)
+    else
+      op_resize = "x#{h.to_i}"
+      w_result = (w_original * h / h_original)
+      h_result = h
+    end
+
+    w_offset, h_offset = cama_crop_offsets_by_gravity(settings[:gravity], [w_result, h_result], [w, h])
+    data = {img: img, w: w, h: h, w_offset: w_offset, h_offset: h_offset, op_resize: op_resize, settings: settings}; hooks_run("before_resize_crop", data)
+    data[:img].combine_options do |i|
+      i.resize(data[:op_resize])
+      i.gravity(settings[:gravity])
+      i.crop "#{data[:w].to_i}x#{data[:h].to_i}+#{data[:w_offset]}+#{data[:h_offset]}!"
+    end
+
+    if settings[:overwrite]
+      data[:img].write(file.sub '.svg', '.jpg')
+    else
+      if settings[:output_name].present?
+        data[:img].write(file = File.join(File.dirname(file), settings[:output_name]).to_s)
+      else
+        data[:img].write(file = uploader_verify_name(File.join(File.dirname(file), "crop_#{File.basename(file.sub '.svg', '.jpg')}")))
+      end
+    end
+    file
+  end
+
+  # upload tmp file
+  # support for url and local path
+  # sample:
+  # cama_tmp_upload('http://camaleon.tuzitio.com/media/132/logo2.png')  ==> /var/rails/my_project/public/tmp/1/logo2.png
+  # cama_tmp_upload('/var/www/media/132/logo 2.png')  ==> /var/rails/my_project/public/tmp/1/logo-2.png
+  # accept args:
+  #   name: to indicate the name to use, sample: cama_tmp_upload('/var/www/media/132/logo 2.png', {name: 'owen.png', formats: 'images'})
+  #   formats: extensions permitted, sample: jpg,png,... or generic: images | videos | audios | documents (default *)
+  #   dimension: 20x30
+  # return: {file_path, error}
+  def cama_tmp_upload(uploaded_io, args = {})
+    tmp_path = args[:path] || File.join(Rails.public_path, "tmp", current_site.id.to_s).to_s
+    FileUtils.mkdir_p(tmp_path) unless Dir.exist?(tmp_path)
+    saved = false
+    if uploaded_io.is_a?(String) && (uploaded_io.start_with?("data:")) # create tmp file using base64 format
+      _tmp_name = args[:name]
+      return {error: "#{cama_t("camaleon_cms.admin.media.name_required")}"} unless params[:name].present?
+      return {error: "#{ct("file_format_error")} (#{args[:formats]})"} unless cama_uploader.class.validate_file_format(_tmp_name, args[:formats])
+      path = uploader_verify_name(File.join(tmp_path, _tmp_name))
+      File.open(path, 'wb'){|f| f.write(Base64.decode64(uploaded_io.split(';base64,').last)) }
+      uploaded_io = File.open(path)
+      saved =  true
+    elsif uploaded_io.is_a?(String) && (uploaded_io.start_with?("http://") || uploaded_io.start_with?("https://"))
+      return {error: "#{ct("file_format_error")} (#{args[:formats]})"} unless cama_uploader.class.validate_file_format(uploaded_io, args[:formats])
+      uploaded_io = File.join(Rails.public_path, uploaded_io.sub(current_site.the_url(locale: nil), '')).to_s if uploaded_io.include?(current_site.the_url(locale: nil)) # local file
+      _tmp_name = uploaded_io.split("/").last.split('?').first; args[:name] = args[:name] || _tmp_name
+      uploaded_io = open(uploaded_io)
+    end
+    uploaded_io = File.open(uploaded_io) if uploaded_io.is_a?(String)
+    return {error: "#{ct("file_format_error")} (#{args[:formats]})"} unless cama_uploader.class.validate_file_format(_tmp_name || uploaded_io.path, args[:formats])
+    return {error: "#{ct("file_size_exceeded", default: "File size exceeded")} (#{number_to_human_size(args[:maximum])})"} if args[:maximum].present? && args[:maximum] < (uploaded_io.size rescue File.size(uploaded_io))
+    name = args[:name] || uploaded_io.try(:original_filename) || uploaded_io.path.split("/").last; name = "#{File.basename(name, File.extname(name)).underscore}#{File.extname(name)}"
+    path ||= uploader_verify_name(File.join(tmp_path, name))
+    File.open(path, "wb"){|f| f.write(uploaded_io.read) } unless saved
+    path = cama_resize_upload(path, args[:dimension]) if args[:dimension].present?
+    {file_path: path, error: nil}
+  end
+
+  # resize image if the format is correct
+  # return resized file path
+  def cama_resize_upload(image_path, dimesion, args = {})
+    if cama_uploader.class.validate_file_format(image_path, 'image') && dimesion.present?
+      r= {file: image_path, w: dimesion.split('x')[0], h: dimesion.split('x')[1], w_offset: 0, h_offset: 0, resize: !dimesion.split('x')[2] || dimesion.split('x')[2] == "resize", replace: true, gravity: :north_east}.merge(args); hooks_run("on_uploader_resize", r)
+      if r[:w].present? && r[:h].present?
+        image_path = cama_resize_and_crop(r[:file], r[:w], r[:h], {overwrite: r[:replace], gravity: r[:gravity] })
+      else
+        image_path = cama_crop_image(r[:file], r[:w], r[:h], r[:w_offset], r[:h_offset], r[:resize] , r[:replace])
+      end
+    end
+    image_path
+  end
+
+  # return the current uploader
+  def cama_uploader
+    @cama_uploader ||= lambda{
+      thumb = current_site.get_option('filesystem_thumb_size', '100x100').split('x')
+      args= {
+        server: current_site.get_option("filesystem_type", "local").downcase,
+        thumb: {w: thumb[0], h: thumb[1]},
+        aws_settings: {
+          region: current_site.get_option("filesystem_region", 'us-west-2'),
+          access_key: current_site.get_option("filesystem_s3_access_key"),
+          secret_key: current_site.get_option("filesystem_s3_secret_key"),
+          bucket: current_site.get_option("filesystem_s3_bucket_name"),
+          cloud_front: current_site.get_option("filesystem_s3_cloudfront"),
+          aws_file_upload_settings: lambda{|settings| settings }, # permit to add your custom attributes for file_upload http://docs.aws.amazon.com/sdkforruby/api/Aws/S3/Object.html#upload_file-instance_method
+          aws_file_read_settings: lambda{|data, s3_file| data } # permit to read custom attributes from aws file and add to file parsed object
+        },
+        custom_uploader: nil # posibility to use custom file uploader
+      }
+      hooks_run("on_uploader", args)
+      return args[:custom_uploader] if args[:custom_uploader].present?
+
+      case args[:server]
+        when 's3', 'aws'
+          CamaleonCmsAwsUploader.new({current_site: current_site, thumb: args[:thumb], aws_settings: args[:aws_settings]}, self)
+        else
+          CamaleonCmsLocalUploader.new({current_site: current_site, thumb: args[:thumb]}, self)
+      end
+    }.call
+  end
+
+  def slugify(val)
+    val.to_s.downcase.strip.gsub(' ', '-').gsub(/[^\w-]/, '')
+  end
+
+  def slugify_folder(val)
+    splitted_folder = val.split('/')
+    splitted_folder[-1] = slugify(splitted_folder.last)
+    splitted_folder.join('/')
+  end
+
+  private
+  # helper for resize and crop method
+  def cama_crop_offsets_by_gravity(gravity, original_dimensions, cropped_dimensions)
+    original_width, original_height = original_dimensions
+    cropped_width, cropped_height = cropped_dimensions
+
+    vertical_offset = case gravity
+                        when :north_west, :north, :north_east then 0
+                        when :center, :east, :west then [ ((original_height - cropped_height) / 2.0).to_i, 0 ].max
+                        when :south_west, :south, :south_east then (original_height - cropped_height).to_i
+                      end
+
+    horizontal_offset = case gravity
+                          when :north_west, :west, :south_west then 0
+                          when :center, :north, :south then [ ((original_width - cropped_width) / 2.0).to_i, 0 ].max
+                          when :north_east, :east, :south_east then (original_width - cropped_width).to_i
+                        end
+
+    return [ horizontal_offset, vertical_offset ]
+  end
+
+  # convert file path into thumb path format
+  # return the image name into thumb format: owewen.png into thumb/owen-png.png
+  def cama_parse_for_thumb_name(file_path)
+    "#{@fog_connection_hook_res[:thumb_folder_name]}/#{File.basename(file_path).parameterize}#{File.extname(file_path)}"
+  end
+end

data/app/helpers/camaleon_cms/user_roles_helper.rb

@@ -0,0 +1,13 @@
+#encoding: utf-8
+module CamaleonCms::UserRolesHelper
+  def cama_get_roles_values
+    @_cache_cama_get_roles_values ||= lambda{
+      roles_list = CamaleonCms::UserRole::ROLES
+      # permit to add custom roles to be listed in editing roles form
+      # sample: args[:roles_list][:manager] << { key: 'my_role_key', label: "my_custom_permission", description: "lorem ipsum"}
+      # authorize! :manage, :my_role_key
+      args = {roles_list: roles_list}; hooks_run("available_user_roles_list", args)
+      args[:roles_list]
+    }.call
+  end
+end

data/app/mailers/camaleon_cms/html_mailer.rb

@@ -0,0 +1,87 @@
+class CamaleonCms::HtmlMailer < ActionMailer::Base
+  include CamaleonCms::SiteHelper
+  include CamaleonCms::HooksHelper
+  include CamaleonCms::PluginsHelper
+  #include ApplicationHelper
+  default from: "Camaleon CMS <owenperedo@gmail.com>"
+  after_action :set_delivery_options
+
+  # content='', from=nil, attachs=[], url_base='', current_site, template_name, layout_name, extra_data, format, cc_to
+  def sender(email, subject='Hello', data = {})
+    data = data.to_sym
+    if data[:current_site].present?
+      if data[:current_site].is_a?(Integer)
+        data[:current_site] = CamaleonCms::Site.find(data[:current_site]).decorate
+      end
+    else
+      data[:current_site] = CamaleonCms::Site.main_site.decorate
+    end
+    @current_site = data[:current_site]
+    data = {
+      cc_to: @current_site.get_option("email_cc", '').split(','),
+      from: @current_site.get_option("email_from") || @current_site.get_option("email"),
+      template_name: 'mailer',
+      layout_name: 'camaleon_cms/mailer',
+      format: 'html',
+    }.merge(data)
+    data[:cc_to] = [data[:cc_to]] if data[:cc_to].is_a?(String) || !data[:cc_to].present?
+
+    mail_data = {to: email, subject: subject}
+    if @current_site.get_option("mailer_enabled") == 1
+      mail_data[:delivery_method] = :smtp
+      mail_data[:delivery_method_options] = {
+        user_name: @current_site.get_option("email_username"),
+        password: @current_site.get_option("email_pass"),
+        address: @current_site.get_option("email_server"),
+        port: @current_site.get_option("email_port"),
+        domain: (@current_site.the_url.to_s.parse_domain rescue "localhost"),
+        authentication: "plain",
+        enable_starttls_auto: true,
+      }
+    end
+    mail_data[:cc] = data[:cc_to].clean_empty.join(",") if data[:cc_to].present?
+    mail_data[:from] = data[:from] if data[:from].present?
+    
+    data[:mail_data] = mail_data
+    hooks_run('email_late', data)
+    
+    @subject = subject
+    @html = data[:content]
+    @url_base = data[:url_base]
+    @extra_data = data[:extra_data]
+
+    views_dir = "app/apps/"
+    self.prepend_view_path(File.join($camaleon_engine_dir, views_dir).to_s)
+    self.prepend_view_path(Rails.root.join(views_dir).to_s)
+
+    theme = @current_site.get_theme
+    lookup_context.prefixes.prepend("themes/#{theme.slug}") if theme.settings["gem_mode"]
+    lookup_context.prefixes.prepend("themes/#{theme.slug}/views") unless theme.settings["gem_mode"]
+    lookup_context.use_camaleon_partial_prefixes = true
+    ((data[:files] || []) + (data[:attachments] || [])).each{ |attach|
+      if File.exist?(attach) && !File.directory?(attach)
+        attachments["#{File.basename(attach)}"] = File.open(attach, 'rb') { |f| f.read }
+      else
+        Rails.logger.error "Camaleon CMS - File attached in the email doesn't exist: #{attach}".cama_log_style(:red)
+      end
+    }
+
+    layout = data[:layout_name].present? ? data[:layout_name] : false
+    if data[:template_name].present? # render email with template
+      mail(mail_data) { |format| format.html { render data[:template_name], layout: layout } } if data[:format] == "html"
+      mail(mail_data) { |format| format.text { render data[:template_name], layout: layout } } if data[:format] == "txt"
+    else # inline render content
+      mail(mail_data) { |format| format.html { render inline: @html, layout: layout } } if data[:format] == "html"
+      mail(mail_data) { |format| format.text { render inline: @html, layout: layout } } if data[:format] == "txt"
+    end
+    mail(mail_data) unless data[:format].present?
+  end
+
+  private
+  # set default settings configured on admin panel
+  def set_delivery_options
+    if @current_site.get_option("mailer_enabled") == 1
+      mail.perform_deliveries = true
+    end
+  end
+end