gluttonberg-core 2.6.4 → 3.0.0

data/lib/gluttonberg/membership.rb

@@ -0,0 +1,9 @@
+membership = Pathname(__FILE__).dirname.expand_path
+
+require File.join(membership, "membership", "import")
+require File.join(membership, "membership", "export")
+
+module Gluttonberg
+  module Membership
+  end
+end

data/lib/gluttonberg/membership/export.rb

@@ -0,0 +1,82 @@
+module Gluttonberg
+  module Membership
+    module Export
+      extend ActiveSupport::Concern
+     
+      module ClassMethods
+        #export to a csv
+        def exportCSV
+          all_records = self.order("id asc").all
+          require 'csv'
+          other_columns = {}
+          CSV.generate do |csv|
+            other_columns = find_other_columns
+            csv << prepare_header_row
+            all_records.each do |record|
+              csv << prepare_row(record, other_columns)
+            end
+          end
+        end
+
+        private
+
+          def find_other_columns
+            other_columns = {}
+            index = 0
+            Rails.configuration.member_csv_metadata.each do |key , val|
+              if ![:first_name, :last_name , :email , :groups].include?(key)
+                other_columns[key] = index + fix_columns_count
+                index += 1
+              end
+            end
+            other_columns
+          end
+
+          def fix_columns_count
+            count = 1
+            count+= 1 unless Rails.configuration.member_csv_metadata[:first_name].blank? 
+            count+= 1 unless Rails.configuration.member_csv_metadata[:last_name].blank? 
+            count+= 1 unless Rails.configuration.member_csv_metadata[:email].blank? 
+            count+= 1 unless Rails.configuration.member_csv_metadata[:groups].blank? 
+            count
+          end
+
+          def prepare_header_row
+            header_row = [
+              "DATABASE ID"
+            ]
+
+            header_row << Rails.configuration.member_csv_metadata[:first_name] unless Rails.configuration.member_csv_metadata[:first_name].blank? 
+            header_row << Rails.configuration.member_csv_metadata[:last_name] unless Rails.configuration.member_csv_metadata[:last_name].blank? 
+            header_row << Rails.configuration.member_csv_metadata[:email] unless Rails.configuration.member_csv_metadata[:email].blank? 
+            header_row << Rails.configuration.member_csv_metadata[:groups] unless Rails.configuration.member_csv_metadata[:groups].blank? 
+             
+            Rails.configuration.member_csv_metadata.each do |key , val|
+              if ![:first_name, :last_name , :email , :groups].include?(key)
+                header_row << val
+              end
+            end
+            header_row
+          end
+
+          def prepare_row(record, other_columns)
+            data_row = [record.id]
+            data_row << record.first_name unless Rails.configuration.member_csv_metadata[:first_name].blank? 
+            data_row << record.last_name unless Rails.configuration.member_csv_metadata[:last_name].blank? 
+            data_row << record.email unless Rails.configuration.member_csv_metadata[:email].blank? 
+            data_row << record.groups_name("; ") unless Rails.configuration.member_csv_metadata[:groups].blank? 
+            
+
+
+            other_columns.each do |key , val|
+              if !val.blank? && val >= 0
+                data_row[val] = record.send(key)
+              end
+            end
+            data_row
+          end
+
+      end #ClassMethods
+    end
+  end
+end

data/lib/gluttonberg/membership/import.rb

