camaleon_cms 2.1.1.4 → 2.1.2.0

data/app/helpers/camaleon_cms/email_helper.rb

@@ -1,5 +1,5 @@
 module CamaleonCms::EmailHelper
-
+  include CamaleonCms::HooksHelper
   # send and email
   # email: email to
   # subject: Subject of the email
@@ -9,13 +9,17 @@ module CamaleonCms::EmailHelper
   # layout_name: path of the template to render
   # template_name: template name to render in template_path
   def send_email(email, subject='Tiene una notificacion', content='', from=nil, attachs=[], template_name = nil, layout_name = nil, extra_data = {})
-    args = {template_name: template_name, layout_name: layout_name, from: from || current_site.get_option("email"), url_base: cama_root_url, content: content, attachs: attachs, extra_data: extra_data, current_site: current_site}
+    args = {attachs: attachs, extra_data: extra_data}
+    args[:template_name] = template_name if template_name.present?
+    args[:layout_name] = layout_name if layout_name.present?
+    args[:from] = from if from.present?
+    args[:content] = content if content.present?
     cama_send_email(email, subject, args)
   end
 
   # short method of send_email
   def cama_send_email(email_to, subject, args = {})
-    args = {from: current_site.get_option("email"), url_base: cama_root_url, current_site: current_site, cc_to: [], template_name: 'mailer', layout_name: 'camaleon_cms/mailer', format: 'html', subject: subject}.merge(args)
+    args = {url_base: cama_root_url, current_site: current_site, subject: subject}.merge(args)
     args[:attachments] = args[:attachs] if args[:attachs].present?
     args[:current_site] = args[:current_site].id
 

data/app/helpers/camaleon_cms/frontend/nav_menu_helper.rb

@@ -161,7 +161,13 @@ module CamaleonCms::Frontend::NavMenuHelper
           r[:link] = cama_root_path if r[:link] == "root_url"
           r[:link] = site_current_path if site_current_path == "#{current_site.the_path}#{r[:link]}"
           r[:current] = r[:link] == site_current_url || r[:link] == site_current_path
-          r
+          # permit to customize or mark as current menu
+          # _args: (HASH) {menu_item: Model Menu Item, parsed_menu: Parsed Menu }
+          #   Sample parsed_menu: {link: "url of the link", name: "Text of the menu", type_menu: 'external', current: Boolean (true => is current menu, false => not current menu item)}
+          _args = {menu_item: nav_menu_item, parsed_menu: r};  hooks_run("on_external_menu", _args)
+          r = _args[:parsed_menu]
+          return false if _args[:parsed_menu] == false
+
         else
           return false
       end

data/app/helpers/camaleon_cms/html_helper.rb

@@ -128,7 +128,7 @@ module CamaleonCms::HtmlHelper
     libs[:post] = {js: ["camaleon_cms/admin/jquery.tagsinput.min", 'camaleon_cms/admin/post'], css: ["camaleon_cms/admin/jquery.tagsinput"]}
     libs[:multiselect] = {js: ['camaleon_cms/admin/bootstrap-select.js']}
     libs[:validate] = {js: ['camaleon_cms/admin/jquery.validate']}
-    libs[:nav_menu] = {css: ['camaleon_cms/admin/nestable/jquery.nestable', "camaleon_cms/admin/nav-menu"], js: ["camaleon_cms/admin/jquery.nestable", 'camaleon_cms/admin/nav-menu']}
+    libs[:nav_menu] = {css: ['camaleon_cms/admin/nestable/jquery.nestable'], js: ["camaleon_cms/admin/jquery.nestable", 'camaleon_cms/admin/nav_menu']}
     libs[:admin_intro] = {js: ['camaleon_cms/admin/introjs/intro.min'], css: ["camaleon_cms/admin/introjs/introjs.min"]}
     @_cama_assets_libraries = libs
   end

data/app/helpers/camaleon_cms/site_helper.rb

@@ -25,41 +25,32 @@ module CamaleonCms::SiteHelper
     @current_site = r[:site]
   end
 
