camaleon_cms 0.0.1

data/app/helpers/uploader_helper.rb

@@ -0,0 +1,144 @@
+=begin
+  Camaleon CMS is a content management system
+  Copyright (C) 2015 by Owen Peredo Diaz
+  Email: owenperedo@gmail.com
+  This program is free software: you can redistribute it and/or modify   it under the terms of the GNU Affero General Public License as  published by the Free Software Foundation, either version 3 of the  License, or (at your option) any later version.
+  This program is distributed in the hope that it will be useful,  but WITHOUT ANY WARRANTY; without even the implied warranty of  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the  GNU Affero General Public License (GPLv3) for more details.
+=end
+module UploaderHelper
+  # upload a file into server
+  # settings:
+  #   folder: Directory where the file will be saved (default: current_site.upload_directory)
+  #     sample: temporal => will save in /rails_path/public/temporal
+  #   maximum: maximum bytes permitted to upload (default: 1000MG)
+  #   formats: extensions permitted, sample: jpg,png,... or generic: images | videos | audios | documents (default *)
+  #   create_folder: auto create folder if it doesn't exist (default: true)
+  #   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 = {})
+    unless uploaded_io.present?
+      return {error: "File is empty", file: nil, size: nil}
+    end
+    settings = settings.to_sym
+    filename = uploaded_io.original_filename.parameterize(".").downcase.gsub(" ", "-")
+    res = {error: nil, file: filename, size: File.size(uploaded_io.to_io)}
+    #settings[:folder] = File.join(Rails.public_path, settings[:folder]) if settings[:folder].present?
+    settings = {
+        folder: current_site.upload_directory,
+        maximum: 100.megabytes,
+        formats: "*",
+        create_folder: true,
+        temporal_time: 0
+      }.merge(settings)
+    settings[:folder] = settings[:folder].to_s
+    if settings[:create_folder] && !File.directory?(settings[:folder])
+      FileUtils.mkdir_p(settings[:folder])
+      FileUtils.chmod(0655, folder)
+    end
+
+    # folder validation
+    unless File.directory?(settings[:folder])
+      res[:error] = "Directory not found"
+      return res
+    end
+
+
+    file_path = uploader_verify_name(File.join(settings[:folder], filename).to_s)
+
+    # formats validations
+    if settings[:formats] != "*"
+      case settings[:formats]
+        when "images"
+          settings[:formats] = "jpg,jpeg,png,gif,bmp"
+        when "videos"
+          settings[:formats] = "flv,webm,wmv,avi,swf,mp4"
+        when "audios"
+          settings[:formats] = "mp3,ogg"
+        when "documents"
+          settings[:formats] = "pdf,xls,xlsx,doc,docx,ppt,pptx,html,txt"
+        when "compresed"
+          settings[:formats] = "zip,7z,rar,tar,bz2,gz,rar2"
+      end
+
+      unless settings[:formats].downcase.split(",").include?(File.extname(file_path).sub(".", "").downcase)
+        res[:error] = ct("file_format_error")
+        return res
+      end
+    end
+
+    # file size validations
+    if settings[:maximum] < File.size(uploaded_io.to_io)
+      res[:error] = ct("file_size_exceeded")
+      return res
+    end
+
+    begin
+      File.open(file_path, 'wb') do |file|
+        file.write(uploaded_io.read)
+      end
+    rescue => e
+      res[:error] = e.message
+      return res
+    end
+
+    TemporalFileJob.set(wait: settings[:is_temporal]).perform_later(file_path) if settings[:temporal_time] > 0
+    {
+        "file" => file_path,
+        "name"=> File.basename(file_path),
+        "size"=> File.size(file_path),
+        "url"=> file_path_to_url(file_path),
+        "type"=> uploaded_io.content_type,
+        "deleteUrl"=> ""
+    }
+  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)
+    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 file_path_to_url(file_path)
+    file_path.sub(Rails.public_path.to_s, root_url)
+  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)
+  def crop_image(file, w, h, w_offset, h_offset, resize = nil )
+    file_dir = File.join(Rails.public_path, file)
+    puts "-------file_dir--------#{file_dir}----------"
+    image = MiniMagick::Image.open(file_dir)
+    image.combine_options do |i|
+      i.resize(resize) if resize.present?
+      i.crop "#{w.to_i}x#{h.to_i}+#{w_offset}+#{h_offset}!"
+    end
+    ext = File.extname(file_dir)
+    image.write file_dir.gsub(ext, "_crop#{ext}")
+    file.gsub(ext, "_crop#{ext}")
+  end
+
+end

