gluttonberg-core 2.5

data/app/mailer/member_notifier.rb

@@ -0,0 +1,51 @@
+class MemberNotifier < ActionMailer::Base
+  
+  default :from => "#{Gluttonberg::Setting.get_setting("title")} <#{Gluttonberg::Setting.get_setting("from_email")}>"
+  default_url_options[:host] = Rails.configuration.host_name 
+  
+  def password_reset_instructions(member_id ,  current_localization_slug = "")
+    member = Gluttonberg::Member.find(member_id)
+    setup_email
+    @subject += "Password Reset Instructions"
+    @recipients = member.email  
+    @edit_password_reset_url = edit_member_password_reset_url( current_localization_slug,  member.perishable_token)
+  end
+  
+  def confirmation_instructions(member_id ,  current_localization_slug = "")
+    member = Gluttonberg::Member.find(member_id)
+    setup_email
+    @subject += "Confirmation Instructions"
+    @recipients = member.email  
+    @member_confirmation_url = member_confirmation_url(:locale => current_localization_slug , :key => member.confirmation_key)
+  end
+  
+  # welcome email will be sent to member when admin user will create member. 
+  # this member will be automatically verified 
+  # purpose of this email is to provide login details to the member
+  def welcome(member_id, current_localization_slug = "")
+    @member = Gluttonberg::Member.find(member_id)
+    setup_email
+    @subject += "Confirmation Instructions"
+    @recipients = @member.email  
+    @password = Gluttonberg::Member.generateRandomString
+    password_hash = {  
+        :password => @password ,
+        :password_confirmation => @password
+    }
+    @member.welcome_email_sent = true
+    @member.assign_attributes(password_hash)
+    @member.save
+    @login_url = member_login_url
+  end
+  
+  
+  protected
+  
+    def setup_email
+      @from        = "#{Gluttonberg::Setting.get_setting("title")} <#{Gluttonberg::Setting.get_setting("from_email")}>"
+      @subject     = "[#{Gluttonberg::Setting.get_setting("title")}] "
+      @sent_on     = Time.now
+      @content_type = "text/html"
+    end
+    
+end

data/app/mailer/notifier.rb

@@ -0,0 +1,45 @@
+class Notifier < ActionMailer::Base
+  
+  default :from => "#{Gluttonberg::Setting.get_setting("title")} <#{Gluttonberg::Setting.get_setting("from_email")}>"
+  default_url_options[:host] = Rails.configuration.host_name 
+  
+  def password_reset_instructions(user_id)
+    user = User.find(user_id)
+    setup_email
+    @subject += "Password Reset Instructions"
+    @recipients = user.email  
+    @body[:edit_password_reset_url] = edit_admin_password_reset_url(user.perishable_token)
+  end
+  
+  def comment_notification(subscriber , article , comment)
+    @subscriber = subscriber
+    @article = article
+    @comment = comment
+    @website_title = Gluttonberg::Setting.get_setting("title")
+    @article_url = blog_article_url(article.blog.slug, article.slug)
+    @unsubscribe_url = unsubscribe_article_comments_url(@subscriber.reference_hash)
+    
+    mail(:to => @subscriber.author_email, :subject => "Re: [#{@website_title}] #{@article.title}")
+  end
+  
+  def comment_notification_for_admin(admin , article , comment)
+    @admin = admin
+    @article = article
+    @blog = @article.blog
+    @comment = comment
+    @website_title = Gluttonberg::Setting.get_setting("title")
+    @article_url = blog_article_url(:blog_id => article.blog.slug, :id => article.slug)
+    
+    mail(:to => @admin.email, :subject => "Re: [#{@website_title}] #{@article.title}")
+  end
+  
+  protected
+  
+    def setup_email
+      @from        = "#{Gluttonberg::Setting.get_setting("title")} <#{Gluttonberg::Setting.get_setting("from_email")}>"
+      @subject     = "[#{Gluttonberg::Setting.get_setting("title")}] "
+      @sent_on     = Time.now
+      @content_type = "text/html"
+    end
+    
+end

