gluttonberg-core 2.5

data/app/models/gluttonberg/comment.rb

@@ -0,0 +1,88 @@
+module Gluttonberg
+  class Comment < ActiveRecord::Base
+    self.table_name = "gb_comments"
+
+    attr_accessible :body , :author_name , :author_email , :author_website  , :subscribe_to_comments , :blog_slug
+
+    belongs_to :commentable, :polymorphic => true
+    belongs_to :article
+    belongs_to :author, :class_name => "Gluttonberg::Member"
+
+    before_save :init_moderation
+    after_save :send_notifications_if_needed
+
+    scope :all_approved, :conditions => { :approved => true }
+    scope :all_pending, :conditions => { :moderation_required => true }
+    scope :all_rejected, :conditions => { :approved => false , :moderation_required => false }
+
+    attr_accessor :subscribe_to_comments , :blog_slug
+    attr_accessible :body , :author_name , :author_email , :author_website , :commentable_id , :commentable_type , :author_id
+
+    can_be_flagged
+
+    clean_html [:body]
+
+    def moderate(params)
+        if params == "approve"
+          self.moderation_required = false
+          self.approved = true
+          self.save
+        elsif params == "disapprove"
+          self.moderation_required = false
+          self.approved = false
+          self.save
+        else
+          #error
+        end
+    end
+
+    def user_id
+      self.author_id
+    end
+
+    def user_id=(new_id)
+      self.author_id=new_id
+    end
+
+    # these are helper methods for comment.
+    def writer_email
+      if self.author_email
+        self.author_email
+      elsif author
+        author.email
+      end
+    end
+
+    def writer_name
+      if self.author_name
+        self.author_name
+      elsif author
+        author.name
+      end
+    end
+
+    def approved=(val)
+      @approve_updated = !self.moderation_required && val && self.notification_sent_at.blank? #just got approved
+      write_attribute(:approved, val)
+    end
+
+    protected
+      def init_moderation
+        if self.commentable.respond_to?(:moderation_required)
+          if self.commentable.moderation_required == false
+            self.approved = true
+            write_attribute(:moderation_required, false)
+          end
+        end
+        true
+      end
+
+      def send_notifications_if_needed
+        if @approve_updated == true
+          @approve_updated = false
+          CommentSubscription.notify_subscribers_of(self.commentable , self)
+        end
+      end
+
+  end
+end

data/app/models/gluttonberg/comment_subscription.rb

@@ -0,0 +1,26 @@
+module Gluttonberg
+  class CommentSubscription < ActiveRecord::Base
+    self.table_name = "gb_comment_subscriptions"
+
+    before_save    :generate_reference_hash
+    belongs_to     :article
+
+    def self.notify_subscribers_of(article , comment)
+      subscribers = self.find(:all , :conditions => {:article_id => article.id})
+      subscribers.each do |subscriber|
+        unless subscriber.author_email == comment.writer_email
+          Notifier.delay.comment_notification(subscriber , article , comment ) #.deliver # its using delayed job but i am setting sent time immediately
+          comment.notification_sent_at = Time.now
+          comment.save
+        end
+      end
+    end
+
+    def generate_reference_hash
+      unless self.reference_hash
+        self.reference_hash = Digest::SHA1.hexdigest(Time.now.to_s + self.author_email + self.article_id.to_s)
+      end
+    end
+
+  end
+end

data/app/models/gluttonberg/feed.rb

@@ -0,0 +1,14 @@
+module Gluttonberg
+  class Feed < ActiveRecord::Base
+    belongs_to :user
+    belongs_to :feedable, :polymorphic => true
+    self.table_name = "gb_feeds"
+    attr_accessible :user, :feedable_type, :feedable_id, :title, :action_type
+
+    def self.log(user,object,title,action_type)
+      self.create(:user => user , :feedable_type => object.class.to_s,  :feedable_id => object.id, :title => title , :action_type => action_type)
+    end
+
+
+  end
+end

data/app/models/gluttonberg/gallery.rb

