gluttonberg-core 2.6.4 → 3.0.0

data/app/models/flag.rb

@@ -44,13 +44,13 @@ class Flag < ActiveRecord::Base
   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
+    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/asset.rb

@@ -1,204 +1,153 @@
 module Gluttonberg
+  # Asset Model stores meta information for assets and get most of its 
+  # file management functionality from AttachmentMixin
   class Asset < ActiveRecord::Base
-      self.table_name = "gb_assets"
-      has_many :set_elements, :as => :element
-      has_many :asset_thumbnails
+    self.table_name = "gb_assets"
 
-      #after_save  :update_file
-      before_validation  :set_category_and_type
+    # CleaningRequired I think is not used anymore it probably came from bigstores. 
+    has_many :set_elements, :as => :element
 
-      acts_as_taggable_on :locations , :characters , :themes, :photographers
+    # Custom user scaled/croppped thumbnails
+    has_many :asset_thumbnails
 
-      include Library::AttachmentMixin
-      asset_mixins = Rails.configuration.asset_mixins
-      unless asset_mixins.blank?
-        asset_mixins.each do |mixin|
-          include mixin
-        end
-      end
+    # Set asset meta information regarding asset type and category
+    before_validation  :set_category_and_type
 
-      has_and_belongs_to_many :asset_collections     , :join_table => "gb_asset_collections_assets"
-      belongs_to  :asset_type
-      has_one :audio_asset_attribute , :dependent => :destroy
+    # CleaningRequired I think is not used anymore it probably came from bigstores. 
+    acts_as_taggable_on :locations , :characters , :themes, :photographers
 
-      belongs_to :user
+    # Attachment mix manages most of storage, config and asset processing functionality
+    include Library::AttachmentMixin
 
-      attr_accessible :file, :name, :alt, :asset_collection_ids, :mime_type
-      attr_accessible :description, :synopsis, :copyrights, :year_of_production, :duration
-      attr_accessible :artist_name, :link, :width, :height, :alt , :processed, :copied_to_s3
+    # Included mixins which are registered by host app for extending functionality
+    MixinManager.load_mixins(self)
 
-      attr_accessor :type
+    has_and_belongs_to_many :asset_collections     , :join_table => "gb_asset_collections_assets"
+    belongs_to  :asset_type
+    has_one :audio_asset_attribute , :dependent => :destroy, :class_name => "Gluttonberg::AudioAssetAttribute", dependent: :destroy
 
-      # constants for formatted file size
-      GIGA_SIZE = 1073741824.0
-      MEGA_SIZE = 1048576.0
-      KILO_SIZE = 1024.0
+    # User who has created this asset
+    belongs_to :user
 
-      def alt_or_title
-        unless alt.blank?
-          alt
-        else
-          title
-        end
-      end
+    attr_accessible :file, :name, :alt, :asset_collection_ids, :asset_collections, :mime_type
+    attr_accessible :description, :synopsis, :copyrights, :year_of_production, :duration
+    attr_accessible :artist_name, :link, :width, :height, :alt , :processed, :copied_to_s3
+    attr_accessible :poster_image_id
 
-      # returns category of asset
-      def category
-        if asset_type.nil? then
-          Library::UNCATEGORISED_CATEGORY
-        else
-          asset_type.asset_category.name
-        end
-      end
+    # Poster image is only available for Video assets
+    # Once asset is created and its classified as Video then on edit form 
+    # user has option to upload another asset for poster image
+    belongs_to :poster_image , :foreign_key => "poster_image_id" , :class_name => "Gluttonberg::Asset"
 
-      def title
-        self.name
-      end
+    attr_accessor :type
 
-      def type_name
-        if asset_type.nil? then
-          Library::UNCATEGORISED_CATEGORY
-        else
-          asset_type.name
-        end
-      end
+    # constants for formatted file size
+    GIGA_SIZE = 1073741824.0
+    MEGA_SIZE = 1048576.0
+    KILO_SIZE = 1024.0
 
-      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 alt_or_title
+      alt.blank? ? title : alt
+    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
+    # returns category of asset
+    def category
+      if asset_type.blank? then
+        Library::UNCATEGORISED_CATEGORY
+      else
+        asset_type.asset_category.name
       end
+    end
 
-      def self.refresh_all_asset_types
-        all.each do |asset|
-          asset.auto_set_asset_type
-          asset.save
-        end
-      end
+    def title
+      self.name
+    end
 