data/app/helpers/user_roles_helper.rb

@@ -0,0 +1,14 @@
+=begin
+  Camaleon CMS is a content management system
+  Copyright (C) 2015 by Owen Peredo Diaz
+  Email: owenperedo@gmail.com
+  This program is free software: you can redistribute it and/or modify   it under the terms of the GNU Affero General Public License as  published by the Free Software Foundation, either version 3 of the  License, or (at your option) any later version.
+  This program is distributed in the hope that it will be useful,  but WITHOUT ANY WARRANTY; without even the implied warranty of  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the  GNU Affero General Public License (GPLv3) for more details.
+=end
+#encoding: utf-8
+module UserRolesHelper
+  def _get_roles_values
+    UserRole::ROLES
+  end
+end

data/app/mailers/html_mailer.rb

@@ -0,0 +1,47 @@
+=begin
+  Camaleon CMS is a content management system
+  Copyright (C) 2015 by Owen Peredo Diaz
+  Email: owenperedo@gmail.com
+  This program is free software: you can redistribute it and/or modify   it under the terms of the GNU Affero General Public License as  published by the Free Software Foundation, either version 3 of the  License, or (at your option) any later version.
+  This program is distributed in the hope that it will be useful,  but WITHOUT ANY WARRANTY; without even the implied warranty of  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the  GNU Affero General Public License (GPLv3) for more details.
+=end
+class HtmlMailer < ActionMailer::Base
+  #include ApplicationHelper
+  default from: "WPRails <info@wprails.com>"
+
+  # Subject can be set in your I18n file at config/locales/en.yml
+  # with the following lookup:
+  #
+  #   en.user_mailer.password_reset.subject
+  #
+  def sender(email, subject='Hello', content='', from=nil, attachs=[], url_base='', current_site, template_path, template_name)
+    from = "WPRails <info@wprails.com>" if from.nil?
+    @subject = subject
+    @html = content
+    @url_base = url_base
+    @current_site = current_site
+
+    if attachs.present?
+      attachs.each do |attach|
+        attachments["#{File.basename(attach)}"] = File.open(attach, 'rb'){|f| f.read}
+      end
+    end
+
+
+    #begin
+      if email.present?
+        mail to: email, subject: subject, from: from, template_path: template_path, template_name: template_name.to_s
+
+      else
+        Rails.logger.debug "Error: Email no presente: \"#{subject}\""
+      end
+    #rescue => e
+    #  Rails.logger.debug "Error al envio de email para #{email} \"#{subject}\": #{e.inspect}"
+    #end
+
+
+  end
+
+
+end

data/app/models/ability.rb