@@ -0,0 +1,24 @@
+module Gluttonberg
+  class Gallery < ActiveRecord::Base
+    self.table_name = "gb_galleries"
+    include Content::SlugManagement
+    include Content::Publishable
+
+    attr_accessible :title, :slug, :description, :state, :published_at, :collection_imported
+    has_many :gallery_images , :order => "position ASC"
+    belongs_to :user
+
+    def name
+      title
+    end
+
+    def name=(new_name)
+      title = new_name
+    end
+
+    def images
+      gallery_images.map{|i| i.image }
+    end
+
+  end
+end

data/app/models/gluttonberg/gallery_image.rb

@@ -0,0 +1,9 @@
+module Gluttonberg
+  class GalleryImage < ActiveRecord::Base
+    self.table_name = "gb_gallery_images"
+    belongs_to :gallery
+    belongs_to :image  , :class_name => "Gluttonberg::Asset" , :foreign_key => "asset_id"
+    is_drag_tree :scope => :gallery_id , :flat => true , :order => "position"
+    attr_accessible :asset_id, :position
+  end
+end

data/app/models/gluttonberg/group.rb

@@ -0,0 +1,15 @@
+module Gluttonberg
+  class Group < ActiveRecord::Base
+    is_drag_tree :flat => true , :order => "position"
+    self.table_name = "gb_groups"
+    has_and_belongs_to_many :members, :class_name => "Member" , :join_table => "gb_groups_members"
+    has_and_belongs_to_many :pages, :class_name => "Gluttonberg::Page" , :join_table => "gb_groups_pages"
+
+    attr_accessible :name, :default
+
+    def self.default_group
+      self.where(:default =>  true).first
+    end
+
+  end
+end

data/app/models/gluttonberg/help.rb

@@ -0,0 +1,48 @@
+module Gluttonberg
+    class Help
+      # Default help paths
+      @@gluttonberg_help_path = "help"
+    
+      # first find help in engine, if it founds return true
+      # otherwise find in application. 
+      def self.help_available?(opts)
+        status = help_available_in(:engine , opts)
+        status ? status : help_available_in(:application , opts)
+      end
+      
+      # find help file in 'where'. if its :application then look into application 
+      # otherwise look in engine
+      def self.help_available_in(where , opts)
+        if where == :application
+          dir = template_dir_in_application(opts)
+        else
+          dir = template_dir_in_engine(opts)
+        end
+        
+        if dir
+          Dir.glob(File.join(dir ,  "/*") ).each do |template|
+            return true if template.match(opts[:page].to_s)
+          end
+        end
+        false
+      end
+    
+      def self.path_to_template(opts)
+        dir = template_dir(opts)
+        "#{dir}/#{opts[:page]}"
+      end
+    
+      def self.template_dir(opts)        
+        "#{@@gluttonberg_help_path}/#{opts[:controller]}"
+      end
+      
+      def self.template_dir_in_engine(opts)
+        File.join(Engine.root , "app/views" , template_dir(opts)   )
+      end
+      
+      def self.template_dir_in_application(opts)
+        File.join(Rails.root , "app/views" , template_dir(opts)   )
+      end
+      
+    end
+end

data/app/models/gluttonberg/html_content.rb

@@ -0,0 +1,10 @@
+module Gluttonberg
+  class HtmlContent  < ActiveRecord::Base
+    include Content::Block
+    self.table_name = "gb_html_contents"
+
+    is_localized do
+    end
+
+  end
+end

data/app/models/gluttonberg/image_content.rb

@@ -0,0 +1,10 @@
+module Gluttonberg
+  class ImageContent  < ActiveRecord::Base
+    include Content::Block
+    self.table_name = "gb_image_contents"
+    belongs_to :asset
+    attr_accessible :asset_id, :section_name
+    is_versioned
+
+  end
+end

data/app/models/gluttonberg/locale.rb

