neofiles 1.0.0

data/app/controllers/concerns/neofiles/not_found.rb

@@ -0,0 +1,21 @@
+# Return 404 NOT FOUND response when requested file is not found in the database.
+#
+# This concern is to be included in serving controllers (Files/ImagesController).
+#
+module Neofiles::NotFound
+  extend ActiveSupport::Concern
+
+  include ActionController::Rescue
+
+  included do
+    rescue_from Mongoid::Errors::DocumentNotFound, with: :error_404
+
+    def error_404
+      self.response_body = I18n.t('neofiles.404_not_found')
+      self.content_type = 'text/plain; charset=utf-8'
+      self.status = 404
+    end
+
+    private :error_404
+  end
+end

data/app/controllers/neofiles/admin_controller.rb

@@ -0,0 +1,228 @@
+# The main controller, doing all persistence related activities. It extends ApplicationController to derive
+# any application-specific business logic, like before/after filters, auth & auth and stuff.
+#
+# To setup routes to this controller use Neofiles.routes_proc, @see lib/neofiles.rb
+#
+# As the main principle behind whole Neofiles thing is AJAX file manipulations, actions of this controller
+# mainly form backend for AJAX calls.
+#
+class Neofiles::AdminController < ApplicationController
+
+  # TODO: remove this! it should be controlled on application side
+  skip_before_filter :verify_authenticity_token
+
+  # Build AJAX edit/upload form for a single file in compact way: small file thumbnail + misc buttons, like "delete",
+  # "change options" etc.
+  #
+  # It is expected that someday there will be "full" view (hence the prefix "compact" here), with metadata shown
+  # and all kinds of tools exposed.
+  #
+  # If param[:id] is present, the form displayed is for editing a file, while empty or non existent ID displays
+  # an upload form.
+  #
+  # The parameter fake_request allows to build form when needed, when there is no actual request available
+  # (@see #file_save).
+  #
+  # Main parameters:
+  #
+  #   request[:input_name]    - input with this name will be present in HTML and populated with ID of persisted file
+  #   request[:widget_id]     - DOM identifier for this file widget instance
+  #   request[:clean_remove]  - after deleting this file, no substituting upload form should be shown (default '0')
+  #   request[:append_create] - after persisting new file, action should return form for the file + an upload form
+  #                             (default '0')
+  #   request[:disabled]      - only show file, not allow anything to be edited (default '0')
+  #   request[:multiple]      - allow uploading of multiple files at once (default '0')
+  #   request[:with_desc]     - show short file description (default '0')
+  #
+  # Parameters clear_remove & append_create are used to organize Albums — technically a collection of single files.
+  #
+  def file_compact(fake_request = nil)
+    request = fake_request || self.request
+
+    begin
+      @file = Neofiles::File.find request[:id] if request[:id].present?
+    rescue Mongoid::Errors::DocumentNotFound
+      @file = nil
+    end
+
+    @error = I18n.t('neofiles.file_not_found') if request[:id].present? and @file.blank?
+
+    @input_name     = request[:input_name].to_s
+    @widget_id      = request[:widget_id].presence
+    @clean_remove   = request[:clean_remove].present? && request[:clean_remove] != '0'
+    @append_create  = request[:append_create].present? && request[:append_create] != '0'
+    @disabled       = request[:disabled].present? && request[:disabled] != '0'
+    @multiple       = request[:multiple].present? && request[:multiple] != '0'
+    @with_desc      = request[:with_desc].present? && request[:with_desc] != '0'
+    @error        ||= ''
+
+    if fake_request
+      return render_to_string action: :file_compact, layout: false
+    else
+      render layout: false
+    end
+  end
+
+  # Persist new file(s) to database and return view forms for all of them (@see #file_compact) as one big HTML.
+  #
+  # Raises exception if something went wrong.
+  #
+  # This method uses append_create parameter originally passed to #file_compact (stored by JavaScript and sent again
+  # via AJAX call).
+  #
+  def file_save
+    data = request[:neofiles]
+    raise ArgumentError.new I18n.t('neofiles.data_not_passed') unless data.is_a? Hash
+
+    files = data[:file]
+    files = [files] unless files.is_a? Array
+    old_file = data[:id].present? ? Neofiles::File.find(data[:id]) : nil
+
+    file_objects = []
+    errors = []
+    last_exception = nil
+    files.each_with_index do |uploaded_file, i|
+      errors.push("#{I18n.t('neofiles.file_not_passed')} (#{i + 1})") and next unless uploaded_file.respond_to? :read
+
+      file_class = Neofiles::File.class_by_file_object(uploaded_file)
+      file = file_class.new do |f|
+        f.description = data[:description].presence || old_file.try(:description)
+        f.file = uploaded_file
+      end
+
+      begin
+        Rails.application.config.neofiles.before_save.try!(:call, file)
+        file.save!
+      rescue Exception => ex
+        last_exception = ex
+        notify_airbrake(ex) if defined? notify_airbrake
+        next
+      end
+
+      file_objects << file
+    end
+
+    result = []
+    file_objects.each_with_index do |file, i|
+      result << file_compact(data.merge(id: file.id, widget_id: "#{data[:widget_id]}_ap_#{i}", append_create: i == file_objects.count - 1 && !old_file && data[:append_create] == '1' ? '1' : '0'))
+    end
+
+    if result.empty?
+      raise ArgumentError.new(last_exception || (errors.empty? ? I18n.t('neofiles.file_not_passed') : errors.join("\n")))
+    end
+
+    render text: result.join, layout: false
+  end
+
+  # As we don't actually delete anything, this method only marks file as deleted.
+  #
+  # This method uses clean_remove parameter originally passed to #file_compact (stored by JavaScript and sent again
+  # via AJAX call).
+  #
+  def file_remove
+    file, data = find_file_and_data
+
+    file.is_deleted = true
+    file.save!
+
+    return render text: '' if data[:clean_remove].present? && data[:clean_remove] != '0'
+
+    redirect_to neofiles_file_compact_path(data.merge(id: nil))
+  end
+
+  # As Neofiles treats files as immutables, this method updates only auxiliary fields: description, no_wm etc.
+  #
+  # Returns nothing.
+  #
+  def file_update
+    file, data = find_file_and_data
+    file.update data.slice(:description, :no_wm)
+    render text: '', layout: false
+  end
+
+  # Neofiles knows how to play with Redactor.js and this method persists files uploaded via this WYSIWYG editor.
+  #
+  # Redactor.js may know which owner object is edited so we can store owner_type/id for later use.
+  #
+  # Returns JSON list of persisted files.
+  #
+  def redactor_upload
+    owner_type, owner_id, file = prepare_owner_type(request[:owner_type]), request[:owner_id], request[:file]
+    raise ArgumentError.new I18n.t('neofiles.data_not_passed') if owner_type.blank? || owner_id.blank?
+    raise ArgumentError.new I18n.t('neofiles.file_not_passed') unless file.present? && file.respond_to?(:read)
+
+    file_class = Neofiles::File.class_by_file_object(file)
+
+    file = file_class.new do |f|
+      f.owner_type  = owner_type
+      f.owner_id    = owner_id
+      f.description = request[:description].presence
+
+      f.no_wm = true if f.respond_to?(:no_wm)
+      f.file  = file
+    end
+
+    Rails.application.config.neofiles.before_save.try!(:call, file)
+    file.save!
+
+    # returns JSON {filelink: '/neofiles/serve-file/#{file.id}'}
+    render json: {filelink: neofiles_file_path(file), filename: file.filename}
+  end
+
+  # Returns JSON of files assigned to specific owner to show them in Redactor.js tab "previously uploaded files".
+  #
+  def redactor_list
+    type, owner_type, owner_id = request[:type], prepare_owner_type(request[:owner_type]), request[:owner_id]
+
+    type ||= 'file'
+
+    begin
+      file_class = "Neofiles::#{type.classify}".constantize
+    rescue
+      raise ArgumentError.new I18n.t('neofiles.unknown_file_type', type: type)
+    end
+
+    result = []
+    files = file_class.where(owner_type: owner_type, owner_id: owner_id)
+    files.each do |f|
+      if f.is_a?(Neofiles::Image)
+        result << {
+          thumb: neofiles_image_path(f, format: '100x100'),
+          image: neofiles_file_path(f),
+          title: f.description.to_s,
+          #folder: '',
+        }
+      else
+        result << {
+          filelink: neofiles_file_path(f),
+          title: f.description.to_s,
+          #folder: '',
+        }
+      end
+    end
+
+    # returns JSON [{filelink: '/neofiles/serve-file/#{file.id}', title: '...', thumb: '/neo.../100x100'}, {...}, ...]
+    render json: result
+
+  rescue
+    render json: []
+  end
+
+
+
+  private
+
+  # Fetch common data from request.
+  def find_file_and_data
+    data = request[:neofiles]
+    raise ArgumentError.new I18n.t('neofiles.data_not_passed') if data.blank? || !(data.is_a? Hash)
+    raise ArgumentError.new I18n.t('neofiles.id_not_passed') unless data[:id].present?
+
+    [Neofiles::File.find(data[:id]), data]
+  end
+
+  # TODO: owner_type must be stored properly as in Mongoid polymorphic relation
+  def prepare_owner_type(type)
+    type.to_s.gsub(':', '/')
+  end
+end