-  # check if current site exist, if not, this will be redirected to main domain
-  def cama_site_check_existence()
-    if !current_site.present?
-      if Cama::Site.main_site.present?
-        redirect_to Cama::Site.main_site.decorate.the_url
-      else
-        redirect_to cama_admin_installers_path
-      end
-    end
-  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
+  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
-    contained_files
+    _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
+  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
-    contained_files
+    _args={layouts: contained_files, post_type: post_type}; hooks_run("post_get_list_layouts", _args)
+    _args[:layouts]
   end
 
 

data/app/helpers/camaleon_cms/uploader_helper.rb

@@ -7,6 +7,7 @@
   See the  GNU Affero General Public License (GPLv3) for more details.
 =end
 module CamaleonCms::UploaderHelper
+  include ActionView::Helpers::NumberHelper
   # upload a file into server
   # settings:
   #   folder: Directory where the file will be saved (default: "")
@@ -23,19 +24,14 @@ module CamaleonCms::UploaderHelper
   # 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 = {})
-    unless uploaded_io.present?
-      return {error: "File is empty", file: nil, size: nil}
-    end
+    return {error: "File is empty", file: nil, size: nil} unless uploaded_io.present?
     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
-
-    cama_uploader_init_connection(true)
     settings = settings.to_sym
     settings[:uploaded_io] = uploaded_io
     settings = {
         folder: "",
-        maximum: 100.megabytes,
+        maximum: current_site.get_option('filesystem_max_size', 100).to_f.megabytes,
         formats: "*",
         generate_thumb: true,
         temporal_time: 0,
@@ -45,176 +41,37 @@ module CamaleonCms::UploaderHelper
         same_name: false
     }.merge(settings)
     hooks_run("before_upload", settings)
-
     res = {error: nil}
 
     # formats validations
-    return {error: "#{ct("file_format_error")} (#{settings[:formats]})"} unless cama_verify_format(uploaded_io.path, settings[:formats])
+    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")
+      res[:error] = "#{ct("file_size_exceeded", default: "File size exceeded")} (#{number_to_human_size(settings[:maximum])})"
       return res
     end
 
-    File.chmod(0644, uploaded_io.path) # fix reading permission (Fix Fog-Local)
-
     # save file
