forgeos_core 1.9.1

data/app/controllers/admin/administrators_controller.rb

@@ -0,0 +1,95 @@
+class Admin::AdministratorsController < Admin::BaseController
+  before_filter :get_admin, :only => [:show, :edit, :update, :destroy, :activate]
+
+  def index
+    respond_to do |format|
+      format.html # index.html.erb
+      format.json do
+        sort
+        render :layout => false
+      end
+    end
+  end
+
+  def show
+  end
+
+  def new
+    @admin = Administrator.new(params[:administrator])
+  end
+
+  def edit
+  end
+
+  def create
+    @admin = Administrator.new(params[:administrator])
+    if @admin.save
+      flash[:notice] = t('admin.create.success').capitalize
+      redirect_to [forgeos_core, :edit, :admin, @admin]
+    else
+      flash[:error] = t('admin.create.failed').capitalize
+      render :action => "new"
+    end
+  end
+
+  def update
+    if @admin.update_attributes(params[:administrator])
+      flash[:notice] = t('admin.update.success').capitalize
+    else
+      flash[:error] = t('admin.update.failed').capitalize
+    end
+    render :action => "edit"
+  end
+
+  def destroy
+    if request.delete? && @admin.destroy
+      flash[:notice] = t('admin.destroy.success').capitalize
+    else
+      flash[:error] = t('admin.destroy.failed').capitalize
+    end
+    redirect_to([forgeos_core, :admin, :administrators])
+  end
+
+  def activate
+    render :text => (@admin.active? ? @admin.disactivate : @admin.activate)
+  end
+private
+
+  def get_admin
+    unless @admin = Administrator.find_by_id(params[:id])
+      flash[:error] = t('admin.not_exist').capitalize
+      return redirect_to([forgeos_core, :admin, :administrators])
+    end
+  end
+
+  def sort
+    columns = %w(id lastname roles.name email active)
+    per_page = params[:iDisplayLength].to_i
+    offset =  params[:iDisplayStart].to_i
+    page = (offset / per_page) + 1
+    order_column = params[:iSortCol_0].to_i
+    order = "#{columns[order_column]} #{params[:iSortDir_0].upcase}"
+
+    conditions = {}
+    includes = []
+    options = { :page => page, :per_page => per_page }
+
+    if params[:category_id]
+      conditions[:categories_elements] = { :category_id => params[:category_id] }
+      includes << :admin_categories
+    end
+
+    includes << :role if order_column == 2
+
+    options[:conditions] = conditions unless conditions.empty?
+    options[:include] = includes unless includes.empty?
+    options[:order] = order unless order.squeeze.blank?
+
+    if params[:sSearch] && !params[:sSearch].blank?
+      options[:star] = true
+      @admins = Administrator.search(params[:sSearch],options)
+    else
+      @admins = Administrator.paginate(:all,options)
+    end
+  end
+end

data/app/controllers/admin/attachments_controller.rb