data/app/models/ability.rb

@@ -0,0 +1,46 @@
+class Ability
+  include CanCan::Ability
+  
+  # commented code is left for example for hostapps. In hostapp developer can override this class for custom authorization requirements
+  def initialize(user)
+    
+    user ||= User.new # guest user (not logged in)
+    if user.super_admin?
+      can :manage, :all
+    elsif user.admin?
+      can :manage, :all
+      restricted_features_for_admin
+    else
+      can :manage, :all
+      restricted_features_for_admin
+      
+      cannot :manage , User
+      cannot :manage , Gluttonberg::Setting
+      cannot :destroy , Gluttonberg::Asset
+      
+      #page roles
+      #cannot :manage , Gluttonberg::Page
+      cannot :change_home , Gluttonberg::Page
+      cannot :destroy , Gluttonberg::Page
+      cannot :publish , Gluttonberg::Page
+      cannot :reorder , Gluttonberg::Page
+      
+      #cannot :manage , Gluttonberg::Blog
+      cannot :publish , Gluttonberg::Blog
+      cannot :destroy , Gluttonberg::Blog
+      
+      #cannot :manage , Gluttonberg::Article
+      #cannot :publish , Gluttonberg::Article
+      #cannot :destroy , Gluttonberg::Article
+      
+      #cannot :manage , Gluttonberg::Comment
+      #cannot :moderate , Gluttonberg::Comment
+    end
+    
+  end
+  
+  def restricted_features_for_admin
+    cannot :manage , Gluttonberg::Locale
+    cannot :create_or_destroy , Gluttonberg::Setting
+  end
+end

data/app/models/flag.rb

@@ -0,0 +1,56 @@
+class Flag < ActiveRecord::Base
+  # serialize :flag, Symbol
+  belongs_to :flaggable, :polymorphic => true
+
+  # This will contain the names of all models that can_be_flagged
+  cattr_accessor :flaggable_models
+  attr_accessible :flaggable_type, :flaggable_id, :reason, :description, :url
+
+  # This line is dynamically generated when you call "can_flag" in your user/account model.
+  # It assumes that content is owned by the same class as flaggers.
+  # belongs_to :owner, :through => :flaggable, :class_name => ??
+
+  # This is set dynamically in the plugin.
+  # define "can_flag" in your user/account model.
+  # belongs_to :user
+
+  validates_presence_of :flaggable_id, :flaggable_type
+
+  # requires all your content to have a user_id.  if not, then
+  validates_presence_of :flaggable_user_id, :on => :create,
+    # :message => "error - your content must be owned by a user.",
+    :if => Proc.new { |c| c.flaggable and c.flaggable.user_id }
+
+  # A user can flag a specific flaggable with a specific flag once
+  validates_uniqueness_of :user_id, :scope => [:flaggable_id, :flaggable_type]
+
+  after_create :callback_flaggable
+  # Pings the 'after_flagged' callback in the content model, if it exists.
+  def callback_flaggable
+    flaggable.callback :after_flagged
+  end
+
+  before_validation :set_owner_id , :on => :create
+  def set_owner_id
+    self.flaggable_user_id = flaggable.user_id
+  end
+
+  validates_each :reason do |record,attr,value|
+    record.errors.add(attr, "don't include '#{value}' as an option") if value and !record.flaggable.reasons.include?(value.to_sym)
+  end
+
+  scope :all_approved, :conditions => { :approved => true }
+  scope :all_pending, :conditions => { :moderation_required => true }
+  scope :all_rejected, :conditions => { :approved => false , :moderation_required => false }
+
+  def moderate(params)
+      if params == "approve"
+        update_attributes(:moderation_required => false, :approved => true)
+      elsif params == "disapprove"
+        update_attributes(:moderation_required => false, :approved => false)
+      else
+        #error
+      end
+  end
+
+end