data/app/controllers/neofiles/admin_test_controller.rb

@@ -0,0 +1,5 @@
+class Neofiles::AdminTestController < ApplicationController
+  def file_compact
+    @file_id = request[:id]
+  end
+end

data/app/controllers/neofiles/files_controller.rb

@@ -0,0 +1,28 @@
+# Controller that serves files from the database via single action #show.
+#
+# If the file requested is an image redirect to Neofiles::ImagesController is made.
+#
+class Neofiles::FilesController < ActionController::Metal
+
+  include ActionController::DataStreaming
+  include ActionController::Redirecting
+  include Rails.application.routes.url_helpers
+  include Neofiles::NotFound
+
+  def show
+    file = Neofiles::File.find params[:id]
+
+    if file.is_a? Neofiles::Image
+      redirect_to neofiles_image_path(params) and return
+    end
+
+    send_file_headers!({
+      filename: CGI::escape(file.filename),
+      type: file.content_type,
+      disposition: 'inline',
+    })
+
+    self.status = 200
+    self.response_body = file.data
+  end
+end

data/app/controllers/neofiles/images_controller.rb

@@ -0,0 +1,130 @@
+# Special controller for serving images from the database via single action #show.
+#
+class Neofiles::ImagesController < ActionController::Metal
+
+  class NotAdminException < Exception; end
+
+  include ActionController::DataStreaming
+  include ActionController::RackDelegation
+  include Neofiles::NotFound
+
+  CROP_MAX_WIDTH = Rails.application.config.neofiles.image_max_crop_width
+  CROP_MAX_HEIGHT = Rails.application.config.neofiles.image_max_crop_height
+
+  # Request parameters:
+  #
+  #   format  - resize image to no more than that size, example: '100x200'
+  #   crop    - if '1' and params[:format] is present, then cut image sides if its aspect ratio differs from
+  #             params[:format] (otherwise image aspect ration will be preserved)
+  #   quality - output JPEG quality, integer from 1 till 100 (forces JPEG output, otherwise image type is preserved)
+  #   nowm    - force returned image to not contain watermark - user must be admin or 403 Forbidden response is returned
+  #             @see #admin_or_die
+  #
+  # Maximum allowed format dimensions are set via Rails.application.config.neofiles.image_max_crop_width/height.
+  #
+  # Watermark is added automatically from /assets/images/neofiles/watermark.png or via proc
+  # Rails.application.config.neofiles.watermarker if present.
+  #
+  def show
+
+    # get image
+    image_file = Neofiles::Image.find params[:id]
+
+    # prepare headers
+    data = image_file.data
+    options = {
+      filename: CGI::escape(image_file.filename),
+      type: image_file.content_type || 'image/jpeg',
+      disposition: 'inline',
+    }
+
+    # is resizing needed?
+    watermark_image, watermark_width, watermark_height = data, image_file.width, image_file.height
+    if params[:format].present?
+
+      width, height = params[:format].split('x').map(&:to_i)
+      watermark_width, watermark_height = width, height
+      raise Mongoid::Errors::DocumentNotFound unless width.between?(1, CROP_MAX_WIDTH) and height.between?(1, CROP_MAX_HEIGHT)
+
+      quality = [[Neofiles::quality_requested(params), 100].min, 1].max if Neofiles::quality_requested?(params)
+      setting_quality = quality && options[:type] == 'image/jpeg'
+
+      image = MiniMagick::Image.read(data)
+
+      if Neofiles.crop_requested? params
+        # construct ImageMagick call:
+        # 1) resize to WxH, allow the result to be bigger on one side
+        # 2) allign resized to center
+        # 3) cut the extending parts
+        # 4) set quality if requested
+        image.combine_options do |c|
+          c.resize "#{width}x#{height}^"
+          c.gravity 'center'
+          c.extent "#{width}x#{height}"
+          c.quality "#{quality}" if setting_quality
+        end
+      else
+        # no cropping so just resize to fit in WxH, one side can be smaller than requested
+        if image_file.width > width || image_file.height > height
+          image.combine_options do |c|
+            c.resize "#{width}x#{height}"
+            c.quality "#{quality}" if setting_quality
+          end
+        else
+          setting_quality = false
+          watermark_width, watermark_height = image_file.width, image_file.height
+        end
+      end
+
+      # quality requested, but we didn't have a chance to set it before -> forcibly resave as JPEG
+      if quality && !setting_quality
+        image.format 'jpeg'
+        image.quality quality.to_s
+      end
+
+      # get image bytes and stuff
+      data = image.to_blob
+      watermark_image = image
+      options[:type] = image.mime_type
+    end
+
+    watermark_image = MiniMagick::Image.read watermark_image unless watermark_image.is_a? MiniMagick::Image
+
+    # set watermark
+    data = Rails.application.config.neofiles.watermarker.(
+      watermark_image,
+      no_watermark: nowm?(image_file),
+      watermark_width: watermark_width,
+      watermark_height: watermark_height
+    )
+
+    # stream image headers & bytes
+    send_file_headers! options
+    headers['Content-Length'] = data.length.to_s
+    self.status = 200
+    self.response_body = data
+
+  rescue NotAdminException
+    self.response_body = I18n.t 'neofiles.403_access_denied'
+    self.content_type = 'text/plain; charset=utf-8'
+    self.status = 403
+  end
+
+
+
+  private
+
+  # Are we serving without watermark? If yes and user is not admin raise special exception.
+  def nowm?(image_file)
+    image_file.no_wm? || (params[:nowm] == true && admin_or_die)
+  end
+
+  # Assert the user logged in is admin. @see Neofiles.is_admin?
+  def admin_or_die
+    if Neofiles.is_admin? self
+      true
+    else
+      raise NotAdminException
+    end
+  end
+end