@@ -0,0 +1,195 @@
+class Admin::AttachmentsController < Admin::BaseController
+  before_filter :get_media, :only => [:show, :download, :edit, :update, :destroy]
+  before_filter :get_categories, :only => [:index]
+  before_filter :get_thumbnails, :only => [:show, :edit, :update]
+  skip_before_filter :verify_authenticity_token, :only => [:create]
+
+  def manage
+    @attachments = "#{params[:file_type]}".classify.constantize.paginate :page => params[:page], :order => 'created_at DESC', :per_page => 10, :conditions => { :parent_id => nil}
+    render :partial => 'tiny_mce_list'
+  end
+
+  def index
+    respond_to do |format|
+      format.html
+      format.json do
+        sort
+        render :layout => false
+      end
+    end
+  end
+
+  # GET /medias/1
+  def show
+  end
+
+  # GET /medias/1
+  def download
+    send_file(@media.full_filename)
+  end
+
+  # GET /medias/1/edit
+  def edit
+  end
+
+  def update
+    file_type = nil
+    %w(media picture pdf audio video doc).each do |key|
+      if params[key]
+        params[:attachment] = params[key]
+        file_type = key
+      end
+    end
+    params[:attachment][:filename] = @media.filename
+    rack_file = params[:attachment][:uploaded_data]
+    if !(rack_file.respond_to?(:file_type) && !@media.class.attachment_options[:content_type].include?(rack_file.file_type)) &&
+      @media.update_attributes(params[:attachment])
+      flash[:notice] = I18n.t('media.update.success').capitalize
+    else
+      flash[:error] = I18n.t('product.update.failed').capitalize
+      edit
+    end
+    render :action => 'edit'
+  end
+
+  # POST /medias
+  def create
+    respond_to do |format|
+      format.json do
+        if params[:Filedata]
+          require 'mime/types'
+          filename = params[:Filename] || params[:Filedata].original_path
+          @content_type = MIME::Types.type_for(filename).first.to_s
+          media_class = Media
+          [Audio,Video,Pdf,Doc,Picture].each do |klass|
+            media_class = klass if klass.attachment_options[:content_type].include?(@content_type)
+          end
+
+          @media = media_class.new(params[:attachment])
+          @media.uploaded_data = { 'tempfile' => params[:Filedata], 'content_type' => @content_type, 'filename' => Forgeos::url_generator(filename)}
+
+          if @media.save
+            flash[:notice] = I18n.t('media.create.success').capitalize
+
+            if params[:target] && params[:target_id] && !params[:target].blank?
+              type = target.constantize
+              object = type.find_by_id(params[:target_id])
+              attachments = (object.attachment_ids << @media.id)
+              object.update_attribute('attachment_ids', attachments)
+            end
+
+            if params[:parent_id]
+              parent_category = Category.find_by_id(params[:parent_id])
+              if parent_category
+               @media.attachment_categories << parent_category
+              end
+            end
+
+            render :json => { :result => 'success', :id => @media.id, :path => @media.public_filename(''), :size => @media.size, :type => @media.type.to_s.upcase }
+          else
+            render :json => { :result => 'error', :error => @media.errors.first }
+          end
+        else
+          render :json => { :result => 'error', :error => 'bad parameters' }
+        end
+      end
+      format.js do
+        if params[:Filedata]
+          require 'mime/types'
+          filename = params[:Filedata].original_path
+          @content_type = MIME::Types.type_for(filename).first.to_s
+          media_class = Media
+          [Video,Pdf,Doc,Picture].each do |klass|
+            media_class = klass if klass.attachment_options[:content_type].include?(@content_type)
+          end
+
+          @media = media_class.new(params[:attachment])
+          @media.uploaded_data = { 'tempfile' => params[:Filedata], 'content_type' => @content_type, 'filename' => Forgeos::url_generator(filename)}
+
+          @media.save
+        end
+          responds_to_parent do
+            render(:update) do |page|
+              page << "upload_callback();"
+            end
+          end
+      end
+    end
+  end
+
+  # DELETE /medias/1
+  def destroy
+    if @media.destroy
+      flash[:notice] = I18n.t('media.destroy.success').capitalize
+    else
+      flash[:notice] = I18n.t('media.destroy.failed').capitalize
+    end
+    return render(:nothing => true) if request.xhr?
+    return redirect_to(forgeos_core.admin_attachments_path(:file_type => @media.class.to_s.underscore))
+  end
+
+  private
+
+  def get_media
+    @media = Attachment.find_by_id params[:id]
+    unless @media
+      flash[:error] = I18n.t('media.not_exist').capitalize
+      return redirect_to([forgeos_core, :admin, :library])
+    end
+  end
+
+  def get_thumbnails
+    @thumbnails = @media ? @media.thumbnails.all(:order => '(width*height) DESC') : []
+  end
+
+  def get_categories
+    @file_type = params[:file_type]
+    unless @file_type.nil?
+      type = "#{@file_type}_category".camelize.constantize
+    else
+      type = AttachmentCategory
+    end
+    @categories = type.find_all_by_parent_id(nil)
+  end
+
+  def sort
+    columns = %w(filename filename content_type attachments.updated_at size used '')
+    per_page = params[:iDisplayLength].to_i
+    offset =  params[:iDisplayStart].to_i
+    page = (offset / per_page) + 1
+    order = "#{columns[params[:iSortCol_0].to_i]} #{params[:iSortDir_0].upcase}"
+
+    conditions = { :parent_id => nil }
+    includes = []
+    options = { :page => page, :per_page => per_page }
+
+    # file type
+    unless @file_type.nil?
+      conditions[:type] = @file_type
+      type = @file_type.camelize.constantize
+    else
+      type = Attachment
+    end
+
+    # category
+    if params[:category_id]
+      conditions[:categories_elements] = { :category_id => params[:category_id] }
+      includes << :attachment_categories
+    end
+    if params[:ids]
+      conditions[:attachments] = { :id => params[:ids].split(',') }
+    end
+
+    options[:conditions] = conditions unless conditions.empty?
+    options[:include] = includes unless includes.empty?
+    options[:order] = order unless order.squeeze.blank?
+
+    if params[:sSearch] && !params[:sSearch].blank?
+      options[:star] = true
+      @medias = type.search(params[:sSearch],options)
+    else
+      @medias = type.paginate(:all,options)
+    end
+  end
+
+end

