gluttonberg-core 2.6.4 → 3.0.0

data/app/models/gluttonberg/asset_collection.rb

@@ -1,18 +1,71 @@
 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
+    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
+    
+    # Included mixins which are registered by host app for extending functionality
+    MixinManager.load_mixins(self)
+
+    # Find all images within collection
+    def images
+      data = assets.includes([:asset_type]).all
+      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)"
+    # this method is required for gallery form
+    def name_with_number_of_images
+      "#{name} (#{images.length} images)"
+    end
+
+    # if new collection is provided it will create the object for that
+    # then it will add new collection id into other existing collection ids
+    def self.process_new_collection_and_merge(params, current_user)
+      collection_ids = params[:asset][:asset_collection_ids]
+      if collection_ids.blank? || ["null", "undefined"].include?(collection_ids)
+        collection_ids = []
+      end
+      if collection_ids.kind_of?(String)
+        collection_ids = collection_ids.split(",")
       end
+      the_collection = find_or_create_asset_collection_from_hash(params[:new_collection], current_user)
+      unless the_collection.blank?
+        collection_ids <<  the_collection.id
+      end
+      params[:asset][:asset_collection_ids] = collection_ids
+    end
+
+    private
+      # Returns an AssetCollection (either by finding a matching existing one or creating a new one)
+      # requires a hash with the following keys
+      #   do_new_collection: If not present the method returns nil and does nothing
+      #   new_collection_name: The name for the collection to return.
+      def self.find_or_create_asset_collection_from_hash(param_hash, current_user)
+       # Create new AssetCollection if requested by the user
+       if param_hash
+           if param_hash.has_key?(:new_collection_name)
+             unless param_hash[:new_collection_name].blank?
+               #create options for first or create
+               options = {:name => param_hash[:new_collection_name] }
+
+               # Retireve the existing AssetCollection if it matches or create a new one
+               the_collection = AssetCollection.where(options).first
+               unless the_collection
+                 the_collection = AssetCollection.new(options)
+                 the_collection.user_id = current_user.id
+                 the_collection.save
+               end
+
+               the_collection
+             end # new_collection_name value
+           end # new_collection_name key
+         end # param_hash
+      end # find_or_create_asset_collection_from_hash
+
   end
 end

data/app/models/gluttonberg/asset_mime_type.rb

@@ -1,8 +1,13 @@
 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
+
+      # Included mixins which are registered by host app for extending functionality
+      MixinManager.load_mixins(self)
   end
 end

data/app/models/gluttonberg/asset_thumbnail.rb

@@ -1,7 +1,12 @@
 module Gluttonberg
   class AssetThumbnail  < ActiveRecord::Base
-    belongs_to :asset
     self.table_name = "gb_asset_thumbnails"
+
+    belongs_to :asset
+
     attr_accessible :thumbnail_type, :user_generated
+    
+    # Included mixins which are registered by host app for extending functionality
+    MixinManager.load_mixins(self)
   end
 end

data/app/models/gluttonberg/asset_type.rb

@@ -1,63 +1,74 @@
 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"
+    self.table_name = "gb_asset_types"
 
-      validates_uniqueness_of :name
-      validates_presence_of :name
-      attr_accessible :name, :asset_category_id, :asset_category
+    has_many    :assets , :class_name => "Asset", dependent: :nullify
+    has_many    :asset_mime_types , :class_name => "AssetMimeType", dependent: :nullify
+    belongs_to  :asset_category, :class_name => "AssetCategory"
 
-      # 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)
+    validates_uniqueness_of :name
+    validates_presence_of :name
+    
+    attr_accessible :name, :asset_category_id, :asset_category
+    
+    # Included mixins which are registered by host app for extending functionality
+    MixinManager.load_mixins(self)
 
-        mime_types = ::MIME::Types[mime_type]
+    # 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 = self.find_mime_type_string(mime_type, file_name)
+
+      # OK, we really have no idea what this is
+      if mime_types.blank?
+        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
+
+      self.gb_mime_type_object(file_mime_type, file_base_type)
+    end
 