@@ -0,0 +1,179 @@
+module Gluttonberg
+  module Membership
+    module Import
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        ###############################
+        # takes complete path to csv file.
+        # and returns successfull_users , failed_users and updated_users arrays that contains user objects
+        # if user exist with given email then update its information
+        # otherwise create a new user for it
+        # returns [successfull_users , failed_users , updated_users , ]
+        # if csv format is incorrect then it will return a string "CSV file format is invalid"
+        def importCSV(file_path , invite , group_ids )
+          begin
+            require 'csv'
+            csv_table = CSV.read(file_path)
+          rescue => e
+            return "Please provide a valid CSV file with correct column names."
+          end
+
+          known_columns = PrivateMethods.find_known_columns(csv_table)
+          other_columns = PrivateMethods.find_other_columns(csv_table)
+
+          successfull_users = []
+          failed_users = []
+          updated_users = []
+
+          if PrivateMethods.known_columns_valid?(known_columns)
+            csv_table.each_with_index do |row , index |
+              if index > 0 # ignore first row because its meta data row
+                user_info = PrivateMethods.read_data_row(row, known_columns, other_columns)
+
+                #attach user to an group if its valid
+                PrivateMethods.attach_user_to_group(user_info, row, known_columns, other_columns, group_ids)
+
+                user = where(:email => row[known_columns[:email]]).first
+                if user.blank?
+                  PrivateMethods.create_member(user_info, invite, row, successfull_users , failed_users , updated_users)
+                else
+                  PrivateMethods.update_member(user, user_info, successfull_users , failed_users , updated_users)
+                end
+              end # if csv row index > 0
+            end #loop
+          else
+            return "Please provide a valid CSV file with correct column names"
+          end #if
+          [successfull_users , failed_users , updated_users ]
+        end
+
+        def contains_user?(user , list)
+          list.each do |record|
+            return true if record.id == user.id || record.email == user.email
+          end
+          false
+        end
+
+      end #ClassMethods
+
+      module PrivateMethods
+
+        # csv_table is two dimentional array
+        # col_name is a string.
+        # if structure is proper and column name found it returns column index from 0 to n-1
+        # otherwise nil
+        def self.find_column_position(csv_table  , col_name)
+          if csv_table.instance_of?(Array) && csv_table.count > 0 && csv_table.first.count > 0
+            csv_table.first.each_with_index do |table_col , index|
+              return index if table_col.to_s.upcase == col_name.to_s.upcase
+            end
+          end
+          nil
+        end
+
+        def self.find_known_columns(csv_table)
+          known_columns = {}
+          known_columns[:first_name]  = find_column_position(csv_table , Rails.configuration.member_csv_metadata[:first_name] )
+          known_columns[:last_name]   = find_column_position(csv_table ,  Rails.configuration.member_csv_metadata[:last_name]  )
+          known_columns[:email]       = find_column_position(csv_table , Rails.configuration.member_csv_metadata[:email] )
+          known_columns[:groups]      = find_column_position(csv_table , Rails.configuration.member_csv_metadata[:groups] )
+          known_columns
+        end
+
+        def self.find_other_columns(csv_table)
+          other_columns = {}
+          Rails.configuration.member_csv_metadata.each do |key , val|
+            if ![:first_name, :last_name , :email, :groups].include?(key)
+              other_columns[key] = find_column_position(csv_table , val )
+            end
+          end
+          other_columns
+        end
+
+        def self.read_data_row(row, known_columns, other_columns)
+          user_info = {
+            :group_ids => []
+          }
+          user_info[:first_name] = row[known_columns[:first_name]] unless Rails.configuration.member_csv_metadata[:first_name].blank? 
+          user_info[:last_name] = row[known_columns[:last_name]]  unless Rails.configuration.member_csv_metadata[:last_name].blank?
+          user_info[:email] = row[known_columns[:email]]  unless Rails.configuration.member_csv_metadata[:email].blank?
+
+          other_columns.each do |key , val|
+            if !val.blank? && val >= 0
+              if row[val].blank? || !user_info[key].kind_of?(String)
+                user_info[key] = row[val]
+              else
+                user_info[key] = row[val].force_encoding("UTF-8")
+              end
+            end
+          end
+          user_info
+        end
+
+        def self.known_columns_valid?(known_columns)
+          known_columns[:first_name] && known_columns[:email]
+        end
+
+        def self.attach_user_to_group(user_info, row, known_columns, other_columns, group_ids)
+          unless known_columns[:groups].blank? || row[known_columns[:groups]].blank?
+            group_names = row[known_columns[:groups]].split(";")
+            temp_group_ids = []
+            group_names.each do |group_name|
+              group = Gluttonberg::Group.where(:name => group_name.strip).first
+              temp_group_ids << group.id unless group.blank?
+            end
+            user_info[:group_ids] = temp_group_ids
+          end
+
+          unless group_ids.blank?
+            if user_info[:group_ids].blank?
+              user_info[:group_ids] = group_ids
+            else
+              user_info[:group_ids] << group_ids
+            end
+          end
+          user_info
+        end #attr_user_to_group
+
+        def self.prepare_user_record(user_info, row)
+          # generate random password
+          temp_password = Gluttonberg::Member.generateRandomString
+          password_hash = {
+            :password => temp_password ,
+            :password_confirmation => temp_password
+          }
+
+          # make user object
+          Gluttonberg::Member.new(user_info.merge(password_hash))
+        end
+
+        def self.create_member(user_info, invite, row, successfull_users , failed_users , updated_users)
+          user = PrivateMethods.prepare_user_record(user_info, row)
+          #if its valid then save it send an email and also add it to successfull_users array
+          if user.valid?
+            user.save
+            if invite == "1"
+              # we will regenerate password and send it member
+              MemberNotifier.delay.welcome(user)
+            end
+            successfull_users << user
+          else # if failed then add it to failed list
+            failed_users << user
+          end
+        end
+        
+        def self.update_member(user, user_info, successfull_users , failed_users , updated_users)
+          if !Gluttonberg::Member.contains_user?(user , successfull_users) and !Gluttonberg::Member.contains_user?(user , updated_users)
+            if user.update_attributes(user_info)
+              updated_users << user
+            else
+              failed_users << user
+            end
+          end
+        end
+
+      end #PrivateMethods
+    end #Import
+  end
+end

