gluttonberg-core 2.6.4 → 3.0.0

data/lib/gluttonberg/library/quick_magick/image/draw.rb

@@ -0,0 +1,133 @@
+module Gluttonberg
+  module Library
+    module QuickMagick
+      module Draw
+        extend ActiveSupport::Concern
+
+        # Instance Methods
+        # The shape primitives are drawn in the color specified by the preceding -fill setting.
+        # For unfilled shapes, use -fill none.
+        # You can optionally control the stroke (the "outline" of a shape) with the -stroke and -strokewidth settings.
+
+        # draws a point at the given location in pixels
+        # A point primitive is specified by a single point in the pixel plane, that is, by an ordered pair
+        # of integer coordinates, x,y.
+        # (As it involves only a single pixel, a point primitive is not affected by -stroke or -strokewidth.)
+        def draw_point(x, y, options={})
+          _draw(options, "point #{x},#{y}")
+        end
+
+        # draws a line between the given two points
+        # A line primitive requires a start point and end point.
+        def draw_line(x0, y0, x1, y1, options={})
+          _draw_4_points("line", x0, y0, x1, y1, options)
+        end
+
+        # draw a rectangle with the given two corners
+        # A rectangle primitive is specified by the pair of points at the upper left and lower right corners.
+        def draw_rectangle(x0, y0, x1, y1, options={})
+          _draw_4_points("rectangle", x0, y0, x1, y1, options)
+        end
+
+        # draw a rounded rectangle with the given two corners
+        # wc and hc are the width and height of the arc
+        # A roundRectangle primitive takes the same corner points as a rectangle
+        # followed by the width and height of the rounded corners to be removed.
+        def draw_round_rectangle(x0, y0, x1, y1, wc, hc, options={})
+          _draw_6_points("roundRectangle",  x0, y0, x1, y1, wc, hc, options)
+        end
+
+        # The arc primitive is used to inscribe an elliptical segment in to a given rectangle.
+        # An arc requires the two corners used for rectangle (see above) followed by
+        # the start and end angles of the arc of the segment segment (e.g. 130,30 200,100 45,90).
+        # The start and end points produced are then joined with a line segment and the resulting segment of an ellipse is filled.
+        def draw_arc(x0, y0, x1, y1, a0, a1, options={})
+          _draw_6_points("arc",  x0, y0, x1, y1, a0, a1, options)
+        end
+
+        # Use ellipse to draw a partial (or whole) ellipse.
+        # Give the center point, the horizontal and vertical "radii"
+        # (the semi-axes of the ellipse) and start and end angles in degrees (e.g. 100,100 100,150 0,360).
+        def draw_ellipse(x0, y0, rx, ry, a0, a1, options={})
+          _draw_6_points("ellipse",  x0, y0, rx, ry, a0, a1, options)
+        end
+
+        # The circle primitive makes a disk (filled) or circle (unfilled). Give the center and any point on the perimeter (boundary).
+        def draw_circle(x0, y0, x1, y1, options={})
+          _draw_4_points("circle", x0, y0, x1, y1, options)
+        end
+
+        # The polyline primitive requires three or more points to define their perimeters.
+        # A polyline is simply a polygon in which the final point is not stroked to the start point.
+        # When unfilled, this is a polygonal line. If the -stroke setting is none (the default), then a polyline is identical to a polygon.
+        #  points - A single array with each pair forming a coordinate in the form (x, y).
+        # e.g. [0,0,100,100,100,0] will draw a polyline between points (0,0)-(100,100)-(100,0)
+        def draw_polyline(points, options={})
+          _draw(options, "polyline #{points_to_str(points)}")
+        end
+
+        # The polygon primitive requires three or more points to define their perimeters.
+        # A polyline is simply a polygon in which the final point is not stroked to the start point.
+        # When unfilled, this is a polygonal line. If the -stroke setting is none (the default), then a polyline is identical to a polygon.
+        #  points - A single array with each pair forming a coordinate in the form (x, y).
+        # e.g. [0,0,100,100,100,0] will draw a polygon between points (0,0)-(100,100)-(100,0)
+        def draw_polygon(points, options={})
+          _draw(options, "polygon #{points_to_str(points)}")
+        end
+
+        # The Bezier primitive creates a spline curve and requires three or points to define its shape.
+        # The first and last points are the knots and these points are attained by the curve,
+        # while any intermediate coordinates are control points.
+        # If two control points are specified, the line between each end knot and its sequentially
+        # respective control point determines the tangent direction of the curve at that end.
+        # If one control point is specified, the lines from the end knots to the one control point
+        # determines the tangent directions of the curve at each end.
+        # If more than two control points are specified, then the additional control points
+        # act in combination to determine the intermediate shape of the curve.
+        # In order to draw complex curves, it is highly recommended either to use the path primitive
+        # or to draw multiple four-point bezier segments with the start and end knots of each successive segment repeated.
+        def draw_bezier(points, options={})
+          _draw(options, "bezier #{points_to_str(points)}")
+        end
+
+        # A path represents an outline of an object, defined in terms of moveto
+        # (set a new current point), lineto (draw a straight line), curveto (draw a Bezier curve),
+        # arc (elliptical or circular arc) and closepath (close the current shape by drawing a
+        # line to the last moveto) elements.
+        # Compound paths (i.e., a path with subpaths, each consisting of a single moveto followed by
+        # one or more line or curve operations) are possible to allow effects such as donut holes in objects.
+        # (See http://www.w3.org/TR/SVG/paths.html)
+        def draw_path(path_spec, options={})
+          _draw(options, "path #{path_spec}")
+        end
+
+        # Use image to composite an image with another image. Follow the image keyword
+        # with the composite operator, image location, image size, and filename
+        # You can use 0,0 for the image size, which means to use the actual dimensions found in the image header.
+        # Otherwise, it is scaled to the given dimensions. See -compose for a description of the composite operators.
+        def draw_image(operator, x0, y0, w, h, image_filename, options={})
+          _draw(options, "image #{operator} #{x0},#{y0} #{w},#{h} \"#{image_filename}\"")
+        end
+
+        # Use text to annotate an image with text. Follow the text coordinates with a string.
+        def draw_text(x0, y0, text, options={})
+          _draw(options, "text #{x0},#{y0} '#{text}'")
+        end
+
+        private
+          def _draw(options, draw_command_postfix)
+            append_to_operators("draw", "#{options_to_str(options)} #{draw_command_postfix}")
+          end
+
+          # draw_ellipse, draw_arc, draw_round_rectangle
+          def _draw_6_points(shape,  x0, y0, rx, ry, a0, a1, options={})
+            _draw(options, "#{shape} #{x0},#{y0} #{rx},#{ry} #{a0},#{a1}")
+          end
+
+          def _draw_4_points(shape, x0, y0, x1, y1, options={})
+            _draw(options, "#{shape} #{x0},#{y0} #{x1},#{y1}")
+          end
+      end #Draw
+    end
+  end
+end

