effective_assets 0.1 → 1.0.0

data/app/models/effective/access_denied.rb

@@ -0,0 +1,17 @@
+unless defined?(Effective::AccessDenied)
+  module Effective
+    class AccessDenied < StandardError
+      attr_reader :action, :subject
+
+      def initialize(message = nil, action = nil, subject = nil)
+        @message = message
+        @action = action
+        @subject = subject
+      end
+
+      def to_s
+        @message || I18n.t(:'unauthorized.default', :default => 'Access Denied')
+      end
+    end
+  end
+end

data/app/models/effective/asset.rb

@@ -21,12 +21,16 @@ module Effective
 
     structure do
       title           :string
+
       description     :text
       tags            :string
+      extra           :text
 
       content_type    :string, :validates => [:presence]
-      upload_file     :string    # The full url of the file, as originally uploaded
+      upload_file     :string, :validates => [:presence]    # The full url of the file, as originally uploaded
+
       processed       :boolean, :default => false
+      aws_acl         :string, :default => 'public-read', :validates => [:presence, :inclusion => {:in => ['public-read', 'authenticated-read']}]
 
       data            :string
 
@@ -40,26 +44,29 @@ module Effective
     end
 
     serialize :versions_info, Hash
+    serialize :extra, Hash
 
-    #attr_accessible :title, :description, :tags, :content_type, :data_size, :upload_file, :user, :user_id, :id
-    #validates_presence_of :user_id
-
+    before_validation :set_content_type
     before_save :update_asset_dimensions
+    after_save :enqueue_delayed_job
 
-    default_scope order('created_at DESC')
+    default_scope -> { order(:id) }
+    scope :nonplaceholder, -> { where("#{EffectiveAssets.assets_table_name}.upload_file != ?", 'placeholder') }
 
-    scope :images, -> { where('content_type LIKE ?', '%image%') }
-    scope :videos, -> { where('content_type LIKE ?', '%video%') }
-    scope :audio, -> { where('content_type LIKE ?', '%audio%') }
-    scope :files, -> { where('(content_type NOT LIKE ?) AND (content_type NOT LIKE ?) AND (content_type NOT LIKE ?)', '%image%', '%video%', '%audio%') }
+    scope :images, -> { nonplaceholder().where("#{EffectiveAssets.assets_table_name}.content_type LIKE ?", '%image%') }
+    scope :nonimages, -> { nonplaceholder().where("(#{EffectiveAssets.assets_table_name}.content_type NOT LIKE ?)", '%image%') }
 
-    scope :today, -> { where("created_at >= ?", Date.today.beginning_of_day) }
-    scope :this_week, -> { where("created_at >= ?", Date.today.beginning_of_week) }
-    scope :this_month, -> { where("created_at >= ?", Date.today.beginning_of_month) }
+    scope :videos, -> { nonplaceholder().where("#{EffectiveAssets.assets_table_name}.content_type LIKE ?", '%video%') }
+    scope :audio, -> { nonplaceholder().where("#{EffectiveAssets.assets_table_name}.content_type LIKE ?", '%audio%') }
+    scope :files, -> { nonplaceholder().where("(#{EffectiveAssets.assets_table_name}.content_type NOT LIKE ?) AND (#{EffectiveAssets.assets_table_name}.content_type NOT LIKE ?) AND (#{EffectiveAssets.assets_table_name}.content_type NOT LIKE ?)", '%image%', '%video%', '%audio%') }
+
+    scope :today, -> { nonplaceholder().where("#{EffectiveAssets.assets_table_name}.created_at >= ?", Time.zone.today.beginning_of_day) }
+    scope :this_week, -> { nonplaceholder().where("#{EffectiveAssets.assets_table_name}.created_at >= ?", Time.zone.today.beginning_of_week) }
+    scope :this_month, -> { nonplaceholder().where("#{EffectiveAssets.assets_table_name}.created_at >= ?", Time.zone.today.beginning_of_month) }
 
     class << self
       def s3_base_path
-        "http://#{EffectiveAssets.aws_bucket}.s3.amazonaws.com"
+        "https://#{EffectiveAssets.aws_bucket}.s3.amazonaws.com/"
       end
 
       def string_base_path
@@ -68,49 +75,22 @@ module Effective
 
       # Just call me with Asset.create_from_url('http://somewhere.com/somthing.jpg')
       def create_from_url(url, options = {})