@@ -0,0 +1,113 @@
+=begin
+  Camaleon CMS is a content management system
+  Copyright (C) 2015 by Owen Peredo Diaz
+  Email: owenperedo@gmail.com
+  This program is free software: you can redistribute it and/or modify   it under the terms of the GNU Affero General Public License as  published by the Free Software Foundation, either version 3 of the  License, or (at your option) any later version.
+  This program is distributed in the hope that it will be useful,  but WITHOUT ANY WARRANTY; without even the implied warranty of  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the  GNU Affero General Public License (GPLv3) for more details.
+=end
+class Ability
+  include CanCan::Ability
+
+  def initialize(user, current_site = nil)
+    # Define abilities for the passed in user here. For example:
+    #
+    user ||= User.new # guest user (not logged in)
+    if user.admin?
+      can :manage, :all
+    elsif user.client?
+      can :read, :all
+    else
+      #conditions:
+      @roles_manager = user.get_role(current_site).meta["_manager_#{current_site.id.to_s}".to_sym] || {} rescue {}
+      @roles_post_type ||= user.get_role(current_site).meta["_post_type_#{current_site.id.to_s}".to_sym] || {} rescue {}
+
+      ids_publish = @roles_post_type[:publish] || []
+      ids_edit = @roles_post_type[:edit] || []
+      ids_edit_other = @roles_post_type[:edit_other] || []
+      ids_edit_publish = @roles_post_type[:edit_publish] || []
+      ids_delete = @roles_post_type[:delete] || []
+      ids_delete_other = @roles_post_type[:delete_other] || []
+      ids_delete_publish = @roles_post_type[:delete_publish] || []
+
+      can :posts, PostType do |pt|
+        (ids_edit + ids_edit_other + ids_edit_publish).to_i.include?(pt.id) rescue false
+      end
+
+      can :create_post, PostType do |pt|
+        ids_edit.to_i.include?(pt.id) rescue false
+      end
+      can :publish_post, PostType do |pt|
+        ids_publish.to_i.include?(pt.id) rescue false
+      end
+
+      can :categories, PostType do |pt|
+        @roles_post_type[:manage_categories].to_i.include?(pt.id) rescue false
+      end
+      can :post_tags, PostType do |pt|
+        @roles_post_type[:manage_tags].to_i.include?(pt.id) rescue false
+      end
+
+      can :update, Post do |post|
+        pt_id = post.post_type.id
+        r = false
+        r ||= (ids_edit).to_i.include?(pt_id) && post.user_id == user.id rescue false
+        r ||= (ids_edit_publish ).to_i.include?(pt_id) && post.published? rescue false
+        r ||= (ids_edit_other).to_i.include?(pt_id) && post.user_id != user.id  rescue false
+        r
+      end
+
+      can :destroy, Post do |post|
+        pt_id = post.post_type.id
+        r = false
+        r ||= (ids_delete).to_i.include?(pt_id) && post.user_id == user.id rescue false
+        r ||= (ids_delete_publish).to_i.include?(pt_id) && post.published? rescue false
+        r ||= (ids_delete_other).to_i.include?(pt_id) && post.user_id != user.id rescue false
+        r
+      end
+
+
+
+      #others
+      can :manage, :media     if @roles_manager[:media] rescue false
+      can :manage, :comments  if @roles_manager[:comments] rescue false
+      #can :manage, :forms     if @roles_manager[:forms] rescue false
+      can :manage, :themes    if @roles_manager[:themes] rescue false
+      can :manage, :widgets   if @roles_manager[:widgets] rescue false
+      can :manage, :nav_menu  if @roles_manager[:nav_menu] rescue false
+      can :manage, :plugins   if @roles_manager[:plugins] rescue false
+      can :manage, :users     if @roles_manager[:users] rescue false
+      can :manage, :settings  if @roles_manager[:settings] rescue false
+
+
+    end
+
+
+
+
+    # variants:
+
+    # can [:update, :destroy], [Article, Comment]
+
+    #alias_action :create, :read, :update, :destroy, :to => :crud
+    # can :crud, User
+
+    # can :invite, User
+
+    # can :read, Project, :priority => 1..3
+
+    # conditions:
+    # can :read, Project, :active => true, :user_id => user.id
+    # can :read, Project, :category => { :visible => true }
+    # can :manage, Project, :group => { :id => user.group_ids }
+    # can :read, Photo, Photo.scope_defined do |photo|
+    #   photo.groups.empty?
+    # end
+
+
+
+
+    # See the wiki for details:
+    # https://github.com/CanCanCommunity/cancancan/wiki/Defining-Abilities
+  end
+end

data/app/models/category.rb