data/lib/gluttonberg/library/quick_magick/image/operators_and_settings.rb

@@ -0,0 +1,78 @@
+module Gluttonberg
+  module Library
+    module QuickMagick
+      module OperatorsAndSettings
+        extend ActiveSupport::Concern
+
+        # InstanceMethods
+        # Image operators supported by ImageMagick
+        IMAGE_OPERATORS_METHODS = %w{
+          alpha auto-orient bench black-threshold bordercolor charcoal clip clip-mask clip-path colorize
+          contrast convolve cycle decipher deskew despeckle distort edge encipher emboss enhance equalize
+          evaluate flip flop function gamma identify implode layers level level-colors median modulate monochrome
+          negate noise normalize opaque ordered-dither NxN paint polaroid posterize print profile quantize
+          radial-blur Raise random-threshold recolor render rotate segment sepia-tone set shade solarize
+          sparse-color spread strip swirl threshold tile tint transform transparent transpose transverse trim
+          type unique-colors white-threshold
+
+          adaptive-blur adaptive-resize adaptive-sharpen annotate blur border chop contrast-stretch extent
+          extract frame gaussian-blur geometry lat linear-stretch liquid-rescale motion-blur region repage
+          resample resize roll sample scale selective-blur shadow sharpen shave shear sigmoidal-contrast
+          sketch splice thumbnail unsharp vignette wave
+
+          append average clut coalesce combine composite deconstruct flatten fx hald-clut morph mosaic process reverse separate write
+          crop
+          }
+
+        # methods that are called with (=)
+        WITH_EQUAL_METHODS =
+          %w{alpha background bias black-point-compensation blue-primary border bordercolor caption
+            cahnnel colors colorspace comment compose compress depth density encoding endian family fill filter
+            font format frame fuzz geometry gravity label mattecolor page pointsize quality stroke strokewidth
+            undercolor units weight
+            brodercolor transparent type size}
+
+        # methods that takes geometry options
+        WITH_GEOMETRY_METHODS =
+          %w{density page sampling-factor size tile-offset adaptive-blur adaptive-resize adaptive-sharpen
+            annotate blur border chop contrast-stretch extent extract frame gaussian-blur
+            geometry lat linear-stretch liquid-rescale motion-blur region repage resample resize roll
+            sample scale selective-blur shadow sharpen shave shear sigmoidal-contrast sketch
+            splice thumbnail unsharp vignette wave crop}
+
+        # Methods that need special treatment. This array is used just to keep track of them.
+        SPECIAL_COMMANDS =
+          %w{floodfill antialias draw}
+
+        # Image settings supported by ImageMagick
+        IMAGE_SETTINGS_METHODS = %w{
+          adjoin affine alpha authenticate attenuate background bias black-point-compensation
+          blue-primary bordercolor caption channel colors colorspace comment compose compress define
+          delay depth display dispose dither encoding endian family fill filter font format fuzz gravity
+          green-primary intent interlace interpolate interword-spacing kerning label limit loop mask
+          mattecolor monitor orient ping pointsize preview quality quiet red-primary regard-warnings
+          remap respect-parentheses scene seed stretch stroke strokewidth style taint texture treedepth
+          transparent-color undercolor units verbose view virtual-pixel weight white-point
+
+          density page sampling-factor size tile-offset
+        }
+
+        (IMAGE_OPERATORS_METHODS + IMAGE_SETTINGS_METHODS).flatten.each do |method|
+          if WITH_EQUAL_METHODS.include?(method)
+            define_method((method+'=').to_sym) do |arg|
+              append_to_settings(method, arg)
+            end
+          elsif WITH_GEOMETRY_METHODS.include?(method)
+            define_method((method).to_sym) do |*args|
+              append_to_settings(method, QuickMagick::geometry(*args) )
+            end
+          else
+            define_method(method.to_sym) do |*args|
+              append_to_settings(method, args.join(" "))
+            end
+          end
+        end
+      end #Operators
+    end #QuickMagick
+  end
+end