data/lib/gluttonberg/middleware/honeypot.rb

@@ -19,5 +19,4 @@ module Gluttonberg
 
     end
   end # Middleware
-end # Gluttonberg
-
+end # Gluttonberg

data/lib/gluttonberg/middleware/locales.rb

@@ -1,39 +1,90 @@
 module Gluttonberg
   module Middleware
+    # This middleware is used to extract locale info from current path.
+    # This helps gluttonberg pages and other controllers to access locale information easily.
     class Locales
       def initialize(app)
         @app = app
       end
 
+      # Reads current path if it contains any valid Gluttonberg::Locale slug 
+      # then it removes from path and add it to env['GLUTTONBERG.LOCALE_INFO']
+      # in addition to that it addes locale object to env['GLUTTONBERG.LOCALE']
+      #
+      # @param env [Hash] looking for PATH_INFO
       def call(env)
-        path = env['PATH_INFO']
-        unless path =~ /^#{Gluttonberg::Engine.config.admin_path}/ || path.start_with?("/stylesheets")  || path.start_with?("/javascripts")   || path.start_with?("/images") ||  path.start_with?("/gluttonberg")  || path.start_with?("/assets")  || path.start_with?("/user_asset")
+        env['PATH_INFO'] = '' if env['PATH_INFO'].nil?
+        path =  env['PATH_INFO']
+        unless Gluttonberg::Middleware::Locales.bypass_path?(path, env)
           case Gluttonberg::Engine.config.identify_locale
             when :subdomain
               # return the sub-domain
             when :prefix
-              if Gluttonberg.localized?
-                locale = path.split('/')[1]
-                if locale.blank?
-                  result = Gluttonberg::Locale.first_default
-                else
-                  result = Gluttonberg::Locale.find_by_locale(locale)
-                end
-              else # take default locale
-                result = Gluttonberg::Locale.first_default
-                locale = result.slug
-              end
-              if result
-                env['PATH_INFO'].gsub!("/#{locale}", '')
-                env['gluttonberg.locale'] = result
-                env['GLUTTONBERG.LOCALE_INFO'] = locale
-              end
+              handle_prefix(path, env)
             when :domain
               env['SERVER_NAME']
           end
         end
         @app.call(env)
       end
+
+      # Checks if we need to skip current path from analysing it for locales or gluttonberg pages
+      #
+      # @param path [String]
+      # @param env [Hash] Its not used anymore. CleaningRequired env param is not used anymore. Please remove it but make sure its also removed from the place where its called.
+      # @return [Boolean] fales if we cannot bypass current path otherwise true.
+      def self.bypass_path?(path, env)
+        if path.blank?
+          false
+        else
+          path =~ /^\/admin/ || path.start_with?("/stylesheets")  || path.start_with?("/javascripts")   || path.start_with?("/images") ||  path.start_with?("/gluttonberg")  || path.start_with?("/assets")  || path.start_with?("/user_asset")
+        end
+      end
+
+      private
+        # Reads current path if it contains any valid Gluttonberg::Locale slug 
+        # then it removes from path and add it to env['GLUTTONBERG.LOCALE_INFO']
+        # in addition to that it addes locale object to env['GLUTTONBERG.LOCALE']
+        #
+        # @param path [String]
+        # @param env [Hash] 
+        def handle_prefix(path, env)
+          if Gluttonberg.localized?
+            locale = path.split('/')[1]
+            if locale.blank?
+              result = Gluttonberg::Locale.first_default
+              locale = result.slug
+            else
+              result = Gluttonberg::Locale.find_by_locale(locale)
+              if result.blank?
+                result = Gluttonberg::Locale.first_default
+                locale = result.slug
+              end
+            end
+          else # take default locale
+            result = Gluttonberg::Locale.first_default
+            locale = result.slug
+          end
+          if result
+            extract_locale_prefix_from_path_info(locale, env)
+            env['GLUTTONBERG.LOCALE'] = result
+            env['GLUTTONBERG.LOCALE_INFO'] = locale
+          end
+        end
+
+        # Removes locale slug from env['PATH_INFO']
+        #
+        # @param path [String]
+        # @param env [Hash] 
+        def extract_locale_prefix_from_path_info(locale, env)
+          unless env['PATH_INFO'].blank?
+            if ![locale, "/#{locale}", "#{locale}/", "/#{locale}/"].include?(env['PATH_INFO'])
+              env['PATH_INFO'].gsub!("/#{locale}/", '/')
+            else
+              env['PATH_INFO'].gsub!("/#{locale}", '')
+            end
+          end
+        end
     end # Locales
   end # Middleware
 end # Gluttonberg