@@ -0,0 +1,55 @@
+=begin
+  Camaleon CMS is a content management system
+  Copyright (C) 2015 by Owen Peredo Diaz
+  Email: owenperedo@gmail.com
+  This program is free software: you can redistribute it and/or modify   it under the terms of the GNU Affero General Public License as  published by the Free Software Foundation, either version 3 of the  License, or (at your option) any later version.
+  This program is distributed in the hope that it will be useful,  but WITHOUT ANY WARRANTY; without even the implied warranty of  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the  GNU Affero General Public License (GPLv3) for more details.
+=end
+class Category < TermTaxonomy
+  # term_group = site_id
+  # status = post_type_id
+
+  default_scope { where(taxonomy: :category) }
+  has_many :metas, ->{ where(object_class: 'Category')}, :class_name => "Meta", foreign_key: :objectid, dependent: :destroy
+  has_many :posts, foreign_key: :objectid, through: :term_relationships, :source => :objects
+  has_many :children, class_name: "Category", foreign_key: :parent_id
+  belongs_to :parent, class_name: "Category", foreign_key: :parent_id
+  belongs_to :post_type_parent, class_name: "PostType", foreign_key: :parent_id
+  belongs_to :owner, class_name: "User", foreign_key: :user_id
+
+  scope :no_empty, ->{ where("count > 0") }
+
+  #scope :parents, -> { where("term_taxonomy.parent_id IS NULL") }
+
+  before_save :set_site
+  before_destroy :set_posts_in_default_category
+
+  # return the post type of this category
+  def post_type
+    ctg = self
+    begin
+      pt = ctg.post_type_parent
+      ctg = ctg.parent
+    end while ctg.present?
+    pt
+  end
+
+  private
+  def set_site
+    pt = self.post_type
+    self.term_group = pt.site.id unless self.term_group.present?
+    self.status = pt.id unless self.status.present?
+  end
+
+  def set_posts_in_default_category
+    category_default = self.post_type.default_category
+    return if category_default == self
+    self.posts.each do |post|
+      if post.categories.where.not(id: self.id).blank?
+        post.assign_category(category_default.id)
+      end
+    end
+  end
+
+end

data/app/models/concerns/categories_tags_for_posts.rb