-    if settings[:same_name]
-      partial_path = "#{current_site.upload_directory_name}/#{"#{settings[:folder]}/" if settings[:folder].present?}#{settings[:filename]}"
-    else
-      partial_path = "#{current_site.upload_directory_name}/#{cama_uploader_check_name("#{"#{settings[:folder]}/" if settings[:folder].present?}#{settings[:filename]}")}"
-    end
-    partial_path = partial_path.gsub(/(\/){2,}/, "/")
-    file = @fog_connection_bucket_dir.files.create({:key => partial_path, :body => uploaded_io, :public => true})
-
-    if settings[:temporal_time] > 0 # temporal file upload (always put as local for temporal files)
-      Thread.new do
-        sleep(settings[:temporal_time])
-        file.destroy
-        ActiveRecord::Base.connection.close
-      end
-    end
-
-    res = cama_uploader_parse_file(file)
+    key = File.join(settings[:folder], settings[:filename]).to_s.gsub(/(\/){2,}/, "/")
+    res = cama_uploader.add_file(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 thumb
-    if settings[:generate_thumb] && res["format"] == "image" && File.extname(file.key) != ".gif"
-
-      cama_uploader_generate_thumbnail(uploaded_io.path, file.key, settings[:folder].split("/").push(@fog_connection_hook_res[:thumb_folder_name]).join("/"))
-    end
+    cama_uploader_generate_thumbnail(uploaded_io.path, res['key']) if settings[:generate_thumb] && res['thumb'].present?
     FileUtils.rm_f(uploaded_io.path) if settings[:remove_source]
     res
   end
 
-  # generate thumbnail
-  def cama_uploader_generate_thumbnail(source_path, filename, folder)
-    thumb_name = cama_parse_for_thumb_name(filename)
-    path_thumb = cama_resize_and_crop(source_path, @fog_connection_hook_res[:thumb][:w], @fog_connection_hook_res[:thumb][:h], {overwrite: false, output_name: thumb_name.split("/").last})
-    upload_file(path_thumb, {generate_thumb: false, same_name: true, remove_source: true, folder: folder})
-  end
-
-  # destroy file from fog
-  # sample: "owen/campaign-date-picker_1.png"
-  def cama_uploader_destroy_file(file_path, destroy_thumb = true)
-    cama_uploader_init_connection(true)
-    file = @fog_connection_bucket_dir.files.head("#{current_site.upload_directory_name}/#{file_path}".gsub(/(\/){2,}/, "/"))
-    _file =  cama_uploader_parse_file(file)
-    if destroy_thumb && _file["format"] == "image" && File.extname(file_path) != ".gif" # destroy thumb
-      cama_uploader_destroy_file("#{File.dirname(file_path)}/#{cama_parse_for_thumb_name(file.key)}", false) rescue ""
-    end
-    file.destroy
-  end
-
-  # destroy a folder from fog
-  def cama_uploader_destroy_folder(folder)
-    cama_uploader_init_connection(true)
-    if @fog_connection.class.name.include?("AWS")
-      dir = @fog_connection.directories.get(@fog_connection_hook_res[:bucket_name], prefix: "#{current_site.upload_directory_name}/#{folder}".gsub(/(\/){2,}/, "/"))
-      dir.files.each{|f| f.destroy }
-    end
-    @fog_connection_bucket_dir.files.head("#{current_site.upload_directory_name}/#{folder}/".gsub(/(\/){2,}/, "/")).destroy rescue ""
-  end
-
-  # add a new folder in fog
-  def cama_uploader_add_folder(folder)
-    cama_uploader_init_connection(true)
-    key = "#{@fog_connection_hook_res[:bucket_name]}/#{current_site.upload_directory_name}/#{folder}/".split("/").clean_empty.join("/")
-    dir = @fog_connection.directories.create(:key => key)
-    dir.files.create({:key => '_tmp.txt', content: "", :public => true}) unless @fog_connection.class.name.include?("AWS")
-  end
-
-  # initialize fog uploader and trigger hook to customize fog storage
-  def cama_uploader_init_connection(clear_cache = false)
-    server = current_site.get_option("filesystem_type", "local")
-    @fog_connection_hook_res ||= {server: server, connection: nil, thumb_folder_name: "thumb", bucket_name: server == "local" ? "media" : current_site.get_option("filesystem_s3_bucket_name"), thumb: {w: 100, h: 100}}; hooks_run("on_uploader", @fog_connection_hook_res)
-    case @fog_connection_hook_res[:server]
-      when "local"
-        Dir.mkdir(Rails.root.join("public", @fog_connection_hook_res[:bucket_name]).to_s) unless Dir.exist?(Rails.root.join("public", @fog_connection_hook_res[:bucket_name]).to_s)
-        @fog_connection ||= !@fog_connection_hook_res[:connection].present? ? Fog::Storage.new({ :local_root => Rails.root.join("public").to_s, :provider   => 'Local', endpoint: (root_url rescue cama_root_url) }) : @fog_connection_hook_res[:connection]
-      when "s3"
-        @fog_connection ||= !@fog_connection_hook_res[:connection].present? ? Fog::Storage.new({ :aws_access_key_id => current_site.get_option("filesystem_s3_access_key"), :provider   => 'AWS', aws_secret_access_key: current_site.get_option("filesystem_s3_secret_key"), :region  => current_site.get_option("filesystem_region") }) : @fog_connection_hook_res[:connection]
-    end
-    @fog_connection_bucket_dir ||= @fog_connection.directories.get(@fog_connection_hook_res[:bucket_name])
-    current_site.set_meta("cache_browser_files_#{@fog_connection_hook_res}", nil) if clear_cache
-  end
-
-  # verify if this file name already exist
-  # if the file is already exist, return a new name for this file
-  # sample: cama_uploader_check_name("my_file/file.txt")
-  def cama_uploader_check_name(partial_path)
-    cama_uploader_init_connection()
-    files = @fog_connection_bucket_dir.files
-    res = partial_path
-    if files.head("#{current_site.upload_directory_name}/#{res}".gsub(/(\/){2,}/, "/")).present?
-      dirname = "#{File.dirname(partial_path)}/" if partial_path.include?("/")
-      (1..999).each do |i|
-        res = "#{dirname}#{File.basename(partial_path, File.extname(partial_path))}_#{i}#{File.extname(partial_path)}"
-        break unless files.head("#{current_site.upload_directory_name}/#{res}".gsub(/(\/){2,}/, "/")).present?
-      end
-    end
-    res.gsub(/(\/){2,}/, "/")
-  end
-
-  # search a folder by path and return all folders and files
-  # sample: cama_media_find_folder("test/exit")
-  def cama_media_find_folder(path = "")
-    cama_uploader_init_connection(true)
-
-    prefix  = "#{current_site.upload_directory_name}/#{path}/".gsub(/(\/){2,}/, "/")
-    res     = {folders: {}, files: []}
-
-    @fog_connection.directories.get(@fog_connection_hook_res[:bucket_name], prefix: prefix).files.each do |file|
-      res[:files] << cama_uploader_parse_file(file) if file.key =~ %r|#{prefix}[^/]+$| && !file.key.include?('/_tmp.txt')
-      if file.key =~ %r|#{prefix}([^/]+)/|
-        folder_name = "#{$~[1]}"
-        res[:folders][folder_name] = {folders: {}, files: []} unless (folder_name == @fog_connection_hook_res[:thumb_folder_name])
-      end
-    end
-    return res
-  end
-
-  # search for a file by filename
-  # sample: cama_media_search_file("")
-  def cama_media_search_file(filename)
-    cama_uploader_init_connection(true)
-
-    prefix  = current_site.upload_directory_name.gsub(/(\/){2,}/, "/")
-
-    @fog_connection.directories
-    .get(@fog_connection_hook_res[:bucket_name], prefix: prefix)
-    .files
-    .select { |file| file.key.split('/').last.include?(filename) && !file.key.include?('/_tmp.txt') }
-    .map { |file| cama_uploader_parse_file(file) }
-  end
-
-  # parse file information of FOG file
-  def cama_uploader_parse_file(file)
-    res = {"name"=> File.basename(file.key), "file"=> file.key, "size"=> file.content_length, "url"=> (file.public_url rescue [current_site.get_option("filesystem_s3_endpoint"), file.key ].join("/")), "deleteUrl"=> "" }
-    ext = File.extname(file.key).sub(".", "").downcase
-    res["format"] = "unknown"
-    if "jpg,jpeg,png,gif,bmp,ico".split(",").include?(ext)
-      if File.extname(res["name"]) == ".gif"
-        res["thumb"] = res["url"]
-      else
-        res["thumb"] = "#{File.dirname(res["url"])}/#{cama_parse_for_thumb_name(file.key)}" rescue ""
-      end
-      res["format"] = "image"
-    end
-    if "flv,webm,wmv,avi,swf,mp4".split(",").include?(ext)
-      res["format"] = "video"
-    end
-    if "mp3,ogg".split(",").include?(ext)
-      res["format"] = "audio"
-    end
-    if "pdf,xls,xlsx,doc,docx,ppt,pptx,html,txt,xml,json".split(",").include?(ext)
-      res["format"] = "document"
-    end
-    if "zip,7z,rar,tar,bz2,gz,rar2".split(",").include?(ext)
-      res["format"] = "compress"
-    end
-    res["type"] = (MIME::Types.type_for(file.key).first.content_type rescue "")
-    res
+  # 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)
+    uploaded_io = File.open(uploaded_io) if uploaded_io.is_a?(String)
+    path_thumb = cama_resize_and_crop(uploaded_io.path, cama_uploader.thumb[:w], cama_uploader.thumb[:h])
+    thumb = cama_uploader.add_file(path_thumb, cama_uploader.version_path(key), is_thumb: true, same_name: true)
+    FileUtils.rm_f(path_thumb)
+    thumb
   end
 
   # helper to find an available filename for file_path in that directory
@@ -337,15 +194,16 @@ module CamaleonCms::UploaderHelper
     tmp_path = args[:path] || Rails.public_path.join("tmp", current_site.id.to_s)
     FileUtils.mkdir_p(tmp_path) unless Dir.exist?(tmp_path)
     if 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_verify_format(uploaded_io, args[:formats])
-      name = args[:name] || uploaded_io.split("/").last
+      return {error: "#{ct("file_format_error")} (#{args[:formats]})"} unless cama_uploader.class.validate_file_format(uploaded_io, args[:formats])
+      uploaded_io = Rails.public_path.join(uploaded_io.sub(current_site.the_url, '')).to_s if uploaded_io.include?(current_site.the_url) # local file
+      name = args[:name] || uploaded_io.split("/").last.split('?').first
       name = "#{File.basename(name, File.extname(name)).underscore}#{File.extname(name)}"
       path = uploader_verify_name( File.join(tmp_path, name))
       File.open(path, 'wb'){|file| file.write(open(uploaded_io).read) }
       path = cama_resize_upload(path, args[:dimension]) if args[:dimension].present?
     else
       uploaded_io = File.open(uploaded_io) if uploaded_io.is_a?(String)
-      return {error: "#{ct("file_format_error")} (#{args[:formats]})"} unless cama_verify_format(uploaded_io.path, args[:formats])
+      return {error: "#{ct("file_format_error")} (#{args[:formats]})"} unless cama_uploader.class.validate_file_format(uploaded_io.path, args[:formats])
       name = args[:name] || 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))