data/lib/gluttonberg/middleware/rewriter.rb

@@ -1,34 +1,75 @@
 module Gluttonberg
   module Middleware
+    # This middleware is used to extract page info from current path.
+    # This helps gluttonberg pages controller/helpers to access page information easily.
+    # It also rewrites to public pages if valid page path found
+    # This middleware assumed that Locale Middleware has already performed its 'call' action
     class Rewriter
       def initialize(app)
         @app = app
       end
 
+      # Reads current path and if its not needs to be bypassed or rails route then
+      # tries to find a Gluttonberg CMS Page using this path, if it finds a page then redirect to 
+      # Public::Page show action. It assigns page object env['GLUTTONBERG.PAGE'] , 
+      # env['GLUTTONBERG.PATH_INFO'] as as page path. It helps in debugging. 
+      # it also tries to find it by previous_path, if it finds a page then it redirects
+      # permanently to new path of this page. Othwerise
+      # it simply returns back from this middleware
+      #
+      # @param env [Hash] looking for PATH_INFO
       def call(env)
         path = env['PATH_INFO']
-        unless path =~ /^#{Gluttonberg::Engine.config.admin_path}/ || path.start_with?("/assets/") || path.start_with?("/user_asset/")
-          page = Gluttonberg::Page.find_by_path(path, env['gluttonberg.locale'] , env['HTTP_HOST'])
-          unless page.blank?
-            env['gluttonberg.page'] = page
-            env['GLUTTONBERG.PATH_INFO'] = path
-            if page.redirect_required?
-              return [301, {"Location" => page.redirect_url}, ["This resource has permanently moved to #{page.redirect_url}"]]
-            elsif page.rewrite_required?
-              env['PATH_INFO'] = page.generate_rewrite_path(path)
-            else
-              env['PATH_INFO'] = "/_public/page"
-            end
-          else
-            page = Gluttonberg::Page.find_by_previous_path(path, env['gluttonberg.locale'] , env['HTTP_HOST'])
+        unless Gluttonberg::Middleware::Locales.bypass_path?(path, env)
+          unless rails_route?(path)
+            page = Gluttonberg::Page.find_by_path(path, env['GLUTTONBERG.LOCALE'] , env['HTTP_HOST'])
             unless page.blank?
-              return [301, {"Location" => page.current_localization.path}, ["This resource has permanently moved to #{page.current_localization.path}"]]
+              env['GLUTTONBERG.PAGE'] = page
+              env['GLUTTONBERG.PATH_INFO'] = path # for debugging purpose
+              if page.redirect_required?
+                return redirect_param_array(page.redirect_url)
+              elsif page.rewrite_required?
+                env['PATH_INFO'] = page.generate_rewrite_path(path)
+              else
+                env['PATH_INFO'] = "/_public/page"
+              end
+            else
+              page = Gluttonberg::Page.find_by_previous_path(path, env['GLUTTONBERG.LOCALE'] , env['HTTP_HOST'])
+              unless page.blank?
+                return redirect_param_array(page.public_path)
+              end
             end
-          end
+          end # rails route
         end
 
         @app.call(env)
       end
+
+      private
+        # Wraps path into a format which is accepted by rails as permanent redirection
+        #
+        # @param path [String]
+        # @return [Array]
+        def redirect_param_array(path)
+          [301, {"Location" => path}, ["This resource has permanently moved to #{path}"]]
+        end
+
+        # Checks if current path is a rails route
+        #
+        # @param path [String]
+        # @return [Boolean]
+        def rails_route?(path)
+          begin
+            route = Rails.application.routes.recognize_path(path)
+          rescue
+          end
+          if route.blank?
+            false
+          else
+            route[:action] != "error_404"
+          end
+        end
+
     end # Rewriter
   end # Middleware
 end # Gluttonberg