camaleon_cms_rails6 2.5.0

data/app/models/concerns/camaleon_cms/user_methods.rb

@@ -0,0 +1,133 @@
+module CamaleonCms::UserMethods extend ActiveSupport::Concern
+  included do
+    include CamaleonCms::Metas
+    include CamaleonCms::CustomFieldsRead
+
+    validates_uniqueness_of :username, scope: [:site_id], case_sensitive: false, message: I18n.t('camaleon_cms.admin.users.message.requires_different_username', default: 'Requires different username')
+    validates_uniqueness_of :email, scope: [:site_id], case_sensitive: false, message: I18n.t('camaleon_cms.admin.users.message.requires_different_email', default: 'Requires different email')
+
+    # callbacks
+    before_validation :cama_before_validation
+    before_destroy :reassign_posts
+    after_destroy :reassign_comments
+    before_create { generate_token(:auth_token) }
+
+    # relations
+    cama_define_common_relationships('User')
+    has_many :all_posts, class_name: "CamaleonCms::Post", foreign_key: :user_id
+    has_many :all_comments, class_name: 'CamaleonCms::PostComment'
+    belongs_to :site, class_name: 'CamaleonCms::Site'
+
+    #scopes
+    scope :admin_scope, -> { where(:role => 'admin') }
+    scope :actives, -> { where(:active => 1) }
+    scope :not_actives, -> { where(:active => 0) }
+
+    #vars
+    STATUS = {0 => 'Active', 1=>'Not Active'}
+    ROLE = { 'admin'=>'Administrator', 'client' => 'Client'}
+
+    def self.decorator_class
+      'CamaleonCms::UserDecorator'.constantize
+    end
+  end
+
+  # return all posts of this user on site
+  def posts(site)
+    site.posts.where(user_id: self.id)
+  end
+
+  def fullname
+    "#{self.first_name} #{self.last_name}".titleize
+  end
+
+  def admin?
+    role == 'admin'
+  end
+
+  def client?
+    self.role == 'client'
+  end
+
+  # return the UserRole Object of this user in Site
+  def get_role(site)
+    @_user_role ||= site.user_roles.where(slug: self.role).first
+  end
+
+  # assign a new site for current user
+  def assign_site(site)
+    self.update_column(:site_id, site.id)
+  end
+
+  def sites
+    if PluginRoutes.system_info["users_share_sites"]
+      CamaleonCms::Site.all
+    else
+      CamaleonCms::Site.where(id: self.site_id)
+    end
+  end
+
+  def created
+    self.created_at.strftime('%d/%m/%Y %H:%M')
+  end
+
+  def updated
+    self.updated_at.strftime('%d/%m/%Y %H:%M')
+  end
+
+  # auth
+  def generate_token(column)
+    begin
+      self[column] = SecureRandom.urlsafe_base64
+    end while CamaleonCms::User.exists?(column => self[column])
+  end
+
+  def send_password_reset
+    generate_token(:password_reset_token)
+    self.password_reset_sent_at = Time.zone.now
+    save!
+  end
+
+  def send_confirm_email
+    generate_token(:confirm_email_token)
+    self.confirm_email_sent_at = Time.zone.now
+    save!
+  end
+    # end auth
+
+  private
+  def cama_before_validation
+    self.role = PluginRoutes.system_info["default_user_role"] if self.role.blank?
+    self.email = self.email.downcase if self.email.present?
+    self.username = self.username.downcase if self.username.present?
+  end
+
+  # deprecated
+  def set_all_sites
+    return
+  end
+
+  # reassign all posts of this user to first admin
+  # reassign all comments of this user to first admin
+  # if doesn't exist any other administrator, this will cancel the user destroy
+  def reassign_posts
+    all_posts.each do |p|
+      s = p.post_type.site
+      u = s.users.admin_scope.where.not(id: self.id).first
+      if u.present?
+        p.update_column(:user_id, u.id)
+        p.comments.where(user_id: self.id).each do |c|
+          c.update_column(:user_id, u.id)
+        end
+      end
+    end
+  end
+
+  def reassign_comments
+    all_comments.includes(post: {post_type: :site}).each do |comment|
+      site = comment.post.post_type.site
+      user = site.get_anonymous_user
+      comment.update_column(:user_id, user.id)
+    end
+  end
+end

data/app/models/plugins.rb

@@ -0,0 +1,5 @@
+module Plugins
+  def self.table_name_prefix
+    'plugins_'
+  end
+end

