the_storages 0.0.1 → 0.0.2

data/app/controllers/concerns/attached_files_actions.rb

@@ -0,0 +1,37 @@
+module AttachedFilesActions
+  def create
+    if params[:files]
+      attached_files_msg        = []
+      attached_files_errors_msg = []
+
+      params[:files].each do |file|
+        attached_file = @storage.attached_files.new
+        attached_file.attachment = file
+        
+        saved = attached_file.save
+
+        attached_files_msg.push        attached_file.attachment_file_name  if  saved
+        attached_files_errors_msg.push attached_file.errors.first          if !saved
+      end
+
+      flash[:notice] = attached_files_msg.join(', ')
+      flash[:error]  = attached_files_errors_msg.join(', ')
+
+      redirect_to [request.referer, :files].join('#')
+    end
+  end
+
+  def watermark_switch
+    attachment = AttachedFile.find(params[:id])
+    attachment.toggle!(:watermark)
+    attachment.refresh_base_image
+    render nothing: true
+  end
+
+  def destroy
+    attachment = AttachedFile.find(params[:id])
+    attachment.destroy_processed_files
+    attachment.destroy
+    redirect_to [request.referer, :files].join('#')
+  end
+end

data/app/controllers/concerns/the_storages_image_processor.rb

@@ -0,0 +1,20 @@
+module TheStoragesImageProcessor
+  def rotate_left
+    attached_file = AttachedFile.where(id: params[:id]).first
+    attached_file.rotate_left
+    redirect_to [request.referer, :files].join('#')
+  end
+
+  def rotate_right
+    attached_file = AttachedFile.where(id: params[:id]).first
+    attached_file.rotate_right
+    redirect_to [request.referer, :files].join('#')
+  end
+
+  def crop_image
+    x = params
+    attached_file = AttachedFile.where(id: x[:image_id]).first
+    attached_file.crop_image(:main_preview, x[:x], x[:y], x[:w], x[:h], x[:img_w])
+    render text: attached_file.url(:main_preview, nocache: true)
+  end
+end

data/app/helpers/attached_files_list_helper.rb

@@ -0,0 +1,115 @@
+# encoding: UTF-8
+
+# DOC:
+# We use Helper Methods for tree building,
+# because it's faster than View Templates and Partials
+
+# SECURITY note
+# Prepare your data on server side for rendering
+# or use h.html_escape(node.content)
+# for escape potentially dangerous content
+module AttachedFilesListHelper
+  module Render 
+    class << self
+      attr_accessor :h, :options
+
+      def render_node(h, options)
+        @h, @options = h, options
+        @node = options[:node]
+
+        "
+          <li data-node-id='#{ @node.id }'>
+            <div class='item'>
+              <i class='handle'></i>
+              #{ rotate_links }
+              <div class='preview_pic'>#{build_preview_pic}</div>
+              <div class='file_block'>
+                #{ show_link }
+                #{ url_input }
+                #{ watermark_switch }
+                #{ show_size }
+              </div>
+              #{ controls }
+            </div>
+            #{ children }
+          </li>
+        "
+      end
+
+      def current_host
+        h.request.protocol + h.request.host_with_port
+      end
+
+      def url_input
+        opts = {nocache: false, timestamp: false}
+        url = @node.is_image? ? @node.url(:base, opts) : @node.url(:original, opts)
+        "<div class='url_input'>URL: <input class='file_url' value='#{current_host + url}'></div>"
+      end
+
+      def show_size
+        "<div class='fsize'>#{@node.mb_size}</div>"
+      end
+
+      def watermark_switch
+        if @node.is_image?
+          link = if @node.watermark
+            "<span class='wm_on'>Вкл.</span>"
+          else
+            "<span class='wm_off'>Выкл.</span>"
+          end
+
+          "<div class='watermark_switcher'>Водный знак: #{link}</div>"
+        end
+      end
+
+      def rotate_links
+        if @node.is_image?
+          left  = h.link_to '', h.rotate_left_url(@node),  method: :patch, class: :left
+          right = h.link_to '', h.rotate_right_url(@node), method: :patch, class: :right
+          "<div class='rotate'>#{left} #{right}</div>"
+        end
+      end
+
+      def build_preview_pic
+        if @node.is_image?
+          src = @node.url(:preview)
+          url = @node.url(:base)
+          "<a href='#{url}'><img src='#{src}'></a>"
+        else
+          klass = @node.file_css_class
+          url = @node.url
+          "<a href='#{url}'><i class='#{klass}'></i></a>"
+        end
+      end
+
+      def show_link
+        node = options[:node]
+        ns   = options[:namespace]
+        title_field = options[:title]
+        title = node.send(title_field)
+        url = @node.is_image? ? @node.url(:base) : @node.url
+        "<h4>#{ h.link_to(title, url)}</h4>"
+      end
+
+      def controls
+        node = options[:node]
+
+        edit_path = h.url_for(:controller => options[:klass].pluralize, :action => :edit, :id => node)
+        show_path = h.url_for(:controller => options[:klass].pluralize, :action => :show, :id => node)
+
+        "
+          <div class='controls'>
+            #{ h.link_to '', show_path, :class => :delete, :method => :delete, :data => { :confirm => 'Are you sure?' } }
+          </div>
+        "
+      end
+
+      def children
+        unless options[:children].blank?
+          "<ol class='nested_set'>#{ options[:children] }</ol>"
+        end
+      end
+
+    end
+  end
+end