data/app/models/gluttonberg/article.rb

@@ -0,0 +1,73 @@
+module Gluttonberg
+  class Article < ActiveRecord::Base
+    self.table_name = "gb_articles"
+    include Content::SlugManagement
+    include Content::Publishable
+
+    belongs_to :blog
+    belongs_to :author, :class_name => "User"
+    belongs_to :user #created by
+    has_many :comments, :as => :commentable, :dependent => :destroy
+    has_many :localizations, :class_name => "Gluttonberg::ArticleLocalization" , :foreign_key => :article_id  , :dependent => :destroy
+
+    acts_as_taggable_on :article_category , :tag
+    attr_accessor :name
+    delegate :title , :body , :excerpt , :featured_image_id , :featured_image  , :to => :current_localization
+    attr_accessible :user_id, :blog_id, :author_id, :slug, :article_category_list, :tag_list, :disable_comments, :state, :published_at, :name
+
+    def commenting_disabled?
+      !disable_comments.blank? && disable_comments
+    end
+
+    def moderation_required
+      if self.blog.blank?
+        true
+      else
+        self.blog.moderation_required
+      end
+    end
+
+    def current_localization
+      if @current_localization.blank?
+        load_default_localizations
+      end
+      @current_localization
+    end
+
+    # Load the matching localization as specified in the options
+    def load_localization(locale = nil)
+      if locale.blank? || locale.id.blank?
+        @current_localization = load_default_localizations
+      else
+        @current_localization = localizations.where("locale_id = ?", locale.id).first
+      end
+      @current_localization
+    end
+
+    def load_default_localizations
+      @current_localization = localizations.where(:locale_id => Locale.first_default.id).first
+    end
+
+    def duplicate
+      ActiveRecord::Base.transaction do
+        duplicated_article = self.dup
+        duplicated_article.state = "draft"
+        duplicated_article.created_at = Time.now
+        duplicated_article.published_at = nil
+
+        if duplicated_article.save
+          self.localizations.each do |loc|
+            dup_loc = loc.dup
+            dup_loc.article_id = duplicated_article.id
+            dup_loc.created_at = Time.now
+            dup_loc.save
+          end
+          duplicated_article
+        else
+          nil
+        end
+      end
+    end
+
+  end
+end

data/app/models/gluttonberg/article_localization.rb

@@ -0,0 +1,21 @@
+module Gluttonberg
+  class ArticleLocalization < ActiveRecord::Base
+    self.table_name = "gb_article_localizations"
+    belongs_to :article  , :class_name => "Gluttonberg::Article"
+    belongs_to :locale
+
+    belongs_to :fb_icon , :class_name => "Gluttonberg::Asset" , :foreign_key => "fb_icon_id"
+    belongs_to :featured_image , :foreign_key => :featured_image_id , :class_name => "Gluttonberg::Asset"
+
+    is_versioned :non_versioned_columns => ['state' , 'disable_comments' , 'published_at' , 'article_id' , 'locale_id']
+
+    validates_presence_of :title
+    attr_accessible :article, :locale_id, :title, :featured_image_id, :excerpt, :body, :seo_title, :seo_keywords, :seo_description, :fb_icon_id, :article_id
+
+    clean_html [:excerpt , :body]
+
+    def name
+      title
+    end
+  end
+end

data/app/models/gluttonberg/asset.rb