data/app/models/themes.rb

@@ -0,0 +1,5 @@
+module Themes
+  def self.table_name_prefix
+    'themes_'
+  end
+end

data/app/uploaders/camaleon_cms_aws_uploader.rb

@@ -0,0 +1,132 @@
+class CamaleonCmsAwsUploader < CamaleonCmsUploader
+  def after_initialize
+    @cloudfront = @aws_settings[:cloud_front] || @current_site.get_option("filesystem_s3_cloudfront")
+    @aws_region = @aws_settings[:region] || @current_site.get_option("filesystem_region", 'us-west-2')
+    @aws_akey = @aws_settings[:access_key] || @current_site.get_option("filesystem_s3_access_key")
+    @aws_asecret = @aws_settings[:secret_key] || @current_site.get_option("filesystem_s3_secret_key")
+    @aws_bucket = @aws_settings[:bucket] || @current_site.get_option("filesystem_s3_bucket_name")
+    @aws_settings[:aws_file_upload_settings] ||= lambda{|settings| settings }
+    @aws_settings[:aws_file_read_settings] ||= lambda{|data, s3_file| data }
+  end
+
+  def setup_private_folder
+    if is_private_uploader?
+      add_folder(PRIVATE_DIRECTORY)
+
+      @aws_settings["inner_folder"] = "#{@aws_settings["inner_folder"]}/#{PRIVATE_DIRECTORY}"
+    end
+  end
+
+  # recover all files from AWS and parse it to save into DB as cache
+  def browser_files
+    bucket.objects({ prefix: @aws_settings["inner_folder"].presence || nil }).each do |file|
+      next if File.dirname(file.key).split('/').pop == 'thumb'
+      cache_item(file_parse(file))
+    end
+  end
+
+  # load media files from a specific folder path
+  def objects(prefix = '/', sort = 'created_at')
+    if @aws_settings["inner_folder"].present?
+      prefix = "#{@aws_settings["inner_folder"]}/#{prefix}".gsub('//', '/')
+      prefix = prefix[0..-2] if prefix.end_with?('/')
+    end
+    super(prefix, sort)
+  end
+
+  def fetch_file(file_name)
+    bucket.object(file_name).download_file(file_name) unless file_exists?(file_name)
+
+    if file_exists?(file_name)
+      file_name
+    else
+      raise ActionController::RoutingError, 'File not found'
+    end
+  end
+
+  # parse an AWS file into custom file_object
+  def file_parse(s3_file)
+    key = s3_file.is_a?(String) ? s3_file : s3_file.key
+    key = key.cama_fix_media_key
+    is_dir = s3_file.is_a?(String) || File.extname(key) == ''
+
+    if is_private_uploader?
+      url = is_dir ? '' : File.basename(key)
+    else
+      url = is_dir ? '' : (@cloudfront.present? ? File.join(@cloudfront, key) : s3_file.public_url)
+    end
+
+    res = {
+      "name" => File.basename(key),
+      "folder_path" => File.dirname(key),
+      "url" => url,
+      "is_folder" => is_dir,
+      "file_size" => is_dir ? 0 : s3_file.size.round(2),
+      "thumb" => '',
+      'file_type' => is_dir ? '' : self.class.get_file_format(key),
+      'created_at' => is_dir ? '' : s3_file.last_modified,
+      'dimension' => ''
+    }.with_indifferent_access
+    res["thumb"] = version_path(res['url']).sub('.svg', '.jpg') if res['file_type'] == 'image' && File.extname(res['name']).downcase != '.gif'
+    res['key'] = File.join(res['folder_path'], res['name'])
+    @aws_settings[:aws_file_read_settings].call(res, s3_file)
+  end
+
+  # add a file object or file path into AWS server
+  # :key => (String) key of the file ot save in AWS
+  # :args => (HASH) {same_name: false, is_thumb: false}, where:
+  #   - same_name: false => avoid to overwrite an existent file with same key and search for an available key
+  #   - is_thumb: true => if this file is a thumbnail of an uploaded file
+  def add_file(uploaded_io_or_file_path, key, args = {})
+    args, res = {same_name: false, is_thumb: false}.merge(args), nil
+    key = "#{@aws_settings["inner_folder"]}/#{key}" if @aws_settings["inner_folder"].present? && !args[:is_thumb]
+    key = key.cama_fix_media_key
+    key = search_new_key(key) unless args[:same_name]
+
+    if @instance # private hook to upload files by different way, add file data into result_data
+      _args={result_data: nil, file: uploaded_io_or_file_path, key: key, args: args, klass: self}; @instance.hooks_run('uploader_aws_before_upload', _args)
+      return _args[:result_data] if _args[:result_data].present?
+    end
+
+    s3_file = bucket.object(key.slice(1..-1))
+    s3_file.upload_file(uploaded_io_or_file_path.is_a?(String) ? uploaded_io_or_file_path : uploaded_io_or_file_path.path, @aws_settings[:aws_file_upload_settings].call({acl: 'public-read'}))
+    res = cache_item(file_parse(s3_file)) unless args[:is_thumb]
+    res
+  end
+
+  # add new folder to AWS with :key
+  def add_folder(key)
+    key = "#{@aws_settings["inner_folder"]}/#{key}" if @aws_settings["inner_folder"].present?
+    key = key.cama_fix_media_key
+    s3_file = bucket.object(key.slice(1..-1) << '/')
+    s3_file.put(body: nil)
+    cache_item(file_parse(s3_file))
+  end
+
+  # delete a folder in AWS with :key
+  def delete_folder(key)
+    key = "#{@aws_settings["inner_folder"]}/#{key}" if @aws_settings["inner_folder"].present?
+    key = key.cama_fix_media_key
+    bucket.objects(prefix: key.slice(1..-1) << '/').delete
+    get_media_collection.find_by_key(key).take.destroy
+  end
+
+  # delete a file in AWS with :key
+  def delete_file(key)
+    key = "#{@aws_settings["inner_folder"]}/#{key}" if @aws_settings["inner_folder"].present?
+    key = key.cama_fix_media_key
+    bucket.object(key.slice(1..-1)).delete rescue ''
+    @instance.hooks_run('after_delete', key)
+    get_media_collection.find_by_key(key).take.destroy
+  end
+
+  # initialize a bucket with AWS configurations
+  # return: (AWS Bucket object)
+  def bucket
+    @bucket ||= lambda{
+      config = Aws.config.update({ region: @aws_region, credentials: Aws::Credentials.new(@aws_akey, @aws_asecret) })
+      s3 = Aws::S3::Resource.new
+      bucket = s3.bucket(@aws_bucket)
+    }.call
+  end
+end