data/lib/gluttonberg/library/quick_magick/image/serialization.rb

@@ -0,0 +1,79 @@
+module Gluttonberg
+  module Library
+    module QuickMagick
+      module Serialization
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          # create an array of images from the given blob data
+          def from_blob(blob, &proc)
+            file = Tempfile.new(QuickMagick::random_string)
+            file.binmode
+            file.write(blob)
+            file.close
+            self.read(file.path, &proc)
+          end
+
+          # create an array of images from the given file
+          def read(filename, &proc)
+            info = identify(%Q<"#{filename}">)
+            info_lines = info.split(/[\r\n]/)
+            images = []
+            info_lines.each_with_index do |info_line, i|
+              images << Image.new("#{filename}", i, info_line)
+            end
+            images.each(&proc) if block_given?
+            return images
+          end
+
+          alias open read
+        end #ClassMethods
+
+        # InstanceMethods
+        # saves the current image to the given filename
+        def save(output_filename)
+          result = QuickMagick.exec3 "convert #{command_line} #{QuickMagick.c output_filename}"
+          if @pseudo_image
+            # since it's been saved, convert it to normal image (not pseudo)
+            initialize(output_filename)
+            revert!
+          end
+          return result
+        end
+
+        alias write save
+        alias convert save
+
+        # saves the current image overwriting the original image file
+        def save!
+          raise QuickMagick::QuickMagickError, "Cannot mogrify a pseudo image" if @pseudo_image
+          result = QuickMagick.exec3 "mogrify #{command_line}"
+          # remove all operations to avoid duplicate operations
+          revert!
+          return result
+        end
+
+        alias write! save!
+        alias mogrify! save!
+
+        def to_blob
+          tmp_file = Tempfile.new(QuickMagick::random_string)
+          if command_line =~ /-format\s(\S+)\s/
+            # use format set up by user
+            blob_format = $1
+          elsif !@pseudo_image
+            # use original image format
+            blob_format = self.format
+          else
+            # default format is jpg
+            blob_format = 'jpg'
+          end
+          save "#{blob_format}:#{tmp_file.path}"
+          blob = nil
+          File.open(tmp_file.path, 'rb') { |f| blob = f.read}
+          blob
+        end
+      end #Settings
+    end #QuickMagick
+  end
+end