data/app/helpers/file_size_helper.rb

@@ -0,0 +1,9 @@
+module FileSizeHelper
+  def self.mb_size(bytes)
+    [sprintf("%.3f", bytes.to_f/1.megabyte.to_f), I18n.t('file_size_helper.mb')].join(' ')
+  end
+
+  def mb_size(bytes)
+    FileSizeHelper.mb_size(bytes)
+  end
+end

data/app/models/concerns/act_as_attached_file.rb

@@ -0,0 +1,69 @@
+# encoding: UTF-8
+module ActAsAttachedFile
+  extend ActiveSupport::Concern
+  include AttachmentProcessing
+  include StorageImageProcessing
+
+  included do
+    IMAGE_EXTS = %w[jpg jpeg pjpeg png x-png gif bmp]
+    IMAGE_CONTENT_TYPES = IMAGE_EXTS.map{ |e| "image/#{e}" }
+
+    belongs_to :user
+    belongs_to :storage, polymorphic: true
+    acts_as_nested_set scope: [:user_id, :storage_id, :storage_type]
+    include TheSortableTree::Scopes
+    
+    before_validation :generate_file_name, on: :create
+    after_create   :recalculate_storage_counters!
+    after_destroy  :recalculate_storage_counters!
+    scope :images, ->{ where(attachment_content_type: IMAGE_CONTENT_TYPES)  }
+  end
+
+  def file_css_class
+    'f_' + TheStorages.file_ext(attachment_file_name)
+  end
+
+  # HELPERS
+  def title
+    attachment_file_name
+  end
+
+  def file_name
+    TheStorages.file_name(attachment_file_name)
+  end
+
+  def content_type
+    attachment_content_type
+  end
+
+  def mb_size
+    FileSizeHelper.mb_size(attachment_file_size)
+  end
+
+  def path style = nil
+    attachment.path(style)
+  end
+
+  def url style = nil, opts = {}
+    url = attachment.url(style, opts)
+    return url unless opts[:nocache]
+    rnd = (rand*1000000).to_i.to_s
+    url =~ /\?/ ? (url + rnd) : (url + '?' + rnd)
+  end
+
+  # BASE HELPERS
+  def is_image?
+    IMAGE_EXTS.include? TheStorages.file_ext(attachment_file_name)
+  end
+
+  def generate_file_name
+    file_name  = attachment.instance_read(:file_name)
+    file_name  = TheStorages.slugged_file_name(file_name)
+    attachment.instance_write :file_name, file_name
+  end
+
+  # CALLBACKS
+  def recalculate_storage_counters!
+    storage.recalculate_storage_counters!
+  end
+end