@@ -0,0 +1,37 @@
+module Gluttonberg
+  class Locale  < ActiveRecord::Base
+    include Content::SlugManagement
+    self.table_name = "gb_locales"
+
+    has_many    :page_localizations,  :class_name => "Gluttonberg::PageLocalization" , :dependent => :destroy
+
+    validates_presence_of :name , :slug
+    validates_uniqueness_of :slug , :name
+    attr_accessible :name, :slug, :slug_type, :default
+
+    SLUG_TYPES = ["prefix"]
+
+    def  self.first_default(opts={})
+      opts[:default] = true
+      find(:first , :conditions => opts )
+    end
+
+    def self.prefix_slug_type
+      SLUG_TYPES.first
+    end
+
+    def self.all_slug_types
+      SLUG_TYPES
+    end
+
+    def self.find_by_locale(locale_slug)
+      find(:first , :conditions => { :slug => locale_slug } )
+    end
+
+    def self.generate_default_locale
+      if Gluttonberg::Locale.find(:first , :conditions => {:slug => "en-au"}).blank?
+        locale = Gluttonberg::Locale.create( :slug => "en-au" , :name => "Australia English" , :default => true , :slug_type => Gluttonberg::Locale.prefix_slug_type )
+      end
+    end
+  end
+end

data/app/models/gluttonberg/member.rb