-        opts = {:upload_file => url, :user_id => 1}.merge(options)
-
-        if (asset = Asset.create(opts))
-          Effective::DelayedJob.new.process_asset(asset)
-          asset
-        else
-          false
-        end
-      end
-
-      # We have just uploaded an asset via our s3 uploader
-      # We want this image to be immediately available.
-      def create_from_s3_uploader(url, options = {})
-        opts = {:upload_file => "#{Asset.s3_base_path}/#{url}", :user_id => 1}.merge(options)
-
-        asset = false
+        opts = {:upload_file => url, :user_id => 1, :aws_acl => EffectiveAssets.aws_acl}.merge(options)
 
-        Asset.transaction do
-          begin
-            asset = Asset.create!(opts)
-
-            Rails.logger.info "Copying s3 uploaded file to final resting place..."
-            storage = Fog::Storage.new(:provider => 'AWS', :aws_access_key_id => EffectiveAssets.aws_access_key_id, :aws_secret_access_key => EffectiveAssets.aws_secret_access_key)
-            storage.copy_object(EffectiveAssets.aws_bucket, url, EffectiveAssets.aws_bucket, "#{EffectiveAssets.aws_final_path.chomp('/')}/#{asset.id}/#{asset.file_name}")
-            storage.put_object_acl(EffectiveAssets.aws_bucket, "#{EffectiveAssets.aws_final_path.chomp('/')}/#{asset.id}/#{asset.file_name}", EffectiveAssets.aws_acl)
-
-            Rails.logger.info "Deleting original..."
-            directory = storage.directories.get(EffectiveAssets.aws_bucket)
-            directory.files.new(:key => url).destroy
-
-            asset.update_column(:upload_file, asset.url) # This is our upload file as far as CarrierWave is now concerned
-
-            Effective::DelayedJob.new.process_asset(asset)
-          rescue => e
-            Rails.logger.info e.message
-            Rails.logger.info e.backtrace.join('\n')
-            asset = false
+        attempts = 3  # Try to upload this string file 3 times
+        begin
+          asset = Asset.new(opts)
+
+          if asset.save
+            asset
+          else
+            puts asset.errors.inspect
+            Rails.logger.info asset.errors.inspect
+            false
           end
-
-          raise ActiveRecord::Rollback unless asset
+        rescue => e
+          (attempts -= 1) >= 0 ? (sleep 2; retry) : false
         end
-
-        asset
       end
 
       # This loads the raw contents of a string into a file and uploads that file to s3
@@ -119,50 +99,56 @@ module Effective
       def create_from_string(str, options = {})
         filename = options.delete(:filename) || "file-#{Time.now.strftime('%Y-%m-%d-%H-%M-%S')}.txt"
 
-        opts = {:upload_file => "#{Asset.string_base_path}#{filename}", :user_id => 1}.merge(options)
+        filename = URI.escape(filename).gsub(/%\d\d|[^a-zA-Z0-9.-]/, '_')  # Replace anything not A-Z, a-z, 0-9, . -
 
-        asset = Asset.new(opts)
-        asset.data = AssetStringIO.new(filename, str)
+        opts = {:upload_file => "#{Asset.string_base_path}#{filename}", :user_id => 1, :aws_acl => EffectiveAssets.aws_acl}.merge(options)
 
-        if asset.save
-          Effective::DelayedJob.new.process_asset(asset)
-          asset
+        attempts = 3  # Try to upload this string file 3 times
+        begin
+          asset = Asset.new(opts)
+          asset.data = AssetStringIO.new(filename, str)
+
+          if asset.save
+            asset
+          else
+            puts asset.errors.inspect
+            Rails.logger.info asset.errors.inspect
+            false
+          end
+        rescue => e
+          (attempts -= 1) >= 0 ? (sleep 2; retry) : false
         end
+
       end
+    end # End of Class methods
+
+    def title
+      self[:title].presence || file_name
     end
 
-    before_validation do
-      if !content_type.present? or content_type == 'null' or content_type == 'unknown' or content_type == 'application/octet-stream'
-        self.content_type = case url.to_s[-4, 4].downcase
-          when '.mp3' ; 'audio/mp3'
-          when '.mp4' ; 'video/mp4'
-          when '.mov' ; 'video/mov'
-          when '.m2v' ; 'video/m2v'
-          when '.m4v' ; 'video/m4v'
-          when '.3gp' ; 'video/3gp'
-          when '.3g2' ; 'video/3g2'
-          when '.avi' ; 'video/avi'
-          when '.jpg' ; 'image/jpg'
-          when '.gif' ; 'image/gif'
-          when '.png' ; 'image/png'
-          when '.bmp' ; 'image/bmp'
-          when '.ico' ; 'image/x-icon'
-          else ; 'unknown'
-        end
-      end
+    def extra
+      self[:extra] || {}
     end
 
-    def title
-      self[:title].present? ? self[:title] : file_name
+    def url(version = nil, expire_in = nil)
+      aws_acl == 'authenticated-read' ? authenticated_url(version, expire_in) : public_url(version)
     end
 