+    def self.build_defaults
+      Library::build_default_asset_types
+    end
+
+    private
+      def self.find_mime_type_string(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
+        mime_types
+      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
+      def self.gb_mime_type_object(file_mime_type, file_base_type)
+        asset_mime_type = AssetMimeType.where(:mime_type => file_mime_type).first
+        if asset_mime_type.blank? then
+          asset_mime_type = AssetMimeType.where(:mime_type => file_base_type).first
+          if asset_mime_type.blank? 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
+            asset_mime_type = AssetMimeType.where(:mime_type => 'unknown').first
+            if asset_mime_type.blank? then
               # something went wrong, so just assign anything :-(
-              return AssetType.first
+              AssetType.first
             else
-              return asset_mime_type.asset_type
+              asset_mime_type.asset_type
             end
           else
-            return asset_mime_type.asset_type
+            asset_mime_type.asset_type
           end
         else
-          return asset_mime_type.asset_type
+          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

@@ -1,8 +1,12 @@
 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
+    self.table_name = "gb_audio_asset_attributes"
 
+    belongs_to :asset, :class_name => "Gluttonberg::Asset"
+    
+    attr_accessible :asset_id , :length , :title , :artist , :album, :tracknum , :genre
+    
+    # Included mixins which are registered by host app for extending functionality
+    MixinManager.load_mixins(self)
   end #class
 end   #module

data/app/models/gluttonberg/authorization.rb

@@ -0,0 +1,10 @@
+module Gluttonberg
+  class Authorization < ActiveRecord::Base
+    self.table_name = "gb_authorizations"
+
+    belongs_to :user
+    belongs_to :authorizable, :polymorphic => true
+    
+    attr_accessible :authorizable_type, :authorizable_id, :user_id, :allow
+  end
+end

data/app/models/gluttonberg/auto_save.rb

@@ -0,0 +1,32 @@
+module Gluttonberg
+  class AutoSave < ActiveRecord::Base
+    self.table_name = "gb_auto_save_versions"
+
+    belongs_to :auto_save_able, :polymorphic => true
+
+    attr_accessible :auto_save_able_id, :auto_save_able_type, :auto_save_able_id
+    attr_accessible :data
+
+    # Included mixins which are registered by host app for extending functionality
+    MixinManager.load_mixins(self)
+    
+    def self.param_name_for(class_name)
+      ActiveModel::Naming.param_key(class_name.constantize).to_sym
+    end
+
+    # Load given autosave version for given object. 
+    # Special cases are handled for Pages and articles
+    def self.load_version(object)
+      auto_save_obj = self.where({:auto_save_able_id => object.id, :auto_save_able_type => object.class.name}).first
+      unless auto_save_obj.blank?
+        hash = JSON.parse(auto_save_obj.data)
+        if object.class.name == "Gluttonberg::PageLocalization"
+          hash.delete('page')
+        elsif object.class.name == "Gluttonberg::Blog::ArticleLocalization"
+          hash.delete('article')
+        end
+        object.assign_attributes(hash)
+      end
+    end
+  end
+end

data/app/models/gluttonberg/collapsed_page.rb

@@ -0,0 +1,13 @@
+module Gluttonberg
+  class CollapsedPage < ActiveRecord::Base
+    self.table_name = "gb_collapsed_pages"
+
+    belongs_to :page, :class_name => "Gluttonberg::Page"
+    belongs_to :user
+    
+    attr_accessible :user_id, :page_id
+
+    # Included mixins which are registered by host app for extending functionality
+    MixinManager.load_mixins(self)
+  end
+end

data/app/models/gluttonberg/embed.rb

@@ -0,0 +1,13 @@
+module Gluttonberg
+  class Embed < ActiveRecord::Base
+    self.table_name = "gb_embeds"
+
+    attr_accessible :body, :shortcode, :title
+    
+    # Included mixins which are registered by host app for extending functionality
+    MixinManager.load_mixins(self)
+    def name
+      title
+    end
+  end
+end

data/app/models/gluttonberg/feed.rb

@@ -1,14 +1,23 @@
 module Gluttonberg
   class Feed < ActiveRecord::Base
+    self.table_name = "gb_feeds"
+
     belongs_to :user
     belongs_to :feedable, :polymorphic => true
-    self.table_name = "gb_feeds"
-    attr_accessible :user, :feedable_type, :feedable_id, :title, :action_type
+    
+    attr_accessible :user, :feedable, :feedable_type, :feedable_id, :title, :action_type
 
+    # Included mixins which are registered by host app for extending functionality
+    MixinManager.load_mixins(self)
+
+    # Create Feed entry for given object
+    #
+    # @param user [User] User who has done current action
+    # @param object [< ActiveRecord] Object which is created/modified/deleted
+    # @param title [String] User friendly Message for current action
+    # @param action_type [String] Action type e.g, created, updated, deleted
     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)