data/app/uploaders/camaleon_cms_local_uploader.rb

@@ -0,0 +1,108 @@
+class CamaleonCmsLocalUploader < CamaleonCmsUploader
+  def after_initialize
+    @root_folder = @args[:root_folder] || @current_site.upload_directory
+
+    FileUtils.mkdir_p(@root_folder)
+  end
+
+  def setup_private_folder
+    @root_folder = Rails.root.join(self.class::PRIVATE_DIRECTORY).to_s
+
+    FileUtils.mkdir_p(@root_folder) unless Dir.exist?(@root_folder)
+  end
+
+  def browser_files(prefix = '/', objects = {})
+    path = File.join(@root_folder, prefix)
+
+    Dir.entries(path).each do |f_name|
+      next if f_name == '..' || f_name == '.' || f_name == 'thumb'
+
+      obj = file_parse(File.join(path, f_name).sub(@root_folder, '').cama_fix_media_key)
+      cache_item(obj)
+
+      if obj['is_folder']
+        browser_files(File.join(prefix, obj['name']))
+      end
+    end
+  end
+
+  def fetch_file(file_name)
+    if file_exists?(file_name)
+      file_name
+    else
+      raise ActionController::RoutingError, 'File not found'
+    end
+  end
+
+  def file_parse(key)
+    file_path = File.join(@root_folder, key)
+    url_path, is_dir = file_path.sub(Rails.root.join('public').to_s, ''), File.directory?(file_path)
+    res = {
+        "name" => File.basename(key),
+        "folder_path" => File.dirname(key),
+        "url" => is_dir ? '' : (is_private_uploader? ? url_path.sub("#{@root_folder}/", '') : File.join(@current_site.decorate.the_url(as_path: true, locale: false, skip_relative_url_root: true), url_path)),
+        "is_folder" => is_dir,
+        "file_size" => is_dir ? 0 : File.size(file_path).round(2),
+        "thumb" => '',
+        'file_type' => self.class.get_file_format(file_path),
+        'dimension' => ''
+    }.with_indifferent_access
+    res['key'] = File.join(res['folder_path'], res['name'])
+    res["thumb"] = (is_private_uploader? ? '/admin/media/download_private_file?file=' + version_path(key).slice(1..-1) : version_path(res['url'])) if res['file_type'] == 'image' && File.extname(file_path).downcase != '.gif'
+    if res['file_type'] == 'image'
+      res["thumb"].sub! '.svg', '.jpg'
+      im = MiniMagick::Image.open(file_path)
+      res['dimension'] = "#{im[:width]}x#{im[:height]}"
+    end
+    res
+  end
+
+  # save a file into local folder
+  def add_file(uploaded_io_or_file_path, key, args = {})
+    args, res = {same_name: false, is_thumb: false}.merge(args), nil
+    key = search_new_key(key) unless args[:same_name]
+
+    if @instance # private hook to upload files by different way, add file data into result_data
+      _args={result_data: nil, file: uploaded_io_or_file_path, key: key, args: args, klass: self}; @instance.hooks_run('uploader_local_before_upload', _args)
+      return _args[:result_data] if _args[:result_data].present?
+    end
+
+    add_folder(File.dirname(key)) if File.dirname(key).present?
+    upload_io = uploaded_io_or_file_path.is_a?(String) ? File.open(uploaded_io_or_file_path) : uploaded_io_or_file_path
+    File.open(File.join(@root_folder, key), 'wb'){|file|       file.write(upload_io.read) }
+    res = cache_item(file_parse(key)) unless args[:is_thumb]
+    res
+  end
+
+  # create a new folder into local directory
+  def add_folder(key)
+    d, is_new_folder = File.join(@root_folder, key).to_s, false
+    unless Dir.exist?(d)
+      FileUtils.mkdir_p(d)
+      is_new_folder = true if File.basename(d) != 'thumb'
+    end
+    f = file_parse(key)
+    cache_item(f) if is_new_folder
+    f
+  end
+
+  # remove an existent folder
+  def delete_folder(key)
+    folder = File.join(@root_folder, key)
+    FileUtils.rm_rf(folder) if Dir.exist? folder
+    get_media_collection.find_by_key(key).take.destroy
+  end
+
+  # remove an existent file
+  def delete_file(key)
+    file = File.join(@root_folder, key)
+    FileUtils.rm(file) if File.exist? file
+    @instance.hooks_run('after_delete', key)
+    get_media_collection.find_by_key(key).take.destroy
+  end
+
+  # convert a real file path into file key
+  def parse_key(file_path)
+    file_path.sub(@root_folder, '').cama_fix_media_key
+  end
+end