data/app/controllers/admin/base_controller.rb

@@ -0,0 +1,55 @@
+class Admin::BaseController < Forgeos::ApplicationController
+  layout 'admin'
+  helper_method :forgeos_js_functions_files, :forgeos_js_inits_files
+  before_filter :login_required, :edition_locale, :except => [:notifications, :url]
+  before_filter :forgeos_core_javascripts_files
+  skip_after_filter :log_visit
+  protect_from_forgery
+
+private
+
+  def forgeos_core_javascripts_files
+    @forgeos_js_functions_files = forgeos_javascripts_files('forgeos_core', 'forgeos/admin/functions')
+    @forgeos_js_inits_files = forgeos_javascripts_files('forgeos_core', 'forgeos/admin/inits')
+  end
+
+  def forgeos_javascripts_files(plugin_name, dir)
+    asset_dir = File.join(Gem.loaded_specs[plugin_name].full_gem_path, 'app', 'assets', 'javascripts')
+    Dir[File.join([asset_dir, dir, '**','*.js'].compact)].collect do |file|
+      file[-(file.size - asset_dir.size - 1)..-1].sub(/\.\w+$/, '')
+    end.sort
+  end
+
+  def forgeos_js_functions_files
+    @forgeos_js_functions_files || []
+  end
+
+  def forgeos_js_inits_files
+    @forgeos_js_inits_files || []
+  end
+
+  def login_required
+    unless current_user.is_a?(Administrator)
+      store_location
+      flash[:warning] = t(:login_required)
+      redirect_to([forgeos_core, :admin,:login])
+      return false
+    end
+    unless current_user.access_path?(params[:controller], params[:action])
+      store_location
+      flash[:warning] = t(:admin_access_denied)
+      if current_user.access_path?('admin/dashboard','index')
+        redirect_to([forgeos_core, :admin,:root])
+      else
+        redirect_to([forgeos_core, :admin, :login])
+      end
+      return false
+    end
+  end
+
+  def edition_locale
+    if session[:lang]
+      ActiveRecord::Base.locale = session[:lang]
+    end
+  end
+end

data/app/controllers/admin/cachings_controller.rb

@@ -0,0 +1,60 @@
+class Admin::CachingsController < Admin::BaseController
+  autoload :FileUtils, 'fileutils'
+
+  def index
+    @files = []
+    directory = Rails.configuration.action_controller.page_cache_directory
+    if directory
+      get_file(directory)
+    end
+  end
+
+  def create
+    if params[:commit] == t('caching.delete.all').capitalize
+      files = params[:hidden_files]
+    else
+      files = params[:file]
+    end
+
+    if files
+      files.values.each do |file|
+        unless File.delete(file)
+          flash[:error] = t('caching.delete.failed').capitalize
+          return redirect_to :action => 'index'
+        end
+      end
+    else
+      return redirect_to :action => 'index'
+      flash[:error] = t('caching.no_files').capitalize
+    end
+
+
+    begin
+      FileUtils.remove_dir(Rails.cache.cache_path, true)
+    rescue
+      p 'This cache directory does not exist'
+    end
+
+    flash[:success] = t('caching.delete.create').capitalize
+    return redirect_to :action => 'index'
+  end
+
+
+private
+
+  def get_file(directory)
+    dir = Dir.new(directory)
+    dir.each do |file|
+      path = "#{directory}/#{file}"
+      if File.directory?(path)
+        @files.delete(path)
+        unless file == '.' || file == '..'
+          get_file(path)
+        end
+      else
+        @files << [file, path]
+      end
+    end
+  end
+
+end

data/app/controllers/admin/categories_controller.rb