+      self.create(:user => user , :feedable => object, :title => title , :action_type => action_type)
     end
-
-
   end
 end

data/app/models/gluttonberg/gallery.rb

@@ -1,24 +1,50 @@
 module Gluttonberg
   class Gallery < ActiveRecord::Base
     self.table_name = "gb_galleries"
+
     include Content::SlugManagement
     include Content::Publishable
+    include ActionView::Helpers::TextHelper
 
-    attr_accessible :title, :slug, :description, :state, :published_at, :collection_imported
-    has_many :gallery_images , :order => "position ASC"
-    belongs_to :user
+    # Included mixins which are registered by host app for extending functionality
+    MixinManager.load_mixins(self)
 
-    def name
-      title
-    end
+    has_many :gallery_images , :order => "position ASC", :dependent => :destroy
+    belongs_to :fb_icon , :class_name => "Gluttonberg::Asset" , :foreign_key => "fb_icon_id"
+    belongs_to :user
 
-    def name=(new_name)
-      title = new_name
-    end
+    attr_accessible :title, :slug, :description, :state, :published_at, :collection_imported
+    attr_accessible :gallery_images, :gallery_images_attributes
+    accepts_nested_attributes_for :gallery_images, :allow_destroy => true
+    attr_accessible :seo_title, :seo_keywords, :seo_description, :fb_icon_id
+    
+    alias_attribute :name, :title
+    validates_presence_of :user_id
 
+    # Array of actual assets
     def images
       gallery_images.map{|i| i.image }
     end
 
+    # Attach all images of a collection to current gallery
+    def save_collection_images(params, current_user)
+      unless params[:collection_id].blank?
+        collection = AssetCollection.where(:id => params[:collection_id]).first
+        collection_images = collection.images
+        Gluttonberg::Feed.log(current_user,self, self.title , "add #{pluralize(collection_images.length , 'image')} from collection '#{collection.name}'")
+        max_position = self.gallery_images.length
+        collection_images.each_with_index do |image , index|
+          self.gallery_images.create({
+            :caption  => image.name,
+            :link     => image.link,
+            :credits  => image.artist_name,
+            :asset_id => image.id,
+            :position => (max_position + index)
+          })
+        end
+        self.update_attributes(:collection_imported => true)
+      end
+    end
+
   end
 end

data/app/models/gluttonberg/gallery_image.rb

@@ -1,9 +1,16 @@
 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"
+    belongs_to :asset  , :class_name => "Gluttonberg::Asset" , :foreign_key => "asset_id"
+
     is_drag_tree :scope => :gallery_id , :flat => true , :order => "position"
-    attr_accessible :asset_id, :position
+
+    attr_accessible :asset_id, :position, :caption, :credits, :link, :gallery_id
+    validates :asset_id, presence: true
+    
+    # Included mixins which are registered by host app for extending functionality
+    MixinManager.load_mixins(self)
   end
 end

data/app/models/gluttonberg/group.rb

@@ -1,15 +1,31 @@
 module Gluttonberg
+  # This model is used for grouping in membership system. 
+  # Members can be grouped, CMS pages can be grouped
   class Group < ActiveRecord::Base
-    is_drag_tree :flat => true , :order => "position"
     self.table_name = "gb_groups"
+
+    is_drag_tree :flat => true , :order => "position"
+    
     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
+    attr_accessible :name, :default, :position
+
+    # Included mixins which are registered by host app for extending functionality
+    MixinManager.load_mixins(self)
 
     def self.default_group
       self.where(:default =>  true).first
     end
 
+    # find group if not exists it makes new one
+    def self.ensure_exists(name)
+      cat = where(:name => name).first
+      if cat.blank?
+        cat = create(:name => name)
+      end
+      cat
+    end
+
   end
 end