data/app/helpers/neofiles/neofiles_helper.rb

@@ -0,0 +1,188 @@
+module Neofiles::NeofilesHelper
+
+  # Returns HTML IMG tag.
+  #
+  #   image_file      - ID, Neofiles::Image of Hash
+  #   width, height   - if both are passed, image will be no more that that size
+  #   resize_options  - crop: '1'/'0' (change or preserve aspect ration, @see Neofiles::ImagesController#show)
+  #   html_attrs      - hash of additional HTML attrs like ALT, TITLE etc.
+  #
+  def neofiles_img_tag(image_file, width = nil, height = nil, resize_options = {}, html_attrs = {})
+
+    resize_options ||= {} # в gem_neo_adv мы передаем nil
+
+    unless image_file.blank?
+      resize_options  = resize_options.merge(format: [width.to_i, height.to_i].join('x')) if width.to_i > 0 && height.to_i > 0
+      size_attrs      = resize_options.key?(:size_attrs) ? resize_options[:size_attrs] : true
+      image_or_id     = image_file.is_a?(Hash) ? image_file[:id] : image_file
+
+      html_attrs.try :symbolize_keys!
+      html_attrs[:src] = neofiles_image_url image_or_id, resize_options
+
+      html_attrs[:width], html_attrs[:height] = dimensions_after_resize(image_file, width.to_i, height.to_i, resize_options) if size_attrs
+    end
+
+    tag :img, html_attrs
+  end
+
+  # Same as neofiles_img_tag but returned IMG is wrapped into A tag (HTML link) pointing to the file original.
+  #
+  #   link_attrs - HTML attrs for A
+  #   img_attrs  - HTML attrs for IMG
+  #
+  # Other params are equivalent to neofiles_img_tag.
+  #
+  def neofiles_img_link(image_file, width = nil, height = nil, resize_options = {}, link_attrs = {}, img_attrs = {})
+    link_attrs[:href] = neofiles_image_url image_file unless link_attrs[:href]
+    neofiles_link(image_file, neofiles_img_tag(image_file, width, height, resize_options, img_attrs), link_attrs)
+  end
+
+  # Returns HTML A tag with link to the passed file.
+  #
+  #   file        - ID or Neofiles::File
+  #   tag_content - what the link content will be (default: file description of filename)
+  #   html_attrs  - additional HTML attrs like TITLE, TARGET etc.
+  #
+  def neofiles_link(file, tag_content = nil, html_attrs = {})
+    html_attrs[:href] = neofiles_file_url file unless html_attrs[:href]
+    content_tag(:a, tag_content.presence || file.description.presence || file.filename, html_attrs)
+  end
+
+  # Returns HTML OBJECT tag to embed SWF (Flash) files.
+  #
+  # For fully crossbrowser experience include swfobject.js on page, where SWF embedding is performed.
+  #
+  #   id        - DOM ID of the object
+  #   url       - path/url to SWF file
+  #   width     - resulting object's area width
+  #   height    - resulting object's area height
+  #   bgcolor   - if passed, the object's area will be colored in this CSS color
+  #   click_tag - clickTAG is a common name for Flash variable used to tell a movie clip to redirect viewer to a certain
+  #               URL after clicking (used in banners)
+  #   alt       - alternative HTML, in case if Flash is not available
+  #
+  def swf_embed(id, url, width, height, bgcolor, click_tag, alt = '')
+    url = h(url)
+    click_tag = h(click_tag)
+
+    result = <<HTML
+      <object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" width="#{width}" height="#{height}" id="#{id}">
+        <param name="movie" value="#{url}" />
+        <param name="bgcolor" value="#{bgcolor}" />
+        <param name="wmode" value="opaque" />
+        <param name="allowfullscreen" value="false" />
+        <param name="allowscriptaccess" value="never" />
+        <param name="quality" value="autohigh" />
+        <param name="flashvars" value="clickTAG=#{click_tag}" />
+
+        <!--[if !IE]>-->
+          <object type="application/x-shockwave-flash" data="#{url}" width="#{width}" height="#{height}">
+            <param name="bgcolor" value="#{bgcolor}" />
+            <param name="wmode" value="opaque" />
+            <param name="allowfullscreen" value="false" />
+            <param name="allowscriptaccess" value="never" />
+            <param name="quality" value="autohigh" />
+            <param name="flashvars" value="clickTAG=#{click_tag}" />
+        <!--<![endif]-->
+
+        #{alt}
+
+        <!--[if !IE]>-->
+          </object>
+        <!--<![endif]-->
+      </object>
+      <script type="text/javascript">
+        try { swfobject.registerObject("#{id}", "9.0.0"); } catch(e) {}
+		  </script>
+HTML
+    result.html_safe
+  end
+
+  # Returns CDN (Content Delivery Network) prefix - mainly a domain - if available.
+  #
+  # Array of CDNs is set via Rails.application.config.neofiles.cdns. If many exist, we choose one by taking remainder
+  # of dividing unix epoch creation time of the object, for which prefix is requested, by number of CDNs.
+  #
+  # If no CDN available, will take current domain via Rails helper root_url.
+  #
+  # First argument is considered Neofiles::File, ID or Hash. Other arguments are ignored.
+  #
+  # Returned prefix is of form 'http://doma.in/url/prefix'.
+  #
+  def neofiles_cdn_prefix(*args)
+    cdns = Rails.application.config.neofiles.cdns || []
+    cdns << root_url unless cdns.any?
+
+    if cdns.count > 1
+      some_file = args.first
+      if some_file.is_a? Neofiles::File
+        gen_time = some_file.id.generation_time.sec
+      elsif some_file.is_a?  Hash
+        tmp = some_file[:id] || some_file['id'] || some_file[:_id] || some_file['_id'] || ""
+        gen_time = BSON::ObjectId.legal?(tmp) ? BSON::ObjectId.from_string(tmp).generation_time.sec : Time.now.strftime('%U').to_i
+      elsif some_file.is_a? String
+        gen_time = BSON::ObjectId.legal?(some_file) ? BSON::ObjectId.from_string(some_file).generation_time.sec : Time.now.strftime('%U').to_i
+      else
+        gen_time = Time.now.strftime('%U').to_i
+      end
+
+      cdn = cdns[gen_time % cdns.count]
+    else
+      cdn = cdns.first
+    end
+
+    cdn.sub! /\/\z/, ''
+    cdn = 'http://' + cdn unless cdn =~ /\Ahttp[s]?:\/\//
+    cdn
+  end
+
+  # Override file URL generation to include CDN prefix.
+  def neofiles_file_url(*args)
+    neofiles_cdn_prefix(*args) + neofiles_file_path(*args)
+  end
+
+  # Override image URL generation to include CDN prefix.
+  def neofiles_image_url(*args)
+    neofiles_cdn_prefix(*args) + neofiles_image_path(*args)
+  end
+
+
+
+  private
+
+  # Calculate dimensions of an image after resize applied, according to rules in Neofiles::ImagesController#show.
+  #
+  # 1) if not cropping (resize_options[:crop] != '1'), but destination width and height are set, calculate resized
+  #    dimensions via external method (uses ImageMagick)
+  # 2) if cropping (resize_options[:crop] == '1'), resized dimensions are equal to the requested with & height
+  # 3) if not cropping and with & height not set, resized dimensions are equal to the input file width & height
+  # 4) if some variables are not available (like input file or height, if file ID is passed), returns nil
+  #
+  #   image_file      - Neofiles::Image, ID or Hash
+  #   width, height   - resulting width & height
+  #   resize_options  - {crop: '1'/'0'}
+  #
+  def dimensions_after_resize(image_file, width, height, resize_options)
+    we_need_resizing = width > 0 && height > 0
+
+    if image_file.is_a? Neofiles::Image
+      image_file_width = image_file.width
+      image_file_height = image_file.height
+    else
+      image_file_width = image_file[:width]
+      image_file_height = image_file[:height]
+    end
+
+    if (image_file_width.present? && image_file_height.present?) && (image_file_width > 0 && image_file_height > 0)
+      if we_need_resizing
+        ::Neofiles.resized_image_dimensions(image_file, width, height, resize_options)
+      else
+        [image_file_width, image_file_height]
+      end
+    elsif we_need_resizing and resize_options[:crop].present? and resize_options[:crop].to_s != '0'
+      [width, height]
+    else
+      [nil, nil]
+    end
+  end
+end