@@ -0,0 +1,152 @@
+# This Controller Manage Categories
+class Admin::CategoriesController < Admin::BaseController
+  before_filter :get_category, :only => [:edit, :update, :destroy, :add_element]
+  before_filter :new_category, :only => [:new, :create]
+  skip_before_filter :set_currency, :only => [:index]
+
+  # List Categories
+  def index
+    respond_to do |format|
+      format.html{ redirect_to([forgeos_core, :root]) }
+      format.json do
+        unless params[:type]
+          # list page and product categories
+          sort
+          render :layout => false
+        else
+          # list categories like a tree
+          klass = params[:type].camelize.constantize
+          @categories = klass.roots
+
+          render :json => @categories.collect(&:to_jstree).to_json
+        end
+      end
+    end
+  end
+
+  def new
+  end
+
+  # Create a Category
+  # ==== Params
+  # * category = Hash of Category's attributes
+  #
+  # The Category can be a child of another Category.
+  def create
+    if @category.save
+      flash[:notice] = t('category.create.success').capitalize
+      respond_to do |format|
+        format.html { redirect_to [forgeos_core, :edit, :admin, @category] }
+        format.json { render :text => @category.id }
+      end
+    else
+      flash[:error] = t('category.create.failed').capitalize
+      render :action => 'new'
+    end
+  end
+
+  # Edit a Category
+  # ==== Params
+  # * id = Category's id to edit
+  # * category = Hash of Category's attributes
+  #
+  # The Category can be a child of another Category.
+  def edit
+  end
+
+  def update
+    if categories = params[:categories_hash]
+      paramz = ActiveSupport::JSON.decode(categories)
+      paramz.each_with_index do | param, position |
+        parent_id = nil
+        update_category_from_params(param, position, parent_id)
+      end
+    elsif @category.update_attributes(params[:category])
+      flash[:notice] = t('category.update.success').capitalize
+    else
+      flash[:error] = t('category.update.failed').capitalize
+    end
+
+    respond_to do |format|
+      format.html { render :action => 'edit' }
+      format.json { render :text => @category.total_elements_count }
+    end
+  end
+
+  # Destroy a Category
+  # ==== Params
+  # * id = Category's id
+  # ==== Output
+  #  if destroy succed, return the Categories list
+  def destroy
+    if @category.destroy
+      flash[:notice] = t('category.destroy.success').capitalize
+    else
+      flash[:error] = t('category.destroy.failed').capitalize
+    end
+    render :text => true
+  end
+
+  def add_element
+    @category.update_attribute(:element_ids, @category.element_ids << params[:element_id].to_i)
+    render :text => @category.elements.count
+  end
+
+private
+  def get_category
+    unless @category = Category.find_by_id(params[:id])
+      flash[:error] = t('category.not_exist').capitalize
+      return redirect_to(:action => :index)
+    end
+  end
+
+  def new_category
+    @category = Category.new(params[:category])
+  end
+
+  def update_category_from_params(param, position, parent_id)
+    if id = param["attributes"]["id"].split("_").last
+      if category = Category.find_by_id(id)
+        children_ids = []
+        if children = param["children"]
+          children.each_with_index do | child, position_child |
+            if child_id = child["attributes"]["id"].split("_").last
+              children_ids << child_id
+              if child["children"].present?
+                update_category_from_params(child, (position+1+position_child+1), id)
+              elsif _child = Category.find_by_id(child_id)
+                _child.update_attributes(:parent_id => id, :position => (position+1+position_child+1))
+              end
+            end
+          end
+        end
+        category.update_attributes(:position => position+1, :parent_id => parent_id )
+      end
+    end
+  end
+
+  def sort
+    columns = %w(category_translations.name category_translations.name)
+    per_page = params[:iDisplayLength].present? ? params[:iDisplayLength].to_i : 50
+    offset =  params[:iDisplayStart].to_i
+    page = (offset / per_page) + 1
+    #order_column = params[:iSortCol_0].to_i
+    #order = "#{columns[order_column]} #{params[:iSortDir_0].upcase}"
+    order = 'position ASC'
+    conditions = {}
+    conditions[:type] = params[:types].collect{ |type| "#{type}Category".camelize } if params[:types]
+
+    options = { :page => page, :per_page => per_page }
+    options[:conditions] = conditions unless conditions.empty?
+    options[:order] = order unless order.squeeze.blank?
+    options[:include] = :translations
+
+    if params[:sSearch] && !params[:sSearch].blank?
+      options[:star] = true
+      options[:sql_order] = options.delete(:order)
+      @categories = Category.search(params[:sSearch], options)
+    else
+      @categories = Category.paginate(:all, options)
+    end
+  end
+end