data/app/models/concerns/act_as_storage.rb

@@ -2,35 +2,15 @@ module ActAsStorage
   extend ActiveSupport::Concern
 
   included do
-    has_many :uploaded_files, as: :storage
-
-    before_update :recalculate_files_data
-    after_update  :recalculate_files_data_for_user
-    after_destroy :recalculate_files_data_for_user
+    has_many :attached_files,  as: :storage
   end
 
-  def recalculate_files_data
-    sum   = 0
-    files = self.uploaded_files.active
-
-    files.each{ |f| sum += f.file_file_size }
-    self.files_size  = sum
-    self.files_count = files.size
-  end
-
-  def recalculate_files_data_for_user
-    user        = self.user
-    storages    = user.storages.active | user.recipes.active | user.pages.active | user.articles.active
-    files_size  = 0
-    files_count = 0
-
-    storages.each do |s|
-      files_size  += s.files_size
-      files_count += s.files_count
-    end
+  def recalculate_storage_counters!
+    af = attached_files.pluck(:attachment_file_size)
+    self.storage_files_count = af.count
+    self.storage_files_size  = af.sum
+    save
 
-    user.files_size  = files_size
-    user.files_count = files_count
-    user.save(:validation => false)
+    self.try(:user).try(:recalculate_all_attached_files!)
   end
 end

data/app/models/concerns/attachment_processing.rb

@@ -0,0 +1,46 @@
+module AttachmentProcessing
+  extend ActiveSupport::Concern
+
+  included do
+    attr_accessor :image_processing
+    before_create :set_processing_flags
+    after_commit  :delayed_file_processing
+
+    has_attached_file :attachment,
+                      default_url: ":rails_root/public/system/uploads/default/:style-missing.jpg",
+                      path:        ":rails_root/public/system/storages/:storage_type/:storage_id/:style/:filename",
+                      url:         "/system/storages/:storage_type/:storage_id/:style/:filename"
+
+    validates_attachment_size :attachment,
+      in: 10.bytes..5.megabytes,
+      message: I18n.translate('the_storages.validation.attachment_file_size')
+
+    validates :attachment_file_name,
+      uniqueness: {
+        scope: [:user_id, :storage_type, :storage_id],
+        message: I18n.translate('the_storages.validation.uniq_attachment_file_name')
+      }
+  end
+
+  def set_processing_flags
+    if is_image?
+      self.processing       = :processing
+      self.image_processing = true
+    end
+  end
+
+  # DELAYED JOB
+  def delayed_file_processing
+    if is_image? && image_processing
+      self.image_processing = false
+      job = DelayedImageProcessor.new(self)
+
+      job.perform
+      # Delayed::Job.enqueue job, queue: :image_processing, run_at: Proc.new { 10.seconds.from_now }
+    else
+      # if it's not image
+      # Upload file and recalculate
+      recalculate_storage_counters!
+    end
+  end
+end

data/app/models/concerns/has_attached_files.rb

@@ -0,0 +1,14 @@
+module HasAttachedFiles
+  extend ActiveSupport::Concern
+
+  included do
+    has_many :all_attached_files, class_name: :AttachedFile, foreign_key: :user_id
+  end
+
+  def recalculate_all_attached_files
+    af = all_attached_files.pluck(:attachment_file_size)
+    self.all_attached_files_count = af.count
+    self.all_attached_files_size  = af.sum
+    save
+  end
+end

data/app/models/concerns/image_manipulation.rb