@@ -0,0 +1,272 @@
+module Gluttonberg
+  class Member < ActiveRecord::Base
+    self.table_name = "gb_members"
+
+    attr_accessible :first_name , :last_name , :email , :password , :password_confirmation , :bio , :image , :image_delete , :term_and_conditions, :group_ids
+
+    has_and_belongs_to_many :groups, :class_name => "Group" , :join_table => "gb_groups_members"
+    has_attached_file :image, :styles => { :profile => ["600x600"], :thumb => ["142x95#"] , :thumb_for_backend => ["100x75#"]}
+
+    validates_format_of :password, :with => /^(?=.*\d)(?=.*[a-zA-Z])(?!.*[^\w\S\s]).{6,}$/ , :if => :require_password?, :message => "must be a minimum of 6 characters in length, contain at least 1 letter and at least 1 number"
+
+    validates_presence_of :first_name , :email
+    attr_accessor :return_url , :term_and_conditions
+
+    attr_accessor :image_delete
+
+
+    clean_html [:bio]
+
+    acts_as_authentic do |c|
+      c.session_class = MemberSession
+      c.login_field = "email"
+    end
+
+    def full_name
+      self.first_name = "" if self.first_name.blank?
+      self.last_name = "" if self.last_name.blank?
+      self.first_name + " " + self.last_name
+    end
+
+    def deliver_password_reset_instructions!(current_localization_slug = "")
+      reset_perishable_token!
+      MemberNotifier.password_reset_instructions(self.id,current_localization_slug).deliver
+    end
+
+    def groups_name(join_str=", ")
+      unless groups.blank?
+        groups.map{|g| g.name}.join(join_str)
+      else
+        ""
+      end
+    end
+
+    def can_login?
+      !respond_to?(:can_login) || self.can_login == true
+    end
+
+    def self.enable_members
+      if Rails.configuration.enable_members == true || Rails.configuration.enable_members.kind_of?(Hash)
+        true
+      else
+        false
+      end
+    end
+
+    def self.does_email_verification_required
+      if Rails.configuration.enable_members == true
+        true
+      elsif Rails.configuration.enable_members.kind_of? Hash
+        if Rails.configuration.enable_members.has_key?(:email_verification)
+          Rails.configuration.enable_members[:email_verification]
+        else
+          true
+        end
+      else
+        false
+      end
+    end
+
+    def self.generateRandomString(length=10)
+      chars = ("A".."Z").to_a + ("0".."9").to_a
+      numbers = ("0".."9").to_a
+      similar_chars = %w{ i I 1 0 O o 5 S s }
+      chars.delete_if {|x| similar_chars.include? x}
+      numbers.delete_if {|x| similar_chars.include? x}
+      newpass = ""
+      1.upto(length-1) { |i| newpass << chars[rand(chars.size-1)] }
+      1.upto(1) { |i| newpass << numbers[rand(numbers.size-1)] }
+      newpass
+    end
+
+    def does_member_have_access_to_the_page?( page)
+      self.have_group?(page.groups)
+    end
+
+    def have_group?(groups)
+      if groups.find_all{|g| self.group_ids.include?(g.id)  }.blank?
+        false
+      else
+        true
+      end
+    end
+
+    ###############################
+    # 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 self.importCSV(file_path , invite , group_ids )
+      begin
+        if RUBY_VERSION >= "1.9"
+          require 'csv'
+          csv_table = CSV.read(file_path)
+        else
+          csv_table = FasterCSV.read(file_path)
+        end
+      rescue => e
+        return "Please provide a valid CSV file with correct column names."
+      end
+      first_name_column_num =   self.find_column_position(csv_table , Rails.configuration.member_csv_metadata[:first_name] )
+      last_name_column_num =   self.find_column_position(csv_table ,  Rails.configuration.member_csv_metadata[:last_name]  )
+      email_column_num =   self.find_column_position(csv_table , Rails.configuration.member_csv_metadata[:email] )
+      groups_column_num =   self.find_column_position(csv_table , Rails.configuration.member_csv_metadata[:groups] )
+      other_columns = {}
+
+      Rails.configuration.member_csv_metadata.each do |key , val|
+        if ![:first_name, :last_name , :email, :groups].include?(key)
+          other_columns[key] = self.find_column_position(csv_table , val )
+        end
+      end
+
+      successfull_users = []
+      failed_users = []
+      updated_users = []
+
+
+      if first_name_column_num && last_name_column_num  && email_column_num
+        csv_table.each_with_index do |row , index |
+            if index > 0 # ignore first row because its meta data row
+              #user information hash
+              user_info = {
+                :first_name => row[first_name_column_num] ,
+                :last_name => row[last_name_column_num] ,
+                :email => row[email_column_num],
+                :group_ids => []
+              }
+              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
+
+              #attach user to an industry if its valid
+              unless groups_column_num.blank? || row[groups_column_num].blank?
+                group_names = row[groups_column_num].split(";")
+                temp_group_ids = []
+                group_names.each do |group_name|
+                  group = Group.find(:first,:conditions=>{:name => group_name.strip})
+                  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 = self.find(:first , :conditions => { :email => row[email_column_num] } )
+              if user.blank?
+                # generate random password
+                temp_password = self.generateRandomString
+                password_hash = {
+                  :password => temp_password ,
+                  :password_confirmation => temp_password
+                }
+
+                # make user object
+                user = self.new(user_info.merge(password_hash))
+
+                #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
+              else
+                if  !self.contains_user?(user , successfull_users) and !self.contains_user?(user , updated_users)
+                    if user.update_attributes(user_info)
+                      updated_users << user
+                    else
+                      failed_users << user
+                    end
+                end
+              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 self.contains_user?(user , list)
+      list.each do |record|
+        return true if record.id == user.id || record.email == user.email
+      end
+      false
+    end
+
+    # 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
+        nil
+      else
+        nil
+      end
+    end
+
+    #############################
+    #export to a csv
+    def self.exportCSV
+      all_records = self.all
+      csv_class = nil
+      if RUBY_VERSION >= "1.9"
+        require 'csv'
+        csv_class = CSV
+      else
+        csv_class = FasterCSV
+      end
+      other_columns = {}
+      csv_string = csv_class.generate do |csv|
+          header_row = ["DATABASE ID",Rails.configuration.member_csv_metadata[:first_name],Rails.configuration.member_csv_metadata[:last_name], Rails.configuration.member_csv_metadata[:email], Rails.configuration.member_csv_metadata[:groups]]
+
+          index = 0
+          Rails.configuration.member_csv_metadata.each do |key , val|
+            if ![:first_name, :last_name , :email , :groups].include?(key)
+              other_columns[key] = index + 5
+              header_row << val
+              index += 1
+            end
+          end
+          csv << header_row
+
+          all_records.each do |record|
+            data_row = [record.id, record.first_name, record.last_name , record.email , record.groups_name("; ")]
+            other_columns.each do |key , val|
+              if !val.blank? && val >= 0
+                data_row[val] = record.send(key)
+              end
+            end
+            csv << data_row
+          end
+      end
+
+      csv_string
+    end
+
+
+  end
+end