-      def self.clear_all_asset_types
-        all.each do |asset|
-          asset.asset_type = nil
-          asset.save
-        end
+    def type_name
+      if asset_type.blank? then
+        Library::UNCATEGORISED_CATEGORY
+      else
+        asset_type.name
       end
+    end
 
-      # find out and set type and category of file
-      def set_category_and_type
-        unless file.nil?
-          auto_set_asset_type
+    def formatted_file_size
+      unless size.blank?
+        case
+          when size == 1 then "1 Byte"
+          when size < KILO_SIZE then "%d Bytes" % size
+          when size < MEGA_SIZE then "%.2f KB" % (size / KILO_SIZE)
+          when size < GIGA_SIZE then "%.2f MB" % (size / MEGA_SIZE)
+          else "%.2f GB" % (size / GIGA_SIZE)
         end
       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?
+    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 absolute_file_path_without_extension
-        Rails.root.to_s + "/public" + self.url.split(".").first unless self.file_name.blank?
+    # update asset type for all assets. Just for fixing purpose only
+    def self.refresh_all_asset_types
+      all.each do |asset|
+        asset.auto_set_asset_type
+        asset.save
       end
+    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
+    # find out and set type and category of file
+    def set_category_and_type
+      unless file.nil?
+        auto_set_asset_type
       end
+    end
 
+    def filename_without_extension
+      self.file_name.split(".").first unless self.file_name.blank?
+    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
+    # This is a helper method for rake task generate_asset_from_bulks_folder
+    # Make assets from files in bulks folder
+    # This is helpful to bootstrap server in case of large assets 
+    def self.create_assets_from_ftp(absolute_directory_path=nil)
+      collection = AssetCollection.first_or_create(:name => "BULKS")
+      absolute_directory_path = Rails.root+"/bulks" if absolute_directory_path.blank?
+      files = Dir.entries(absolute_directory_path)
+      assets = []
+      files.each do |entry|
+        unless AssetBulkImport.hidden_file?(entry)
+          file = GbFile.init(File.join(absolute_directory_path, entry))
+          asset_name_with_extention = entry.split(".").first
+          asset_params = {:name => asset_name_with_extention  , :file => file  }
+          assets << Asset.create(asset_params.merge({:asset_collection_ids => collection.id.to_s}))
         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
+      assets
     end
 
-    def self.find_content_type(filename)
-      begin
-       MIME::Types.type_for(filename).first.content_type
-      rescue
-        ""
-      end
+    def self.search_assets(query)
+      command = Gluttonberg.like_or_ilike
+      self.where(["name #{command} ? OR description #{command} ? ", "%#{query}%" , "%#{query}%" ] ).order("name ASC")
     end
 
-  end
-
+    def to_json_for_ajax_new
+      json = {
+        "asset_id" => self.id,
+        "title" => self.name,
+        "category" => self.category,
+        "url" => self.url
+      }
+      if self.category == "image"
+        json["url"] = self.thumb_small_url
+        json["jwysiwyg_image"] = self.url_for(:jwysiwyg_image)
+      end
+      json.to_json
+    end
+  end #Asset
 end

data/app/models/gluttonberg/asset_bulk_import.rb

@@ -0,0 +1,70 @@
+module Gluttonberg
+  class AssetBulkImport
+    # makes a new folder (name of the folder is current time stamp) inside tmp folder
+    # open zip folder
+    # iterate on opened zip folder and make assets for each entry using  make_asset_for_entry method
+    # removes directory which we made inside tmp folder
+    # also removes zip tmp file
+    def self.open_zip_file_and_make_assets(asset_params, current_user)
+      new_assets = []
+      zip = asset_params[:file]
+      dir = create_tmp_folder
+      begin
+        Zip::File.open(zip.tempfile.path).each do |entry|
+          asset = self.make_asset_for_entry(asset_params, current_user, entry , dir)
+          new_assets << asset if asset && asset.kind_of?(Gluttonberg::Asset)
+        end
+        zip.tempfile.close
+      rescue => e
+       Rails.logger.info e
+      end
+      FileUtils.rm_r(dir)
+      new_assets
+    end
+
+    # taskes zip_entry and dir path. makes assets if its valid then also add it to @new_assets list
+    # its responsible of extracting entry and its deleting it.
+    # it use file name for making asset.
+    def self.make_asset_for_entry(asset_params, current_user, entry , dir)
+      begin
+        unless self.hidden_file_or_directory?(entry)
+          entry_name = entry.name.gsub("/", "-")
+          filename = File.join(dir,entry_name)
+          entry.extract(filename)
+          file = GbFile.init(filename)
+          asset = prepare_asset(entry_name, file, current_user, asset_params)
+          file.close
+          FileUtils.remove_file(filename)
+          asset
+        end
+      rescue => e
+        Rails.logger.info e
+      end
+    end
+
+    private
+      def self.create_tmp_folder
+        dir = File.join(Rails.root,"tmp")
+        dir = File.join(dir,Time.now.to_i.to_s)
+        FileUtils.mkdir_p(dir)
+      end
+
+      def self.prepare_asset(entry_name, file, current_user, asset_params)
+        asset_name_with_extention = entry_name.split(".").first
+        asset_name_with_extention = asset_name_with_extention.humanize
+        asset_name_with_extention = asset_name_with_extention.gsub('-',' ')
+        asset = Asset.new(asset_params.merge( :name => asset_name_with_extention ,  :file => file ) )
+        asset.user_id = current_user.id
+        asset.save ? asset : nil
+      end
+
+      def self.hidden_file_or_directory?(entry)
+        self.hidden_file?(entry.name) || entry.directory?
+      end
+
+      def self.hidden_file?(file_name)
+        name = file_name.split("/").last
+        name.starts_with?(".") || name.starts_with?("__")
+      end
+  end #class
+end