@@ -0,0 +1,194 @@
+module Gluttonberg
+  class Asset < ActiveRecord::Base
+      self.table_name = "gb_assets"
+      has_many :set_elements, :as => :element
+      has_many :asset_thumbnails
+
+      after_save  :update_file
+      before_validation  :set_category_and_type
+
+      acts_as_taggable_on :locations , :characters , :themes, :photographers
+
+      include Library::AttachmentMixin
+
+      has_and_belongs_to_many :asset_collections     , :join_table => "gb_asset_collections_assets"
+      belongs_to  :asset_type
+      has_one :audio_asset_attribute , :dependent => :destroy
+
+      belongs_to :user
+
+      attr_accessible :file, :name, :alt, :asset_collection_ids, :mime_type, :description, :synopsis, :copyrights, :year_of_production, :duration, :width, :height, :alt , :processed, :copied_to_s3
+
+      # constants for formatted file size
+      GIGA_SIZE = 1073741824.0
+      MEGA_SIZE = 1048576.0
+      KILO_SIZE = 1024.0
+
+      def alt_or_title
+        unless alt.blank?
+          alt
+        else
+          title
+        end
+      end
+
+      # returns category of asset
+      def category
+        if asset_type.nil? then
+          Library::UNCATEGORISED_CATEGORY
+        else
+          asset_type.asset_category.name
+        end
+      end
+
+      def title
+        self.name
+      end
+
+      def type_name
+        if asset_type.nil? then
+          Library::UNCATEGORISED_CATEGORY
+        else
+          asset_type.name
+        end
+      end
+
+      def formatted_file_size
+        precision = 2
+        unless size.blank?
+          case
+                when size == 1 then "1 Byte"
+                when size < KILO_SIZE then "%d Bytes" % size
+                when size < MEGA_SIZE then "%.#{precision}f KB" % (size / KILO_SIZE)
+                when size < GIGA_SIZE then "%.#{precision}f MB" % (size / MEGA_SIZE)
+                else "%.#{precision}f GB" % (size / GIGA_SIZE)
+          end
+        end
+      end
+
+      def auto_set_asset_type
+        self.asset_type = AssetType.for_file(mime_type, file_name)
+        cat = self.category.to_s.downcase
+        if cat == "image"
+          self[:type]  = "Photo"
+        elsif cat == "video"
+          self[:type]  = "Video"
+        end
+      end
+
+      def self.refresh_all_asset_types
+        all.each do |asset|
+          asset.auto_set_asset_type
+          asset.save
+        end
+      end
+
+      def self.clear_all_asset_types
+        all.each do |asset|
+          asset.asset_type = nil
+          asset.save
+        end
+      end
+
+      # find out and set type and category of file
+      def set_category_and_type
+        unless file.nil?
+          auto_set_asset_type
+        end
+      end
+
+      def absolute_file_path
+        Rails.root.to_s + "/public" + self.url.to_s
+      end
+
+      def filename_without_extension
+        self.file_name.split(".").first unless self.file_name.blank?
+      end
+
+      def absolute_file_path_without_extension
+        Rails.root.to_s + "/public" + self.url.split(".").first unless self.file_name.blank?
+      end
+
+      def self.create_assets_from_ftp
+
+        collection = AssetCollection.find_by_name("BULKS")
+
+        files = Dir.entries(Rails.root+"/bulks")
+        files.each do |entry|
+          unless entry.starts_with?(".") || entry.starts_with?("__")
+            file = MyFile2.init(entry)
+            asset_name_with_extention = entry.split(".").first
+
+            asset_params = {:name => asset_name_with_extention  , :file => file  }
+            @asset = Asset.create(asset_params.merge({:asset_collection_ids => collection.id.to_s}))
+          end
+        end
+      end
+
+
+
+      def copy_audios_to_s3
+        puts "--------copy_audios_to_s3"
+        key_id = Gluttonberg::Setting.get_setting("s3_key_id")
+        key_val = Gluttonberg::Setting.get_setting("s3_access_key")
+        s3_server_url = Gluttonberg::Setting.get_setting("s3_server_url")
+        s3_bucket = Gluttonberg::Setting.get_setting("s3_bucket")
+        if !key_id.blank? && !key_val.blank? && !s3_server_url.blank? && !s3_bucket.blank?
+          s3 = Aws::S3.new(key_id, key_val, {:server => s3_server_url})
+          bucket = s3.bucket(s3_bucket)
+          begin
+            local_file = Pathname.new(location_on_disk)
+            base_name = File.basename(local_file)
+            folder = self.asset_hash
+            date = Time.now+1.years
+            puts "Copying #{base_name} to #{s3_bucket}"
+            key = bucket.key("user_assets/" + folder + "/" + base_name, true)
+            key.put(File.open(local_file), 'public-read', {"Expires" => date.rfc2822, "content-type" => "audio/mp3"})
+            self.update_attributes(:copied_to_s3 => true)
+            puts "Copied"
+          rescue => e
+            puts "#{base_name} failed to copy"
+            puts "** #{e} **"
+          end
+        end
+      end
+
+
+      private
+
+      # make a new asset folder if not exist. then make backup of asset. generate thumbnails
+      def update_file
+        update_file_on_disk
+      end
+
+
+  end
+
+
+
+  # i made this class for providing extra methods in file class.
+  # I am using it for making assets from zip folder.
+  # keep in mind when we upload asset from browser, browser injects three extra attributes (that are given in MyFile class)
+  # but we are adding assets from file, i am injecting extra attributes manually. because asset library assumes that file has three extra attributes
+  class MyFile2 < File
+    attr_accessor :original_filename , :content_type , :size
+
+    def self.init(filename)
+      file = MyFile2.new(Rails.root+"/bulks/" + filename)
+      file.original_filename = filename
+      file.content_type = find_content_type(filename)
+      file.size = File.size(Rails.root+"/bulks/" + filename)
+      file
+    end
+
+    def self.find_content_type(filename)
+      begin
+       MIME::Types.type_for(filename).first.content_type
+      rescue
+        ""
+      end
+    end
+
+  end
+
+end