data/lib/gluttonberg/library/quick_magick/image_list.rb

@@ -1,6 +1,5 @@
 module Gluttonberg
   module Library
-
     module QuickMagick
       class ImageList
 

data/lib/gluttonberg/library/storage/filesystem.rb

@@ -2,73 +2,72 @@ module Gluttonberg
   module Library
     module Storage
       module Filesystem
-
+        extend ActiveSupport::Concern
         module ClassMethods
           # It run when the engine is loaded. It makes sure that all the required
           # directories for storing assets are in the public dir, creating them if
           # they are missing. It also stores the various paths so they can be
           # retreived using the assets_dir method.
-          def self.storage_setup
-            Library.set_asset_root("public/user_assets", "public/user_assets", "public/test_assets")
+          def storage_setup
+            Library.set_asset_root(File.join(Rails.root, "public/user_assets"), File.join(Rails.root, "public/user_assets"), File.join(Rails.root, "public/test_assets"))
             FileUtils.mkdir(Library.root) unless File.exists?(Library.root) || File.symlink?(Library.root)
           end
         end
 
-        module InstanceMethods
 
-          # The generated directory where this file is located. If it is an image
-          # it’s thumbnails will be stored here as well.
-          def directory
-            Filesystem::ClassMethods.storage_setup if Library.root.blank?
-            Library.root + "/" + self.asset_hash
-          end
+        # The generated directory where this file is located. If it is an image
+        # it’s thumbnails will be stored here as well.
+        def directory
+          self.class.storage_setup if Library.root.blank?
+          Library.root + "/" + self.asset_hash
+        end
 
-          def tmp_directory
-            Filesystem::ClassMethods.storage_setup if Library.tmp_root.blank?
-            Library.tmp_root + "/" + self.asset_hash
-          end
+        def tmp_directory
+          self.class.storage_setup if Library.tmp_root.blank?
+          Library.tmp_root + "/" + self.asset_hash
+        end
 
-          def assets_directory_public_url
-            "/user_assets"
-          end
+        def assets_directory_public_url
+          "/user_assets"
+        end
 
-          def make_backup
-            unless File.exist?(original_file_on_disk)
-              FileUtils.cp location_on_disk, original_file_on_disk
-              FileUtils.chmod(0755,original_file_on_disk)
-            end
-          end
+        def make_backup(replace_backup=true)
+          FileUtils.rm(original_file_on_disk) if replace_backup && File.exist?(original_file_on_disk)
+          FileUtils.cp location_on_disk, original_file_on_disk unless File.exist?(original_file_on_disk)
+          FileUtils.chmod(0755,original_file_on_disk)
+        end
 
-          def remove_file_from_storage
-            if File.exists?(directory)
-              FileUtils.rm_r(directory)
-            end
+        def remove_file_from_storage
+          if File.exists?(directory)
+            FileUtils.rm_r(directory)
           end
+        end
 
-          def remove_file_from_tmp_storage
-            # just dummy method. As we don't need to remove because tmp and actual folder is same for filesystem
-          end
+        def remove_file_from_tmp_storage
+          # just dummy method. As we don't need to remove because tmp and actual folder is same for filesystem
+        end
+
+        def download_asset_to_tmp_file
+          # just dummy method. As we don't need to download file for filesystem storage
+        end
 
-          def update_file_on_storage
-            if file
-              FileUtils.mkdir(directory) unless File.exists?(directory)
-              FileUtils.cp file.tempfile.path, location_on_disk
-              FileUtils.chmod(0755, location_on_disk)
+        def update_file_on_storage
+          if file
+            FileUtils.mkdir(directory) unless File.exists?(directory)
+            FileUtils.rm(location_on_disk) if File.exists?(location_on_disk)
+            FileUtils.cp file.tempfile.path, location_on_disk
+            FileUtils.chmod(0755, location_on_disk)
 
-              #  new file has been upload, if its image generate thumbnails, if mp3 collect sound info.
-              asset_processing
-            end
+            #  new file has been upload, if its image generate thumbnails, if mp3 collect sound info.
+            asset_processing
           end
+        end
 