data/app/models/gluttonberg/asset_category.rb

@@ -1,45 +1,91 @@
 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
+    self.table_name = "gb_asset_categories"
+    has_many :asset_types , :class_name => "AssetType", dependent: :nullify
+    has_many :assets, :through => :asset_types
 
-      validates_uniqueness_of :name
-      validates_presence_of :name
-      attr_accessible :name , :unknown
+    validates_uniqueness_of :name
+    validates_presence_of :name
+    attr_accessible :name , :unknown
+    # Included mixins which are registered by host app for extending functionality
+    MixinManager.load_mixins(self)
 
-      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
+    # Dynamic methods for categories.
+    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
+            cat = where(:name => cat_name).first
+            return cat unless cat.blank?
           end
         end
       end
+      raise NoMethodError
+    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
+    # Ensure the default categories exist in the database.
+    def self.build_defaults
+      ensure_exists('audio')
+      ensure_exists('image')
+      ensure_exists('video')
+      ensure_exists('document')
+      ensure_exists(Library::UNCATEGORISED_CATEGORY, true)
+    end
 
-      private
+    # Find assets for a category. It supports comma seperated categories
+    # It also works for 'all'
+    def self.find_assets_by_category(category_name)
+      if category_name == "all" || category_name.blank? then
+        # ignore asset category if user selects 'all' from category
+        Asset.includes(:asset_type)
+      else
+        req_categories = AssetCategory.where(:name => category_name.split(",")).all
+        # if category is not found then raise exception
+        if req_categories.blank?
+          raise ActiveRecord::RecordNotFound
+        else
+          asset_types = []
+          req_categories.each do |req_category|
+            asset_types << req_category.asset_types.all.collect{|type| type.id}
+          end
+          asset_types = asset_types.flatten unless asset_types.blank?
+          Asset.where(:asset_type_id => asset_types).includes(:asset_type)
+        end
+      end # category#all
+    end
 
-      def self.ensure_exists(name, unknown)
-        cat = find(:first , :conditions => "name = '#{name}'")
-        if cat then
-          cat.unknown = unknown
-          cat.save
+    # Find assets for a category within a collection. It supports comma seperated categories
+    # It also works for 'all'
+    def self.find_assets_by_category_and_collection(category_name, collection)
+      if category_name == "all" || category_name.blank? then
+        collection.assets
+      else
+        req_categories = AssetCategory.where(:name => category_name.split(",")).all
+        # if category is not found then raise exception
+        if req_categories.blank?
+          raise ActiveRecord::RecordNotFound
         else
-          cat = create(:name => name, :unknown => unknown)
+          asset_types = []
+          req_categories.each do |req_category|
+            asset_types << req_category.asset_types.all.collect{|type| type.id}
+          end
+          collection.assets.where({:asset_type_id => asset_types }) unless asset_types.blank?
         end
       end
+    end
+
+    # find category if not exists it makes new one
+    def self.ensure_exists(name, unknown=false)
+      cat = where(:name => name).first
+      if cat then
+        cat.unknown = unknown
+        cat.save
+      else
+        cat = create(:name => name, :unknown => unknown)
+      end
+    end
 
   end
 end