@@ -0,0 +1,63 @@
+module ImageManipulation
+  extend ActiveSupport::Concern
+
+  # HELPERS
+  def landscape? image
+    image[:width] > image[:height]
+  end
+
+  def portrait? image
+    image[:width] < image[:height]
+  end
+
+  # Fu
+  def rotate_image src, dest, angle
+    img = MiniMagick::Image.open(src)
+    img.rotate(angle)
+    img.write(dest)
+  end
+
+  def rotate_attached_image angle
+    src = path
+    rotate_image(src,src,angle)
+    refresh_base_image
+  end
+
+  def rotate_left
+    rotate_attached_image "-90"
+  end
+
+  def rotate_right
+    rotate_attached_image "90"
+  end
+
+  def resize_to_larger_side image, side_size
+    if image[:width] > side_size.to_i
+      landscape?(image)             ?
+      image.resize("#{side_size}x") :
+      image.resize("x#{side_size}")
+    end
+
+    image
+  end
+
+  def resize_to_larger_side! src, side_size
+    image = MiniMagick::Image.open(src)
+    image = resize_to_larger_side(image, side_size)
+    image.write src
+  end
+
+  # IMAGE CROP
+  def crop_image src, dest, x0 = 0, y0 = 0, w = 100, h = 100, scale = 1
+    image = MiniMagick::Image.open src
+
+    x_shift = (x0.to_f * scale).to_i
+    y_shift = (y0.to_f * scale).to_i
+
+    w = (w.to_f * scale).to_i
+    h = (h.to_f * scale).to_i
+
+    image.crop "#{w}x#{h}+#{x_shift}+#{y_shift}"
+    image.write dest  
+  end
+end

data/app/models/concerns/storage_image_processing.rb

@@ -0,0 +1,90 @@
+# encoding: UTF-8
+module StorageImageProcessing
+  include WatermarkFu
+  include ImageManipulation
+
+  def draw_watermark
+    return false unless need_watermark?
+    build_watermarks
+    put_watermark_on_base_image
+  end
+
+  def build_base_images
+    resize_src_image
+    refresh_base_image
+
+    # set process state
+    src_size = File.size?(path)
+    update(processing: :finished, attachment_file_size: src_size)
+  end
+
+  def create_img_dir_path path
+    _path = path.split('/')[0...-1].join('/')
+    FileUtils.mkdir_p _path
+  end
+
+  # IMAGE PROCESSING
+  def prepare_image src, dest, larger_side
+    image = MiniMagick::Image.open src
+    image.auto_orient
+    resize_to_larger_side(image, larger_side)
+    image.strip
+    create_img_dir_path(dest)
+    image.write(dest)
+  end
+
+  def build_square_image src, dest, side = 100
+    image = MiniMagick::Image.open src
+
+    min_size = image[:width]
+    shift    = { x: 0, y: 0}
+    
+    if landscape?(image)
+      min_size  = image[:height]
+      shift[:x] = (image[:width] - min_size) / 2
+    elsif portrait?(image)
+      min_size  = image[:width]
+      shift[:y] = (image[:height] - min_size) / 2
+    end    
+    
+    x0 = shift[:x]
+    y0 = shift[:y]
+    w  = h = min_size
+
+    image.crop "#{w}x#{h}+#{x0}+#{y0}"
+    image.resize "#{side}x#{side}!"
+
+    create_img_dir_path(dest)
+    image.write dest
+  end
+
+  def build_correct_preview
+    src      = path
+    preview  = path :preview
+    build_square_image(src, preview, 100)
+  end
+
+  def build_base_image
+    src  = path
+    base = path :base
+    prepare_image(src, base, TheStorages.config.base_larger_side)
+  end
+
+  def refresh_base_image
+    build_base_image
+    build_correct_preview
+    draw_watermark
+  end
+
+  def resize_src_image
+    src = path
+    prepare_image(src, src, TheStorages.config.original_larger_side)
+  end
+
+  def destroy_processed_files
+    base    = path :base
+    preview = path :preview
+
+    FileUtils.rm([base, preview], force: true)
+  end
+end