-          def move_tmp_file_to_actual_directory(file_name , tmp_file_dirty=true)
-            if self.file_dirty == true
-              self.file_dirty = false
-            end
+        def move_tmp_file_to_actual_directory(file_name , tmp_file_dirty=true)
+          if self.file_dirty == true
+            self.file_dirty = false
           end
-
-          # def write_file_to_disc(src_file_path , )
-          # end
-        end #InstanceMethods
+        end
 
       end #Filesystem
     end #Storage

data/lib/gluttonberg/library/storage/s3.rb

@@ -2,41 +2,47 @@ module Gluttonberg
   module Library
     module Storage
       module S3
+        extend ActiveSupport::Concern
+
         module ClassMethods
           # It run when the engine is loaded. It makes sure that all the required
           # directories for storing assets are in the public dir, creating them if
           # they are missing. It also stores the various paths so they can be
           # retreived using the assets_dir method.
           TEMP_ASSET_DIRECTORY = "tmp/user_assets"
-          def self.storage_setup
+          def storage_setup
             Library.set_asset_root("user_assets", TEMP_ASSET_DIRECTORY, "public/test_assets")
             FileUtils.mkdir(Library.root) unless File.exists?(Library.root) || File.symlink?(Library.root)
             FileUtils.mkdir(Library.tmp_root) unless File.exists?(Library.tmp_root) || File.symlink?(Library.tmp_root)
           end
 
-          def self.s3_server_url
+          def s3_server_url
             Gluttonberg::Setting.get_setting("s3_server_url")
           end
 
-          def self.s3_bucket_name
+          def s3_bucket_name
             Gluttonberg::Setting.get_setting("s3_bucket")
           end
 
-          def self.s3_server_key_id
+          def s3_server_key_id
             Gluttonberg::Setting.get_setting("s3_key_id")
           end
 
-          def self.s3_server_access_key
+          def s3_server_access_key
             Gluttonberg::Setting.get_setting("s3_access_key")
           end
 
-          def self.bucket_handle
-            key_id = S3::ClassMethods.s3_server_key_id
-            key_val = S3::ClassMethods.s3_server_access_key
-            s3_server_url = S3::ClassMethods.s3_server_url
-            s3_bucket = S3::ClassMethods.s3_bucket_name
+          def bucket_handle
+            key_id = self.s3_server_key_id
+            key_val = self.s3_server_access_key
+            s3_server_url = self.s3_server_url
+            s3_bucket = self.s3_bucket_name
             if !key_id.blank? && !key_val.blank? && !s3_server_url.blank? && !s3_bucket.blank?
-              s3 = AWS::S3.new({ :access_key_id => key_id, :secret_access_key => key_val , :server => s3_server_url})
+              s3 = AWS::S3.new({
+                :access_key_id => key_id,
+                :secret_access_key => key_val,
+                :server => s3_server_url
+              })
               bucket = s3.buckets[s3_bucket]
             else
               nil
@@ -44,149 +50,149 @@ module Gluttonberg
           end
 
           #takes file from public/assets folder and upload to s3 if s3 info is given in CMS settings
-          def self.migrate_file_to_s3(asset_hash , file_name, mime_type='')
+          def migrate_file_to_s3(asset_hash , file_name, mime_type='')
             bucket = bucket_handle
-            unless bucket.blank?
-              local_file = "public/user_assets/" + asset_hash + "/" + file_name
+            if bucket != nil
               key_for_s3 = "user_assets/" + asset_hash + "/" + file_name
-              date = Time.now+1.years
-              key = bucket.objects[key_for_s3]
               asset = Gluttonberg::Asset.where(:asset_hash => asset_hash).first
               unless asset.blank?
-                puts " Copying #{local_file} to #{S3::ClassMethods.s3_bucket_name}"
-
-                mime_type = asset.mime_type if mime_type.blank?
-
-                unless mime_type.blank?
-                  key.write(File.open(local_file), {:expires => date.rfc2822, :content_type => mime_type , :acl => :public_read })
-                else
-                  key.write(File.open(local_file) , {:expires => date.rfc2822 , :acl => :public_read })
-                end
+                local_file = asset.tmp_directory + "/" + file_name
+                local_file = "public/user_assets/" + asset_hash + "/" + file_name unless File.exist?(local_file)
+                puts " Copying #{local_file} to #{self.s3_bucket_name}"
+                self.upload_file_to(asset, bucket.objects[key_for_s3], mime_type, local_file)
                 asset.update_attributes(:copied_to_s3 => true)