@@ -358,7 +216,7 @@ module CamaleonCms::UploaderHelper
   # resize image if the format is correct
   # return resized file path
   def cama_resize_upload(image_path, dimesion)
-    if cama_verify_format(image_path, 'image') && dimesion.present?
+    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}; 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] })
@@ -369,29 +227,15 @@ module CamaleonCms::UploaderHelper
     image_path
   end
 
-  # verify permitted formats (return boolean true | false)
-  # true: if format is accepted
-  # false: if format is not accepted
-  # sample: cama_verify_format(file_path, 'image,audio,docx,xls') => return true if the file extension is in formats
-  def cama_verify_format(file_path, formats)
-    return true if formats == "*" || !formats.present?
-    formats = formats.downcase.split(",")
-    if formats.include? "image"
-      formats += "jpg,jpeg,png,gif,bmp,ico".split(',')
-    end
-    if formats.include? "video"
-      formats += "flv,webm,wmv,avi,swf,mp4".split(',')
-    end
-    if formats.include? "audio"
-      formats += "mp3,ogg".split(',')
-    end
-    if formats.include? "document"
-      formats += "pdf,xls,xlsx,doc,docx,ppt,pptx,html,txt,htm,json,xml".split(',')
-    end
-    if formats.include?("compress") || formats.include?("compres")
-      formats += "zip,7z,rar,tar,bz2,gz,rar2".split(',')
+  # return the current uploader
+  def cama_uploader
+    case current_site.get_option("filesystem_type", "local").downcase
+      when 's3' || 'aws'
+        @cama_uploader ||= CamaleonCmsAwsUploader.new({current_site: current_site})
+      else
+        @cama_uploader ||= CamaleonCmsLocalUploader.new({current_site: current_site})
     end