data/app/models/gluttonberg/asset_category.rb

@@ -0,0 +1,45 @@
+module Gluttonberg
+  class AssetCategory < ActiveRecord::Base
+      self.table_name = "gb_asset_categories"
+      has_many :asset_types , :class_name => "AssetType"
+      has_many :assets, :through => :asset_types
+
+      validates_uniqueness_of :name
+      validates_presence_of :name
+      attr_accessible :name , :unknown
+
+      def self.method_missing(methId, *args)
+        method_info = methId.id2name.split('_')
+        if method_info.length == 2 then
+          if method_info[1] == 'category' then
+            cat_name = method_info[0]
+            if cat_name then
+              return find(:first , :conditions => "name = '#{cat_name}'")
+            end
+          end
+        end
+      end
+
+      def self.build_defaults
+        # Ensure the default categories exist in the database.
+        ensure_exists('audio', false)
+        ensure_exists('image', false)
+        ensure_exists('video', false)
+        ensure_exists('document', false)
+        ensure_exists(Library::UNCATEGORISED_CATEGORY, true)
+      end
+
+      private
+
+      def self.ensure_exists(name, unknown)
+        cat = find(:first , :conditions => "name = '#{name}'")
+        if cat then
+          cat.unknown = unknown
+          cat.save
+        else
+          cat = create(:name => name, :unknown => unknown)
+        end
+      end
+
+  end
+end

data/app/models/gluttonberg/asset_collection.rb

@@ -0,0 +1,18 @@
+module Gluttonberg
+  class AssetCollection < ActiveRecord::Base
+      self.table_name = "gb_asset_collections"
+      has_and_belongs_to_many :assets, :class_name => "Asset" , :join_table => "gb_asset_collections_assets"
+      validates_uniqueness_of :name
+      validates_presence_of :name
+      attr_accessible :name
+      def images
+        data = assets.find(:all , :include => :asset_type )
+        data.find_all{|d| d.category == "image"}
+      end
+
+      # this method is required for gallery form
+      def name_with_number_of_images
+        "#{name} (#{images.length} images)"
+      end
+  end
+end

data/app/models/gluttonberg/asset_mime_type.rb

@@ -0,0 +1,8 @@
+module Gluttonberg
+  class AssetMimeType < ActiveRecord::Base
+      self.table_name = "gb_asset_mime_types"
+      belongs_to :asset_type, :class_name => "AssetType"
+      validates_uniqueness_of :mime_type
+      attr_accessible :mime_type, :asset_type_id
+  end
+end