data/app/uploaders/camaleon_cms_uploader.rb

@@ -0,0 +1,164 @@
+class CamaleonCmsUploader
+  PRIVATE_DIRECTORY = 'private'
+  
+  attr_accessor :thumb
+  # root_folder= '/var/www/my_public_foler/', current_site= CamaSite.first.decorate, thumb = {w: 100, h: 75},
+  # aws_settings: {region, access_key, secret_key, bucket}
+  def initialize(args = {}, instance = nil)
+    @current_site = args[:current_site]
+    t_w, t_h = @current_site.get_option('filesystem_thumb_size', '100x100').split('x')
+    @thumb = args[:thumb] || {w: t_w, h: t_h}
+    @aws_settings = args[:aws_settings] || {}
+    @args = args
+    @instance = instance
+    after_initialize
+  end
+
+  def after_initialize
+
+  end
+
+  # load media files from a specific folder path
+  def objects(prefix = '/', sort = 'created_at')
+    prefix = prefix.cama_fix_media_key
+    browser_files unless get_media_collection.any?
+    res = ['/', ''].include?(prefix) ? get_media_collection.where(folder_path: '/') : get_media_collection.find_by_key(prefix).take.try(:items)
+    # Private hook to recover custom files to include in current list where data can be modified to add custom{files, folders}
+    # Note: this hooks doesn't have access to public vars like params. requests, ...
+    if @instance
+      args={data: res, prefix: prefix}; @instance.hooks_run('uploader_list_objects', args)
+      res = args[:data]
+    end
+    res
+  end
+
+  # clean cached of files structure saved into DB
+  def clear_cache
+    get_media_collection.destroy_all
+  end
+
+  # search for folders or files that includes search_text in their names
+  def search(search_text)
+    get_media_collection.search(search_text)
+  end
+
+  # reload cache files structure
+  def reload
+    browser_files
+  end
+
+  # save file_parsed as a cache into DB
+  # file_parsed: (HASH) File parsed object
+  # objects_db: HASH Object where to add the current object (optional)
+  def cache_item(file_parsed, _objects_db = nil, custom_cache_key = nil)
+    unless get_media_collection.where(name: file_parsed['name'], folder_path: file_parsed['folder_path']).any?
+      a = get_media_collection.new(file_parsed.except('key'))
+      a.save!
+    end
+    file_parsed
+  end
+
+  # return the media collection for current situation
+  def get_media_collection
+    is_private_uploader? ? @current_site.public_media : @current_site.private_media
+  end
+
+
+  # convert current string path into file version_path, sample:
+  # version_path('/media/1/screen.png') into /media/1/thumb/screen-png.png (thumbs)
+  # Sample: version_path('/media/1/screen.png', '200x200') ==> /media/1/thumb/screen-png_200x200.png (image versions)
+  def version_path(image_path, version_name = nil)
+    res = File.join(File.dirname(image_path), 'thumb', "#{File.basename(image_path).parameterize}#{File.extname(image_path)}")
+    res = res.cama_add_postfix_file_name("_#{version_name}") if version_name.present?
+    res
+  end
+
+  # return the file format (String) of path (depends of file extension)
+  def self.get_file_format(path)
+    ext = File.extname(path).sub(".", "").downcase
+    format = "unknown"
+    format = "image" if get_file_format_extensions('image').split(",").include?(ext)
+    format = "video" if get_file_format_extensions('video').split(",").include?(ext)
+    format = "audio" if get_file_format_extensions('audio').split(",").include?(ext)
+    format = "document" if get_file_format_extensions('document').split(",").include?(ext)
+    format = "compress" if get_file_format_extensions('compress').split(",").include?(ext)
+    format
+  end
+
+  # return the files extensión for each format
+  # support for multiples formats, sample: image,audio
+  def self.get_file_format_extensions(format)
+    res = []
+    format.downcase.gsub(' ', '').split(',').each do |f|
+      res << case f
+                when 'image', 'images'
+                  "jpg,jpeg,png,gif,bmp,ico,svg"
+                when 'video', 'videos'
+                  "flv,webm,wmv,avi,swf,mp4,mov,mpg"
+                when 'audio'
+                  "mp3,ogg"
+                when 'document', 'documents'
+                  "pdf,xls,xlsx,doc,docx,ppt,pptx,html,txt,xml,json"
+                when 'compress'
+                  "zip,7z,rar,tar,bz2,gz,rar2"
+                else
+                  ''
+              end
+    end
+    res.join(',')
+  end
+
+  # verify permitted formats (return boolean true | false)
+  # true: if format is accepted
+  # false: if format is not accepted
+  # sample: validate_file_format('/var/www/myfile.xls', 'image,audio,docx,xls') => return true if the file extension is in formats
+  def self.validate_file_format(key, valid_formats = "*")
+    return true if valid_formats == "*" || !valid_formats.present?
+    valid_formats = valid_formats.gsub(' ', '').downcase.split(',') + get_file_format_extensions(valid_formats).split(',')
+    valid_formats.include?(File.extname(key).sub(".", "").split('?').first.try(:downcase))
+  end
+
+
+  # verify if this file name already exist
+  # if the file is already exist, return a new name for this file
+  # sample: search_new_key("my_file/file.txt")
+  def search_new_key(key)
+    _key = key
+    if get_media_collection.find_by_key(key).any?
+      (1..999).each do |i|
+        _key = key.cama_add_postfix_file_name("_#{i}")
+        break unless get_media_collection.find_by_key(_key).any?
+      end
+    end
+    _key
+  end
+
+  # check if file with :key exist and return parsed_file, else return nil
+  def get_file(key, use_cache = true)
+    # deprecated
+  end
+
+  def enable_private_mode!
+    @args[:private] = true
+
+    setup_private_folder
+  end
+
+  def disable_private_mode!
+    @args[:private] = false
+  end
+
+  def file_exists?(file_name)
+    File.exist?(file_name)
+  end
+
+  private
+  def cache_key
+    "cama_media_cache#{'_private' if is_private_uploader?}"
+  end
+
+  # check if this uploader is private mode
+  def is_private_uploader?
+    @args[:private]
+  end
+end