-                puts "Copied"
               end
             end
           end
 
+          def upload_file_to(asset, bucket_key, mime_type, local_file)
+            options = {
+              :expires => (Time.now+1.years).rfc2822,
+              :acl => :public_read
+            }
+            mime_type = asset.mime_type if mime_type.blank?
+            options[:content_type] = mime_type unless mime_type.blank?
+            response = bucket_key.write(File.open(File.join((Rails.env == 'test' ? Engine.root : Rails.root),local_file)), options)
+            puts "Copied"
+          end
+
         end
 
-        module InstanceMethods
 
-          def bucket_handle
-            unless @bucket.blank?
-              @bucket
-            else
-              @bucket = S3::ClassMethods.bucket_handle
-            end
-          end
+        # InstanceMethods
 
-          # The generated directory where this file is located.
-          def directory
-            S3::ClassMethods.storage_setup if Library.root.blank?
-            Library.root + "/" + self.asset_hash
-          end
+        def bucket_handle
+          @bucket ||= self.class.bucket_handle
+        end
 
-          # The generated tmp directory where we will locate this file temporarily for processing.
-          def tmp_directory
-            S3::ClassMethods.storage_setup if Library.tmp_root.blank?
-            Library.tmp_root + "/" + self.asset_hash
-          end
+        def bucket_handle=(handle)
+          @bucket = handle
+        end
 
-          def s3_bucket_root_url
-            "http://#{S3::ClassMethods.s3_server_url}/#{S3::ClassMethods.s3_bucket_name}"
-          end
+        # The generated directory where this file is located.
+        def directory
+          self.class.storage_setup if Library.root.blank?
+          Library.root + "/" + self.asset_hash
+        end
 
-          def assets_directory_public_url
-            "#{s3_bucket_root_url}/user_assets"
-          end
+        # The generated tmp directory where we will locate this file temporarily for processing.
+        def tmp_directory
+          self.class.storage_setup if Library.tmp_root.blank?
+          Library.tmp_root + "/" + self.asset_hash
+        end
 
-          def make_backup
-            unless File.exist?(tmp_original_file_on_disk)
-              FileUtils.cp tmp_location_on_disk, tmp_original_file_on_disk
-              FileUtils.chmod(0755,tmp_original_file_on_disk)
-              move_tmp_file_to_actual_directory("original_" + file_name , true)
-            end
-          end
+        def s3_bucket_root_url
+          "http://#{self.class.s3_server_url}/#{self.class.s3_bucket_name}"
+        end
 
-          def remove_file_from_storage
-            remove_file_from_tmp_storage
-            remove_asset_folder_from_s3
+        def assets_directory_public_url
+          "#{s3_bucket_root_url}/user_assets"
+        end
+
+        def make_backup(replace_backup=true)
+          unless File.exist?(tmp_original_file_on_disk)
+            FileUtils.cp tmp_location_on_disk, tmp_original_file_on_disk
+            FileUtils.chmod(0755,tmp_original_file_on_disk)
+            move_tmp_file_to_actual_directory("original_" + file_name , true)
           end
+        end
 
-          def remove_file_from_tmp_storage
-            if File.exists?(tmp_directory)
-              puts "Remove assset folder from tmp storage (#{tmp_directory})"
-              FileUtils.rm_r(tmp_directory)
-            end
+        def remove_file_from_storage
+          remove_file_from_tmp_storage
+          remove_asset_folder_from_s3
+        end
+
+        def remove_file_from_tmp_storage
+          if File.exists?(tmp_directory)
+            puts "Remove assset folder from tmp storage (#{tmp_directory})"
+            FileUtils.rm_r(tmp_directory)
           end
+        end
 
-          def update_file_on_storage
-            if file
-              FileUtils.mkdir(tmp_directory) unless File.exists?(tmp_directory)
-              FileUtils.cp file.tempfile.path, tmp_location_on_disk
-              FileUtils.chmod(0755, tmp_location_on_disk)
-
-              move_tmp_file_to_actual_directory(file_name , false)
-              #  new file has been upload, if its image generate thumbnails, if mp3 collect sound info.
-              asset_processing
-              # delete local tmp folder
-              remove_file_from_tmp_storage
-            end
+        def update_file_on_storage
+          if file
+            FileUtils.mkdir(tmp_directory) unless File.exists?(tmp_directory)
+            FileUtils.cp file.tempfile.path, tmp_location_on_disk
+            FileUtils.chmod(0755, tmp_location_on_disk)
+
+            move_tmp_file_to_actual_directory(file_name , false)
+            #  new file has been upload, if its image generate thumbnails, if mp3 collect sound info.
+            asset_processing
+            # delete local tmp folder
+            remove_file_from_tmp_storage  unless self.asset_type.asset_category.name == "video"
           end