data/app/controllers/admin/dashboard_controller.rb

@@ -0,0 +1,10 @@
+class Admin::DashboardController < Admin::BaseController
+  def index; end
+
+  def change_lang
+    if params[:lang] && I18n.available_locales.include?(params[:lang].to_sym)
+      session[:lang] = params[:lang].to_sym
+    end
+    redirect_to(:back)
+  end
+end

data/app/controllers/admin/import_controller.rb

@@ -0,0 +1,102 @@
+class Admin::ImportController < Admin::BaseController
+  include MapFields
+  UPLOAD_PROGRESS_FILE = File.join(Rails.root,'tmp','import_progress.txt')
+  before_filter :save_import_set, :except => :index
+  map_fields :create_user, User.new.attributes.keys
+  before_filter :models, :only => :index
+
+  def index; end
+
+  def create_user
+    create_model(User,'email')
+  end
+
+  def progress
+    if File.exist?(UPLOAD_PROGRESS_FILE)
+      render :text => File.open(UPLOAD_PROGRESS_FILE,'r').read
+    else
+      render :nothing => true
+    end
+  end
+
+  private
+
+  def models
+    @models = ['user']
+  end
+
+  def create_model(klass, uniq_field = nil, &block)
+    File.open(UPLOAD_PROGRESS_FILE, 'w') {|f| f.write(0) }
+    if fields_mapped?
+      total = mapped_fields.size
+      created = 0
+      updated = 0
+      errors = []
+      methods = self.class.read_inheritable_attribute("map_fields_fields_#{params[:action]}")
+      mapped_fields.each do |row|
+        logger.debug("\033[01;33m Number : #{row.number} / #{total}\033[0m")
+
+        attributes = ActiveSupport::OrderedHash.new
+        methods.each_with_index do |attribute,i|
+          exist = params[:fields].values.include?((i+1).to_s)
+          attributes[attribute.to_sym] = row[i] if exist
+        end
+
+        if block_given?
+          attributes = yield(attributes) || {}
+        end
+
+        uniq_field_index = methods.index(uniq_field)
+
+        if uniq_field != nil && row[uniq_field_index] != nil && object = klass.send("find_by_#{uniq_field}",row[uniq_field_index])
+          if object.update_attributes(attributes)
+            updated+=1
+          else
+            errors << object.errors
+            logger.debug("\033[01;33m#{object.errors.inspect}\033[0m")
+          end
+        else
+          object = klass.new(attributes)
+          if object.save
+            created+=1
+          else
+            errors << object.errors
+            logger.debug("\033[01;33m#{object.errors.inspect}\033[0m")
+          end
+        end
+        File.open(UPLOAD_PROGRESS_FILE, 'w') {|f| f.write((row.number.to_f / total.to_f) * 100.0) } if row.number.modulo(10).zero?
+      end
+
+      flash[:notice] = t('import.create.success', :model => t(klass.to_s.underscore, :count => created), :nb => "#{created}/#{total}") if created != 0
+      flash[:warning] = t('import.update.success', :model => t(klass.to_s.underscore, :count => updated), :nb => "#{updated}/#{total}") if updated != 0
+      errors_count = errors.flatten.size
+      flash[:error] = t('import.failed.errors', :model => t(klass.to_s.underscore, :count => errors_count), :nb =>"#{ errors_count}/#{total}") unless errors.empty?
+      File.open(UPLOAD_PROGRESS_FILE, 'w') {|f| f.write(100.0) }
+      render(:nothing => true)
+    else
+      render(:action => 'create')
+    end
+    rescue StandardError => error
+      File.open(UPLOAD_PROGRESS_FILE, 'w') {|f| f.write(100.0) }
+      render(:text => error.inspect, :status => 500)
+  end
+
+  private
+
+  def save_import_set
+    @set = ImportSet.find_by_id(params[:set_id])
+    if params[:save_set]
+      set_attributes = {
+        :fields => params[:fields],
+        :parser_options => session[:parser_options],
+        :ignore_first_row => params[:ignore_first_row],
+        :name => params[:set_name]
+      }
+      if @set = ImportSet.find_by_id(params[:set_id])
+        @set.update_attributes(set_attributes)
+      else
+        @set = ImportSet.create(set_attributes)
+      end
+    end
+  end
+end