@@ -0,0 +1,140 @@
+=begin
+  Camaleon CMS is a content management system
+  Copyright (C) 2015 by Owen Peredo Diaz
+  Email: owenperedo@gmail.com
+  This program is free software: you can redistribute it and/or modify   it under the terms of the GNU Affero General Public License as  published by the Free Software Foundation, either version 3 of the  License, or (at your option) any later version.
+  This program is distributed in the hope that it will be useful,  but WITHOUT ANY WARRANTY; without even the implied warranty of  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the  GNU Affero General Public License (GPLv3) for more details.
+=end
+module CategoriesTagsForPosts extend ActiveSupport::Concern
+  included do
+    # data_tags: (String) tags name separated by commas, sample: "Tag1,Tag two,tag new"
+    # data_categories: (Array) array of category ids assigned for this post, sample: [1,2,3]
+    attr_accessible :data_tags, :data_categories
+    attr_accessor :data_tags, :data_categories
+
+    after_save :save_extra_data
+    after_save :check_default_category
+  end
+
+  # check if this post can manage categories
+  def manage_categories?
+    post_type.manage_categories?
+  end
+
+  # check if this post can manage tags
+  def manage_tags?
+    post_type.manage_tags?
+  end
+
+  # update category assignations for this post
+    # remove assignations that no longer exist
+    # add new assignations
+  # cats: (Array) array of category ids assigned for this post, sample: [1,2,3]
+  def update_categories(cats=[])
+    rescue_extra_data
+    cats = cats.to_i
+    old_categories = categories.pluck("term_taxonomy.id")
+    delete_categories = old_categories - cats
+    news_categories =  cats - old_categories
+    term_relationships.where("term_taxonomy_id in (?)", delete_categories ).destroy_all   if  delete_categories.present?
+    news_categories.each do |key|
+      term_relationships.create(:term_taxonomy_id => key)
+    end
+    update_counters("categories")
+  end
+
+  # update tags assignations for this post
+    # remove assignations that no longer exist
+    # add new assignations
+  # tags: (String) tags name separated by commas, sample: "Tag1,Tag two,tag new"
+  def update_tags(tags)
+    rescue_extra_data
+    tags = tags.split(",").strip
+    post_tags = self.post_type.post_tags
+    post_tags = post_tags.where("name not in (?)", tags) if tags.present?
+    self.term_relationships.where("term_taxonomy_id in (?)", post_tags.pluck("term_taxonomy.id")).destroy_all
+    tags.each do |f|
+      post_tag = self.post_type.post_tags.where({name: f}).first_or_create(slug: f.parameterize)
+      self.term_relationships.where({term_taxonomy_id: post_tag.id}).first_or_create
+    end
+    update_counters("tags")
+  end
+
+  # Assign this post for category with id: category_id
+  # categories_id: (Array) array of category ids assigned for this post, sample: [1,2,3]
+  def assign_category(categories_id)
+    categories_id = [categories_id] if categories_id.is_a?(Integer)
+    rescue_extra_data
+    categories_id.each do |key|
+      term_relationships.where(:term_taxonomy_id => key).first_or_create!
+    end
+    update_counters("categories")
+  end
+
+  # Assign this post for category with id: category_id
+  # categories_id: (Array) array of category ids assigned for this post, sample: [1,2,3]
+  def unassign_category(categories_id)
+    categories_id = [categories_id] if categories_id.is_a?(Integer)
+    rescue_extra_data
+    term_relationships.where(:term_taxonomy_id => categories_id).destroy_all
+    update_counters("categories")
+  end
+
+  # Assign new tags to this post
+  # tags_title: (String) tags name separated by commas, sample: "Tag1,Tag two,tag new"
+  def assign_tags(tag_titles)
+    update_counters_before
+    tags = tag_titles.split(",").strip
+    tags.each do |t|
+      post_tag = self.post_type.post_tags.where(name: t).first_or_create!
+      self.term_relationships.where({term_taxonomy_id: post_tag.id}).first_or_create!
+    end
+    update_counters("tags")
+  end
+
+  # Unassign tags from this post
+  # tags_title: (String) tags name separated by commas, sample: "Tag1,Tag two,tag new"
+  def unassign_tags(tag_titles)
+    update_counters_before
+    tags = tag_titles.split(",").strip
+    self.term_relationships.where({term_taxonomy_id: self.post_type.post_tags.where(name: tags).pluck(:id)}).destroy_all
+    update_counters("tags")
+  end
+
+  # update quantity of posts assigned for tags and categories assigned to this post
+  def update_extra_data
+    rescue_extra_data
+    update_counters
+  end
+
+  private
+  @cats_before, @tags_before = [], []
+  # save as a cache previous categories and tags assigned for this post
+  def rescue_extra_data
+    @cats_before = self.categories.pluck(:id) if manage_categories?
+    @tags_before = self.post_tags.pluck(:id) if manage_tags?
+  end
+
+  # update quantity of posts assigned for tags and categories assigned to this post
+  # if kind is empty, then this will update both: cats and tags
+  # kind: (string) tags | categories
+  def update_counters(kind = "")
+    self.post_type.full_categories.where(id: (@cats_before + self.categories.pluck(:id)).uniq).each { |c| c.update_column("count", c.posts.published.size) } if ["", "categories"].include?(kind) && manage_categories?
+    self.post_type.post_tags.where(id: (@tags_before + self.post_tags.pluck(:id)).uniq).each { |tag| tag.update_column("count", tag.posts.published.size) } if ["", "tags"].include?(kind) && manage_tags?
+  end
+
+  # save extra data such as: categories and tags assigned to this post
+  def save_extra_data
+    update_categories(self.data_categories) if manage_categories? && !self.data_categories.nil?
+    update_tags(self.data_tags) if manage_tags? && !self.data_tags.nil?
+  end
+
+  # auto assign default categories if none categories were assigned
+  def check_default_category
+    if manage_categories?
+      assign_category([self.post_type.default_category.id]) unless self.categories.present?
+    end
+  end
+
+end