-    formats.include?(File.extname(file_path).sub(".", "").downcase)
+    @cama_uploader
   end
 
   private

data/app/mailers/camaleon_cms/html_mailer.rb

@@ -16,11 +16,11 @@ class CamaleonCms::HtmlMailer < ActionMailer::Base
 
   # 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
     data[:current_site] = CamaleonCms::Site.main_site.decorate unless data[:current_site].present?
     data[:current_site] = CamaleonCms::Site.find(data[:current_site]).decorate if data[:current_site].is_a?(Integer)
-    @current_site = data[:current_site]
-    current_site = data[:current_site]
-    data = {cc_to: [], from: current_site.get_option("email"), template_name: 'mailer', layout_name: 'camaleon_cms/mailer', format: 'html'}.merge(data)
+    current_site = @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)
     @subject = subject
     @html = data[:content]
     @url_base = data[:url_base]
@@ -38,8 +38,6 @@ class CamaleonCms::HtmlMailer < ActionMailer::Base
                                              authentication: "plain",
                                              enable_starttls_auto: true
       }
-      data[:cc_to].push(current_site.get_option("email_cc"))
-      data[:from] = current_site.get_option("email_from", data[:from])
     end
     mail_data[:cc] = data[:cc_to].clean_empty.join(",") if data[:cc_to].present?
     mail_data[:from] = data[:from] if data[:from].present?
