forgeos_core 1.9.1

data/lib/forgeos/core.rb

@@ -0,0 +1,12 @@
+require 'forgeos'
+require 'forgeos/core/engine'
+
+module Forgeos
+  module Core
+  end
+end
+
+require File.join(File.dirname(__FILE__), '..', 'sphinx_globalize')
+require File.join(File.dirname(__FILE__), '..', 'sortable_attachments')
+require File.join(File.dirname(__FILE__), '..', 'extensions')
+require File.join(File.dirname(__FILE__), '..', 'map_fields')

data/lib/forgeos/statistics.rb

@@ -0,0 +1,11 @@
+module Forgeos
+  class Statistics
+    def self.total_of_visitors(date = nil)
+      VisitorCounter.sum(:counter, :conditions => { :date => date})
+    end
+
+    def self.keywords_most_searched(date = nil, limit = nil)
+      SearchKeywordCounter.sum(:counter, :conditions => { :date => date}, :group => :element_id, :limit => limit)
+    end
+  end
+end

data/lib/forgeos.rb

@@ -0,0 +1,89 @@
+# coding: utf-8
+# encoding: utf-8
+module Forgeos
+  autoload :Statistics, 'forgeos/statistics'
+  autoload :Urlified, 'forgeos/urlified'
+
+  def self.url_generator(phrase = '', sep = '-')
+    return '' if phrase.nil?
+    url = phrase.dup
+    { %w(á à â ä ã Ã Ä Â À) => 'a',
+      %w(é è ê ë Ë É È Ê €) => 'e',
+      %w(í ì î ï I Î Ì) => 'i',
+      %w(ó ò ô ö õ Õ Ö Ô Ò) => 'o',
+      %w(ç) => 'c',
+      %w(œ) => 'oe',
+      %w(ß) => 'ss',
+      %w(ú ù û ü U Û Ù) => 'u',
+      %w(\/ \| & = # ' " \?) => '',
+      %w(\s+ _) => sep
+    }.each do |ac,rep|
+      url.gsub!(Regexp.new(ac.join('|')), rep)
+    end
+
+    url.squeeze(sep).gsub(/(^#{sep}+|#{sep}+$)/,'').downcase
+  end
+
+  AdminMenu = [
+    { :title => 'back_office.menu.dashboard',
+      :url => '/admin/dashboard',
+      :i18n => true,
+      :html => { :class => 'left first'}
+    },
+    { :title => 'back_office.menu.users',
+      :url => '/admin/users',
+      :i18n => true,
+      :html => { :class => 'left'}
+    },
+    { :title => 'back_office.menu.statistics',
+      :url => '/admin/statistics',
+      :i18n => true,
+      :html => { :class => 'right' }
+    }
+  ]
+
+  AdminSubMenu = [
+    { :title => 'back_office.menu.administration',
+      :i18n => true,
+      :url => [
+        '/admin/administrators',
+        '/admin/roles',
+        '/admin/rights'
+      ],
+      :html => { :class => 'left first'}
+    },
+    { :title => 'back_office.menu.settings',
+      :i18n => true,
+      :url => '/admin/setting',
+      :html => { :class => 'left' }
+    },
+    { :title => 'back_office.menu.library',
+      :i18n => true,
+      :url => [
+        '/admin/library',
+        '/admin/images/attachments',
+        '/admin/pdf/attachments',
+        '/admin/audio/attachments',
+        '/admin/video/attachments',
+        '/admin/media/attachments',
+        '/admin/doc/attachments'
+      ],
+      :html => { :class => 'left' }
+    },
+    { :title => 'back_office.menu.accounts',
+      :i18n => true,
+      :url => '/admin/account',
+      :html => { :class => 'left' }
+    },
+    { :title => 'back_office.menu.logout',
+      :i18n => true,
+      :url => '/admin/logout',
+      :html => { :class => 'right' }
+    },
+    { :title => 'back_office.menu.support',
+      :i18n => true,
+      :url => 'http://www.webpulser.com',
+      :html => { :class => 'right first' }
+    }
+  ]
+end

data/lib/forgeos_core.rb

@@ -0,0 +1 @@
+require 'forgeos/core'

data/lib/map_fields.rb

@@ -0,0 +1,187 @@
+# coding: utf-8
+require (RUBY_VERSION.to_f >= 1.9 ? 'csv' : 'fastercsv')
+
+module MapFields
+  VERSION = '1.0.0'
+  CsvParser = (RUBY_VERSION.to_f >= 1.9 ? CSV : FasterCSV)
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def map_fields(action, fields, options = {})
+      include MapFields::InstanceMethods
+      write_inheritable_array("map_fields_fields_#{action}", fields)
+      write_inheritable_attribute("map_fields_options_#{action}", options)
+      write_inheritable_attribute(:map_fields_actions, []) unless read_inheritable_attribute(:map_fields_actions)
+      write_inheritable_attribute(:map_fields_actions, (read_inheritable_attribute(:map_fields_actions) << action).uniq)
+      skip_filter :map_fields
+      skip_filter :map_fields_cleanup
+      before_filter :map_fields, :only =>  read_inheritable_attribute(:map_fields_actions)
+      after_filter :map_fields_cleanup, :only =>  read_inheritable_attribute(:map_fields_actions)
+    end
+  end
+
+
+  module InstanceMethods
+    def map_fields
+      default_options = {
+        :file_field => 'file',
+        :params => []
+      }
+      options = default_options.merge(
+        self.class.read_inheritable_attribute("map_fields_options_#{params[:action]}")
+      )
+      if session[:map_fields].nil? || params[options[:file_field]]
+        session[:map_fields] = {}
+        if params[options[:file_field]].blank?
+          @map_fields_error = MissingFileContentsError
+          return
+        end
+
+        file_field = params[options[:file_field]]
+
+        temp_path = File.join(Dir::tmpdir, "map_fields_#{Time.now.to_i}_#{$$}")
+        File.open(temp_path, 'wb') do |f|
+          f.write file_field.read
+        end
+
+        session[:map_fields][:file] = temp_path
+      end
+
+      if params[:fields].nil?
+        @rows = []
+        parser_options = session[:parser_options] = params[:parser_options].symbolize_keys
+        CsvParser.foreach(temp_path, parser_options) do |row|
+          @rows << row
+          break if @rows.size == 5
+        end
+        expected_fields = self.class.read_inheritable_attribute("map_fields_fields_#{params[:action]}")
+        @fields = ([nil] + expected_fields).inject([]){ |o, e| o << [e, o.size]}
+        @parameters = []
+        options[:params].each do |param|
+          @parameters += ParamsParser.parse(params, param)
+        end
+      else
+        if @set
+          @mapped_fields = MappedFields.new(session[:map_fields][:file],
+                                            @set.fields,
+                                            @set.ignore_first_row,
+                                            @set.parser_options)
+
+        else
+          if session[:map_fields][:file].nil? || params[:fields].nil?
+            session[:map_fields] = nil
+            @map_fields_error =  InconsistentStateError
+          else
+            @mapped_fields = MappedFields.new(session[:map_fields][:file],
+                                              params[:fields],
+                                              params[:ignore_first_row],
+                                              session[:parser_options])
+          end
+        end
+      end
+    end
+
+    def mapped_fields
+      @mapped_fields
+    end
+
+    def fields_mapped?
+      raise @map_fields_error if @map_fields_error
+      @mapped_fields
+    end
+
+    def map_field_parameters(&block)
+
+    end
+
+    def map_fields_cleanup
+      if @mapped_fields
+        if session[:map_fields][:file]
+          File.delete(session[:map_fields][:file])
+        end
+        session[:map_fields] = nil
+        @mapped_fields = nil
+        @map_fields_error = nil
+      end
+    end
+  end
+
+  class MappedFields
+    def initialize(file, mapping, ignore_first_row, parser_options)
+      @file = file
+      @parser_options = parser_options
+      @mapping = {}
+      @ignore_first_row = ignore_first_row
+      mapping.each do |k,v|
+        @mapping[v.to_i - 1] = k.to_i - 1 unless v.to_i == 0
+      end
+    end
+
+    def each
+      row_number = 1
+      CsvParser.foreach(@file,@parser_options) do |csv_row|
+        unless row_number == 1 && @ignore_first_row
+          row = []
+          @mapping.each do |k,v|
+            row[k] = csv_row[v]
+          end
+          row.class.send(:define_method, :number) { row_number }
+          yield(row)
+        end
+        row_number += 1
+      end
+    end
+
+    def size
+      @size = CsvParser.read(@file,@parser_options).size
+      @size -= 1 if @ignore_first_row
+      return @size
+    end
+  end
+
+  class InconsistentStateError < StandardError
+  end
+
+  class MissingFileContentsError < StandardError
+  end
+
+  class ParamsParser
+    def self.parse(params, field = nil)
+      result = []
+      params.each do |key,value|
+        if field.nil? || field.to_s == key.to_s
+          check_values(value) do |k,v|
+            result << ["#{key.to_s}#{k}", v]
+          end
+        end
+      end
+      result
+    end
+
+    private
+    def self.check_values(value, &block)
+      result = []
+      if value.kind_of?(Hash)
+        value.each do |k,v|
+          check_values(v) do |k2,v2|
+            result << ["[#{k.to_s}]#{k2}", v2]
+          end
+        end
+      elsif value.kind_of?(Array)
+        value.each do |v|
+          check_values(v) do |k2, v2|
+            result << ["[]#{k2}", v2]
+          end
+        end
+      else
+        result << ["", value]
+      end
+      result.each do |arr|
+        yield arr[0], arr[1]
+      end
+    end
+  end
+end

data/lib/sortable_attachments.rb

@@ -0,0 +1,42 @@
+module SortableAttachments
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    def has_and_belongs_to_many_attachments(options = {})
+      has_many :attachment_links, :as => :element, :order => :position
+      has_many :attachments, { :through => :attachment_links, :class_name => 'Attachment', :order => :position }.merge(options)
+      has_many :pictures, :through => :attachment_links, :class_name => 'Picture', :source => :attachment, :order => :position
+      has_many :docs, :through => :attachment_links, :class_name => 'Doc', :source => :attachment, :order => :position
+      has_many :videos, :through => :attachment_links, :class_name => 'Video', :source => :attachment, :order => :position
+      has_many :pdfs, :through => :attachment_links, :class_name => 'Pdf', :source => :attachment, :order => :position
+      has_many :audios, :through => :attachment_links, :class_name => 'Audio', :source => :attachment, :order => :position
+      has_many :medias, :through => :attachment_links, :class_name => 'Media', :source => :attachment, :order => :position
+
+      unless self.instance_methods.include?('attachment_ids_with_position=')
+        include SortableAttachments::InstanceMethods
+        alias_method_chain :attachment_ids=, :position
+      end
+    end
+  end
+
+  module InstanceMethods
+    def attachment_ids_with_position=(attachment_ids)
+      self.attachment_ids_without_position=(attachment_ids)
+      reset_attachment_positions_by_ids(attachment_ids)
+    end
+
+    def reset_attachment_positions_by_ids(ids)
+      return if self.new_record?
+      ids.each_with_index do |id, i|
+        connection.update(
+          "UPDATE `attachment_links` SET `position` = #{i} " +
+          "WHERE `element_id` = #{self.id} AND `element_type` = '#{self.class.base_class}' AND `attachment_id` = #{id}"
+        ) if id.to_i != 0
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include,SortableAttachments)

data/lib/sphinx_globalize.rb

@@ -0,0 +1,23 @@
+module Sphinx
+  module Globalize
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def define_translated_index(*attr_names)
+        klass_name = self.table_name.singularize
+        translation_table_name = "#{klass_name}_translations"
+        I18n.available_locales.each do |locale|
+          self.define_index "#{klass_name}_#{locale}" do
+            where "`#{translation_table_name}`.`locale` = '#{locale}'"
+            attr_names.each do |attr|
+              indexes translations(attr), :as => attr, :sortable => true
+            end
+          end
+        end
+      end
+    end
+  end
+end
+ActiveRecord::Base.send(:include,Sphinx::Globalize)

data/lib/tasks/attachments_migration.rake

@@ -0,0 +1,24 @@
+namespace :forgeos do
+  namespace :core do
+    desc 'copy attachments association table values into an unique table'
+    task :attachments_migration => :environment do
+      elements = [] <<
+      Product.all <<
+      User.all <<
+      Attribute.all <<
+      ProductType.all <<
+      Category.all <<
+      AttributeValue.all
+
+      elements.flatten.each do |element|
+        print "#{element.class} ##{element.id} : "
+        element.attachments2 = element.attachments
+        if element.save
+          puts 'ok'
+        else
+          puts element.errors.inspect
+        end
+      end
+    end
+  end
+end

data/lib/tasks/fixtures.rake

@@ -0,0 +1,64 @@
+namespace :forgeos do
+  namespace :core do
+    namespace :fixtures do
+      desc "Load seed fixtures (from db/fixtures) into the current environment's database."
+      task :load, [:plugin_name, :tables] => :environment do |t,args|
+        require 'active_record/fixtures'
+
+        if args.plugin_name && args.tables
+          PLUGIN_PATH = Gem.loaded_specs[args.plugin_name].full_gem_path
+          tables = args.tables.split(' ')
+        else
+          puts "usage: rake forgeos:core:fixtures:load[PLUGIN_NAME,table_name1,table_name2];"
+          exit
+        end
+
+        tables.each do |file|
+          file_name = File.basename(file, '.yml')
+          begin
+            Fixtures.create_fixtures(File.join(PLUGIN_PATH,'db','fixtures'), file_name)
+            puts "Loaded #{file_name} fixtures"
+          rescue
+            puts "#{file_name} fixtures not loaded"
+          end
+        end
+      end
+
+      desc 'Create YAML test fixtures from data in an existing database.
+      Defaults to development database. Set RAILS_ENV to override.'
+      task :extract => :environment do
+        PLUGIN_PATH = Gem.loaded_specs['forgeos_core'].full_gem_path
+
+        skip_tables = ["schema_info", "sessions"]
+        ActiveRecord::Base.establish_connection
+
+        unless ARGV[1].nil? && ARGV[1].blank?
+          tables = (ARGV[1]== 'all') ? ActiveRecord::Base.connection.tables - skip_tables : ARGV[1].split(',')
+        else
+          puts "usage: rake forgeos:core:fixtures:extract table_name1,table_name2;"
+          exit
+        end
+
+        sql = "SELECT * FROM `%s`"
+        tables.each do |table_name|
+          i = "000"
+          begin
+            File.open(File.join(PLUGIN_PATH,'db','fixtures',"#{table_name}.yml"), 'w') do |file|
+              puts "extract #{table_name}"
+              data = ActiveRecord::Base.connection.select_all(sql % table_name)
+              file.write data.inject({}) { |hash, record|
+                hash["#{table_name}_#{i.succ!}"] = record
+                hash["#{table_name}_#{i}"].delete('id')
+                hash["#{table_name}_#{i}"].delete('created_at')
+                hash["#{table_name}_#{i}"].delete('updated_at')
+                hash
+              }.rehash.to_yaml
+            end
+          rescue
+            puts "#{table_name} can't be extracted"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tasks/generate.rake

@@ -0,0 +1,60 @@
+require 'active_record/fixtures'
+
+namespace :forgeos do
+  namespace :core do
+    namespace :generate do
+
+      desc "Generates a role per controller and a right per controller action."
+      task :acl, [:path] => :environment do |t,args|
+
+        # set project path
+        # By default, plugin path
+        # else path is set to the first argument provided.
+        if args.path
+          project_path = args.path
+        else
+          puts 'usage : rake forgeos:core:generate:acl[iproject_path>]'
+          exit
+        end
+
+        # list admin controllers
+        path = File.join(project_path, 'app', 'controllers', 'admin')
+
+        if File.directory? path
+          # create a role for each controller and its associated actions rights
+          Dir.foreach(path) do |filename|
+            next if filename.match(/^\./) or !filename.match(/\.rb$/) or File.directory?(File.join(path, filename))
+
+            controller_underscore = filename.gsub(".rb", "")
+            controller_name = controller_underscore.gsub("_controller", "")
+            controller = ("admin/"+controller_underscore).camelize.constantize
+
+            print "generating rights for #{controller_name} "
+
+            unless right_category = RightCategory.find_by_name(controller_name)
+              right_category = RightCategory.create( :name => controller_name )
+            end
+
+            # create a right per controller action, & link it with the right RightCategory
+            controller.action_methods.reject { |action| ApplicationController.action_methods.include?(action) }.each do |action|
+              right = Right.find_or_create_by_name_and_controller_name_and_action_name "#{controller_name}_#{action}", "admin/#{controller_name}", action
+              right_category.elements << right if right_category.elements.all( :conditions => { :name => "#{controller_name}_#{action}" }).empty?
+              print '.'
+            end
+            puts ' [ok]'
+          end
+
+          role = Role.first || Role.create(:name => 'super administrator')
+          admin = Administrator.first
+
+          print "associate rights to #{role.name} "
+          role.update_attributes(:right_ids => Right.all(:select => :id).collect(&:id))
+          puts ' [ok]'
+          print "associate role to first admin "
+          admin.update_attribute(:role_id,role.id)
+          puts ' [ok]'
+        end
+      end
+    end
+  end
+end

data/lib/tasks/install.rake

@@ -0,0 +1,9 @@
+namespace :forgeos do
+  namespace :core do
+    desc "load fixtures and generate forgeos_core controllers ACLs"
+    task :install => [ :environment, 'forgeos_core_engine:install:migrations', 'db:migrate' ] do
+      system 'rake "forgeos:core:fixtures:load[forgeos_core,people geo_zones settings]"'
+      system "rake 'forgeos:core:generate:acl[#{Gem.loaded_specs['forgeos_core'].full_gem_path}]'"
+    end
+  end
+end

data/lib/tasks/translations.rake

@@ -0,0 +1,15 @@
+task :model_translations, [:model] => :environment do |t,args|
+  klass = args.model.camelize.constantize
+  puts klass
+  klass.all.each do |model|
+    attributes = {}
+    model.translated_attributes.keys.each do |method|
+      attributes[method] = model.attributes[method.to_s]
+    end
+    if model.update_attributes(attributes)
+      puts "translated #{model.id}"
+    else
+      puts model.errors.inspect
+    end
+  end
+end

data/lib/tasks/update_thumbnails.rake

@@ -0,0 +1,50 @@
+namespace :forgeos do
+  namespace :core do
+    desc 'update pictures from modified or added thumbnails formats'
+    task :update_thumbnails => :environment do
+      pictures = Picture.find_all_by_parent_id(nil)
+      pictures.each_with_index do |picture,i|
+        puts "Fixing #{i}/#{pictures.size} : #{picture.filename}"
+        temp_file = picture.create_temp_file
+
+        picture.attachment_options[:thumbnails].each { |suffix, size|
+          picture.create_or_update_thumbnail(temp_file, suffix, *size)
+          puts "  #{suffix}"
+        }
+        #sleep 2
+      end
+    end
+    task :update_thumbnails_with_options, [:start, :end, :thumb] => :environment do |t,options|
+      unless options[:start] && options[:end] && options[:thumb]
+        puts 'usage : rake forgeos:core:update_thumbnails_with_options[start,end,thumb]'
+        exit
+      end
+      pictures = Picture.find_all_by_parent_id(nil)
+      options[:start].blank? ? _start = 0 : _start = options[:start].to_i
+      options[:end].blank? ? _end = (pictures.size-1) : _end = options[:end].to_i
+      format = options[:thumb].to_sym
+
+      i = _start
+      pictures[_start.._end].each do |picture|
+        puts "Fixing #{i}/#{_end} : #{picture.filename}"
+        temp_file = picture.create_temp_file
+
+        size = picture.attachment_options[:thumbnails][format.to_sym]
+        unless size.nil?
+          picture.create_or_update_thumbnail(temp_file, options[:thumb] , *size)
+          puts "=> #{options[:thumb]} ...... [ok]"
+        else
+          puts "================================="
+          puts "* cannot find this thumb format *"
+          puts "================================="
+          puts ""
+          puts "=> below the list of thumb formats"
+          picture.attachment_options[:thumbnails].keys.each do |key|
+            puts "- #{key}"
+          end
+        end
+        i = _start + 1
+      end
+    end
+  end
+end