+        end
 
-          def move_tmp_file_to_actual_directory(file_name , tmp_file_dirty=true)
-            if self.file_dirty == true || tmp_file_dirty == true
-              copy_file_to_s3(file_name)
-              self.file_dirty = false
-            end
+        def move_tmp_file_to_actual_directory(file_name , tmp_file_dirty=true)
+          if self.file_dirty == true || tmp_file_dirty == true
+            copy_file_to_s3(file_name)
+            self.file_dirty = false
           end
+        end
 
-          #takes file from tmp folder and upload to s3 if s3 info is given in CMS settings
-          def copy_file_to_s3(file_name)
-            bucket = bucket_handle
-            unless bucket.blank?
-              local_file = self.tmp_directory + "/" + file_name
-              folder = self.asset_hash
-              date = Time.now+1.years
-              puts "Copying #{file_name} (#{local_file}) to #{S3::ClassMethods.s3_bucket_name}"
-              key = bucket.objects[self.directory + "/" + file_name]
-              unless self.mime_type.blank?
-                key.write(File.open(local_file), {:expires => date.rfc2822, :content_type => self.mime_type , :acl => :public_read })
-              else
-                key.write(File.open(local_file) , {:expires => date.rfc2822 , :acl => :public_read })
-              end
-              self.update_column(:copied_to_s3 , true)
-              puts "Copied"
-            end
+        #takes file from tmp folder and upload to s3 if s3 info is given in CMS settings
+        def copy_file_to_s3(file_name)
+          bucket = bucket_handle
+          if bucket
+            local_file = self.tmp_directory + "/" + file_name
+            puts "Copying #{file_name} (#{local_file}) to #{self.class.s3_bucket_name}"
+            bucket_key = bucket.objects[self.directory + "/" + file_name]
+            self.class.upload_file_to(self, bucket_key, self.mime_type, local_file)
+            self.update_column(:copied_to_s3 , true)
           end
+        end
 
+        # This method is used for delayed job
+        def copy_audios_to_s3
+          copy_file_to_s3(self.file_name)
+        end
 
+        # TODO
+        def remove_file_from_s3(file_name)
+        end
 
-          # TODO
-          def remove_file_from_s3(file_name)
+        def remove_asset_folder_from_s3
+          bucket = bucket_handle
+          unless bucket.blank?
+            bucket.objects.with_prefix(self.directory).delete_all
           end
+        end
 
-          def remove_asset_folder_from_s3
-            bucket = bucket_handle
-            unless bucket.blank?
-              bucket.objects.with_prefix(self.directory).delete_all
-            end
-          end
+        def download_asset_to_tmp_file
+          download_orginal_file_from_s3
+        end
 
-          def download_asset_to_tmp_file
-            download_orginal_file_from_s3
-          end
+        def download_orginal_file_from_s3
+          FileUtils.mkdir(self.tmp_directory) unless File.exists?(self.tmp_directory)
+          _download_file_from_s3(self.location_on_disk, self.tmp_location_on_disk)
+          _download_file_from_s3(self.original_file_on_disk, self.tmp_original_file_on_disk)
+        end
 
-          def download_orginal_file_from_s3
+        private
+          def _download_file_from_s3(src, dest)
             FileUtils.mkdir(self.tmp_directory) unless File.exists?(self.tmp_directory)
             bucket = bucket_handle
             key = bucket.objects[self.location_on_disk]
-            File.open(self.tmp_location_on_disk, "w", encoding: "ASCII-8BIT") do |f|
-              key.read do |chunk|
-                f.write(chunk)
-              end
-            end
-            key = bucket.objects[self.original_file_on_disk]
             if key.exists?
               File.open(self.tmp_original_file_on_disk, "w", encoding: "ASCII-8BIT") do |f|
                 key.read do |chunk|
@@ -195,8 +201,6 @@ module Gluttonberg
               end
             end
           end
-
-        end #InstanceMethods
       end #S3
     end #Storage
   end #Library