-    # Return the final location of this asset
-    def url
-      "#{Asset.s3_base_path}/#{EffectiveAssets.aws_final_path.chomp('/')}/#{self.id.to_i}/#{upload_file.to_s.split('/').last}"
+    def public_url(version = nil)
+      if data.present?
+        version.present? ? data.send(version).file.url : data.file.url
+      else
+       "#{Asset.s3_base_path.chomp('/')}/#{EffectiveAssets.aws_path.chomp('/')}/#{id.to_i}/#{file_name}"
+      end
+    end
+
+    def authenticated_url(version = nil, expire_in = 60.minutes)
+      data.fog_authenticated_url_expiration = expire_in
+      version.present? ? data.send(version).file.authenticated_url : data.file.authenticated_url
     end
 
     def file_name
-      url.split('/').last rescue url
+      upload_file.to_s.split('/').last rescue upload_file
     end
 
     def video?
@@ -181,22 +167,66 @@ module Effective
       content_type.include? 'audio'
     end
 
-    def as_json(options={})
-      {:thumbnail => image_tag(:thumb).html_safe}.merge super
+    def versions_info
+      self[:versions_info] || {}
     end
 
-    def still_processing?
-      !processed
+    def to_s
+      title
     end
 
-    def versions_info
-      self[:versions_info] || {}
+    def reprocess!
+      begin
+        Rails.logger.info "Reprocessing ##{id}..."
+        print "Reprocessing ##{id}..."
+
+        raise 'must be processed first before reprocessed' unless processed?
+
+        data.cache_stored_file!
+        data.retrieve_from_cache!(data.cache_name)
+        data.recreate_versions!
+        save!
+
+        Rails.logger.info "Successfully reprocessed ##{id}"
+        print "success"; puts ''
+        true
+      rescue => e
+        Rails.logger.info  "Error: #{id} -> #{e.to_s}"
+        print "error: #{e.to_s}"; puts ''
+        false
+      end
     end
 
     protected
-     # Called in the DelayedJob
-     def update_asset_dimensions
-      if data.present? and data_changed? and image?
+
+    def set_content_type
+      if [nil, 'null', 'unknown', 'application/octet-stream', ''].include?(content_type)
+        self.content_type = case File.extname(file_name).downcase.gsub(/\?.+/, '')
+          when '.mp3' ; 'audio/mp3'
+          when '.mp4' ; 'video/mp4'
+          when '.mov' ; 'video/mov'
+          when '.m2v' ; 'video/m2v'
+          when '.m4v' ; 'video/m4v'
+          when '.3gp' ; 'video/3gp'
+          when '.3g2' ; 'video/3g2'
+          when '.avi' ; 'video/avi'
+          when '.jpg' ; 'image/jpg'
+          when '.gif' ; 'image/gif'
+          when '.png' ; 'image/png'
+          when '.bmp' ; 'image/bmp'
+          when '.ico' ; 'image/x-icon'
+          when '.txt' ; 'text/plain'
+          when '.doc' ; 'application/msword'
+          when '.docx' ; 'application/msword'
+          when '.xls' ; 'application/excel'
+          when '.xlsx' ; 'application/excel'
+          else ; 'unknown'
+        end
+      end
+    end
+
+    def update_asset_dimensions
+      if data.present? && data_changed? && image?
         begin
           image = MiniMagick::Image.open(self.data.path)
           self.width = image[:width]
@@ -206,6 +236,13 @@ module Effective
       end
       true
     end
+
+    def enqueue_delayed_job
+      if !self.processed && self.upload_file.present? && self.upload_file != 'placeholder'
+        Effective::DelayedJob.new.process_asset(self.id)
+      end
+    end
+
   end
 
   class AssetStringIO < StringIO

data/app/models/effective/attachment.rb

@@ -12,14 +12,9 @@ module Effective
       box             :string, :default => 'assets', :validates => [:presence]  # This is essentially a category
     end
 
-    validates_presence_of :asset_id
+    default_scope -> { includes(:asset).order("\"#{EffectiveAssets.attachments_table_name.to_s}\".\"position\" ASC, \"#{EffectiveAssets.attachments_table_name.to_s}\".\"asset_id\" ASC") }
 
-    #attr_accessible :box, :position, :asset_id, :attachable_type, :attachable_id
+    validates_presence_of :asset_id
 
-    class << self
-      def default_scope
-        includes(:asset).order(:position)
-      end
-    end
   end
 end

data/app/models/effective/delayed_job.rb

@@ -4,96 +4,51 @@
 
 module Effective
   class DelayedJob