@@ -51,9 +49,7 @@ class CamaleonCms::HtmlMailer < ActionMailer::Base
     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"]
-    if data[:files].present?
-      data[:files].each { |attach| attachments["#{File.basename(attach)}"] = File.open(attach, 'rb') { |f| f.read } }
-    end
+    (data[:files] || data[:attachments] || []).each { |attach| attachments["#{File.basename(attach)}"] = File.open(attach, 'rb') { |f| f.read } }
 
     layout = data[:layout_name].present? ? data[:layout_name] : false
     if data[:template_name].present? # render email with template

data/app/models/camaleon_cms/custom_field_group.rb

@@ -26,6 +26,7 @@ class CamaleonCms::CustomFieldGroup < CamaleonCms::CustomField
   # for select, radio and checkboxes add:
   # -- multiple_options: [{"title"=>"Option Title", "value"=>"2", "default"=>"1"}, {"title"=>"abcde", "value"=>"3"}]
   # -- add default for default value
+  # -- label_eval: (Boolean, default false), true => will evaluate the label and description of current field using (eval('my_label')) to have translatable|dynamic labels
   # SAMPLE: my_model.add_field({"name"=>"Sub Title", "slug"=>"subtitle"}, {"field_key"=>"text_box", "translate"=>true, default_value: "Get in Touch"})
 
   def add_manual_field(item, options)

data/app/models/camaleon_cms/nav_menu.rb

@@ -12,12 +12,6 @@ class CamaleonCms::NavMenu < CamaleonCms::TermTaxonomy
   has_many :children, class_name: "CamaleonCms::NavMenuItem", foreign_key: :parent_id, dependent: :destroy
   belongs_to :site, :class_name => "CamaleonCms::Site", foreign_key: :parent_id
 
-  # add multiple menu items for current menu only used from form
-  def add_menu_items(menu_data=[])
-    children.destroy_all
-    saved_nav_items(self, menu_data) if menu_data.present?
-  end
-
   # add menu item for current menu
   # value: (Hash) is a hash object that contains label, type, link
   #   options for type: post | category | post_type | post_tag | external
@@ -26,7 +20,7 @@ class CamaleonCms::NavMenu < CamaleonCms::TermTaxonomy
   # sample: {label: "my label", type: "category", link: 12}
   # return item created
   def append_menu_item (value)
-    item = children.create({name: value[:label], data_options: {type: value[:type], object_id: value[:link]}})
+    item = children.create!({name: value[:label], data_options: {type: value[:type], object_id: value[:link]}})
     item
   end
 
@@ -36,19 +30,6 @@ class CamaleonCms::NavMenu < CamaleonCms::TermTaxonomy
   end
 
   private
-  def saved_nav_items (nav_menu_item, items)
-    items.each do |key, value|
-      item = nav_menu_item.children.new({name: value[:label]})
-      if item.save!
-        item.set_meta('_default',{type: value[:type], object_id: value[:link]})
-        saved_nav_items(item, value[:children]) if value[:children].present?
-
-        # save custom fields for this menu item
-        item.set_field_values(value[:fields]) if value[:fields].present?
-      end
-    end
-  end
-
   # overwrite termtaxonomy method
   def destroy_dependencies
   end