data/app/models/gluttonberg/asset_thumbnail.rb

@@ -0,0 +1,7 @@
+module Gluttonberg
+  class AssetThumbnail  < ActiveRecord::Base
+    belongs_to :asset
+    self.table_name = "gb_asset_thumbnails"
+    attr_accessible :thumbnail_type, :user_generated
+  end
+end

data/app/models/gluttonberg/asset_type.rb

@@ -0,0 +1,63 @@
+module Gluttonberg
+    #require 'action_controller/mime_types'
+  require 'mime/types'
+  class AssetType < ActiveRecord::Base
+      self.table_name = "gb_asset_types"
+      has_many    :assets , :class_name => "Asset"
+      has_many    :asset_mime_types , :class_name => "AssetMimeType"
+      belongs_to  :asset_category, :class_name => "AssetCategory"
+
+      validates_uniqueness_of :name
+      validates_presence_of :name
+      attr_accessible :name, :asset_category_id, :asset_category
+
+      # Take the reported mime-type and the file_name and return
+      # the best AssetType to use for that file.
+      def self.for_file(mime_type, file_name)
+
+        mime_types = ::MIME::Types[mime_type]
+
+
+        # if the supplied mime_type isn't recognised as aregistered or common one,
+        # try and work out a suitable one from the file extension
+        if mime_types.blank?
+          mime_types = ::MIME::Types.type_for(file_name)
+        end
+
+        # OK, we really have no idea what this is
+        if mime_types.empty?
+          file_mime_type = mime_type
+          file_base_type = mime_type.split('/').first
+        else
+          # multiple mime-types may be returned, but we only want to work with
+          # one, so pick the first one
+          file_mime_type = mime_types.first.content_type
+          file_base_type = mime_types.first.raw_media_type
+        end
+
+        asset_mime_type = AssetMimeType.find(:first, :conditions => "mime_type = '#{file_mime_type}'")
+
+        if asset_mime_type.nil? then
+          asset_mime_type = AssetMimeType.find(:first, :conditions => "mime_type = '#{file_base_type}'")
+          if asset_mime_type.nil? then
+            # this is a completely unknown type, so default to unkown
+            asset_mime_type = AssetMimeType.find( :first, :conditions => "mime_type = 'unknown'")
+            if asset_mime_type.nil? then
+              # something went wrong, so just assign anything :-(
+              return AssetType.first
+            else
+              return asset_mime_type.asset_type
+            end
+          else
+            return asset_mime_type.asset_type
+          end
+        else
+          return asset_mime_type.asset_type
+        end
+      end
+
+      def self.build_defaults
+        Library::build_default_asset_types
+      end
+  end
+end

data/app/models/gluttonberg/audio_asset_attribute.rb

@@ -0,0 +1,8 @@
+module Gluttonberg
+  class AudioAssetAttribute < ActiveRecord::Base
+      belongs_to :asset
+      self.table_name = "gb_audio_asset_attributes"
+      attr_accessible :asset_id , :length , :title , :artist , :album, :tracknum , :genre
+
+  end #class
+end   #module

data/app/models/gluttonberg/blog.rb

@@ -0,0 +1,19 @@
+module Gluttonberg
+  class Blog < ActiveRecord::Base
+    self.table_name = "gb_blogs"
+    include Content::Publishable
+    include Content::SlugManagement
+
+    belongs_to :user
+    has_many :articles, :dependent => :destroy
+
+    validates_presence_of :name
+
+    is_versioned :non_versioned_columns => ['state' ,'published_at' , 'moderation_required' ]
+
+    acts_as_taggable_on :tag
+    clean_html [:description]
+    attr_accessible :user_id, :name, :slug, :description, :moderation_required, :seo_title, :seo_keywords, :seo_description, :fb_icon_id, :state, :published_at
+
+  end
+end