-    def process_asset(asset)
-      DelayedJob.configure_carrierwave
-
-      if asset and !asset.processed? and asset.upload_file.present?
-        begin
-          puts "Processing an asset ID ##{asset.id}..."
-
-          if asset.upload_file.include?("#{Asset.s3_base_path}")
-            if asset.image?
-              puts "Asset is an image in our S3 assets directory.  Downloading and processing..."
-
-              # Carrierwave must download the file, process it, then re-upload it to S3
-              asset.remote_data_url = asset.upload_file
-              asset.processed = true
-              asset.save!
-            else
-              puts "Asset is a non-image in our S3 uploads directory.  Copying to final location..."
-
-              # We have uploaded a video, or something non-image to our S3 bucket.
-              # We do not currently process anything.
-
-              puts "Marking local asset as processed..."
-              asset.update_column(:data, asset.file_name)
-              asset.processed = true
-              asset.save!
-            end
-          elsif asset.upload_file.include?(Asset.string_base_path)
-            puts "Asset is a string-based asset.  Processing..."
-
-            asset.data.cache_stored_file!
-            asset.data.retrieve_from_cache!(asset.data.cache_name)
-            asset.data.recreate_versions!
-            asset.processed = true
-            asset.save!
-          else
-            puts "Asset is not an s3 uploaded asset.  Downloading and processing..."
-
-            # Carrierwave must download the file, process it, then re-upload it to S3
-            asset.remote_data_url = asset.upload_file
-            asset.processed = true
-            asset.save!
-          end
-
-          puts "Successfully processed the asset."
-        rescue => e
-          puts "An error occurred while processing an asset:"
-          puts e.message
-          puts e.backtrace.inspect
-        end
+    def process_asset(obj)
+      if obj.kind_of?(Effective::Asset)
+        asset = obj
+      else
+        asset = Effective::Asset.where(:id => (obj.to_i rescue 0)).first
       end
-    end
-    handle_asynchronously :process_asset
 
-    def reprocess_all_assets
-      DelayedJob.configure_carrierwave
+      if asset.present? && !asset.processed? && asset.upload_file.present? && asset.upload_file != 'placeholder'
+        puts "Processing asset ##{asset.id} from #{asset.upload_file}."
+
+        if asset.upload_file.include?(Effective::Asset.string_base_path)
+          puts "String-based Asset processing and uploading..."
 
-      Asset.all.each do |asset|
-        begin
-          puts "Processing Asset ID=#{asset.id}..."
           asset.data.cache_stored_file!
           asset.data.retrieve_from_cache!(asset.data.cache_name)
           asset.data.recreate_versions!
-          asset.save!
-          puts "Successfully processed #{asset.inspect}"
-        rescue => e
-          puts  "ERROR: #{asset.id} -> #{e.to_s}"
+        elsif asset.upload_file.include?(Effective::Asset.s3_base_path)
+          puts "S3 Uploaded Asset downloading and processing..."
+          # Carrierwave must download the file, process it, then upload the generated versions to S3
+          # We only want to process if it's an image, so we don't download zips or videos
+          asset.remote_data_url = asset.url if asset.image?
+        else
+          puts "Non S3 Asset downloading and processing..."
+          puts "Downloading #{asset.url}"
+
+          # Carrierwave must download the file, process it, then upload it and generated verions to S3
+          # We only want to process if it's an image, so we don't download zips or videos
+          asset.remote_data_url = asset.upload_file
         end
-      end
-    end
-    handle_asynchronously :reprocess_all_assets
 
-    def self.configure_carrierwave
-      return if defined? @@configured_carrierwave
+        asset.processed = true
+        asset.save!
 
-      CarrierWave.configure do |config|
-        config.fog_credentials = {
-          :provider               => 'AWS',
-          :aws_access_key_id      => EffectiveAssets.aws_access_key_id,
-          :aws_secret_access_key  => EffectiveAssets.aws_secret_access_key
-        }
-        config.fog_directory  = EffectiveAssets.aws_bucket
-        config.fog_public     = EffectiveAssets.aws_acl.to_s.include?('public')
-        config.fog_attributes = {'Cache-Control'=>'max-age=315576000'}
-        config.cache_dir      = "#{Rails.root}/tmp/uploads" # For heroku
-      end
+        (GC.start rescue nil)
 
-      Rails.logger.info "CONFIGURED CARRIERWAVE"
+        puts "Successfully processed the asset."
+      end
+    end
+    handle_asynchronously :process_asset
 
-      @@configured_carrierwave = true
+    def reprocess_asset(id)
+      Effective::Asset.find(id).reprocess!
+      (GC.start rescue nil)
     end
+    handle_asynchronously :reprocess_asset
 
   end
 end