asset_host_core 2.0.0.beta

data/app/controllers/asset_host_core/public_controller.rb

@@ -0,0 +1,104 @@
+module AssetHostCore
+  class PublicController < AssetHostCore::ApplicationController
+
+    def home
+      render text: "", status: :ok, layout: false
+    end
+
+    #----------
+
+    # Given a fingerprint, id and style, determine whether the size has been cut.
+    # If so, redirect to the image file. If not, fire off a render process for
+    # the style.
+    def image
+      # if we have a cache key with aprint and style, assume we're good
+      # to just return that value
+      if img = Rails.cache.read("img:#{params[:id]}:#{params[:aprint]}:#{params[:style]}")
+        _send_file(img) and return
+      end
+
+      asset = Asset.find_by_id(params[:id])
+
+      if !asset
+        render_not_found and return
+      end
+
+      # Special case for "original"
+      # This isn't a "style", just someone has requested
+      # the raw image file.
+      if params[:aprint] == "original"
+        _send_file(asset.image.path) and return
+      end
+
+
+      # valid style?
+      output = Output.find_by_code(params[:style])
+
+      if !output
+        render_not_found and return
+      end
+
+      # do the fingerprints match? If not, redirect them to the correct URL
+      if asset.image_fingerprint && params[:aprint] != asset.image_fingerprint
+        redirect_to image_path(
+          :aprint   => asset.image_fingerprint,
+          :id       => asset.id,
+          :style    => params[:style]
+        ), status: :moved_permanently and return
+      end
+
+      # do we have a rendered output for this style?
+      asset_outputs = asset.outputs.where(output_id: output.id)
+
+      if asset_outputs.present?
+        if asset_outputs.first.fingerprint.present?
+          # Yes, return the image
+          # the file may still not have been written yet. loop a try to return it
+
+          5.times do
+            if asset.image.exists? output.code_sym
+              # got it.  cache and return
+
+              path = asset.image.path(output.code)
+              Rails.cache.write("img:#{asset.id}:#{asset.image_fingerprint}:#{output.code}",path)
+
+              _send_file(path) and return
+            end
+
+            # nope... sleep!
+            sleep 0.5
+          end
+
+          # crap.  totally failed.
+          redirect_to asset.image.url(output.code) and return
+        else
+
+          # we're in the middle of rendering
+          # sleep for 500ms to try and let the render complete, then try again
+          sleep 0.5
+          redirect_to asset.image.url(output.code) and return
+        end
+
+      else
+        # No, fire a render for the style
+
+        # create an AssetOutput with no fingerprint
+        asset.outputs.create(output_id: output.id, image_fingerprint: asset.image_fingerprint)
+
+        # and fire the queue
+        asset.image.enqueue_styles(output.code)
+
+        # now, sleep for 500ms to try and let the render complete, then try again
+        sleep 0.5
+        redirect_to asset.image.url(output.code) and return
+      end
+    end
+
+
+    private
+
+    def _send_file(file)
+      send_file file, type: "image/jpeg", disposition: 'inline'
+    end
+  end
+end

data/app/models/asset_host_core/api_user.rb

@@ -0,0 +1,44 @@
+require 'securerandom'
+
+module AssetHostCore
+  class ApiUser < ActiveRecord::Base
+    has_many :api_user_permissions
+    has_many :permissions, through: :api_user_permissions
+
+    validates_uniqueness_of :auth_token
+    validates :name, :email, presence: true
+
+    before_create :generate_auth_token, if: -> {
+      self.auth_token.blank?
+    }
+
+    attr_accessible :name, :email, :is_active, :permission_ids
+
+    class << self
+      def authenticate(auth_token)
+        if user = self.where(is_active: true, auth_token: auth_token).first
+          user.update_column(:last_authenticated, Time.now)
+          user
+        else
+          false
+        end
+      end
+    end
+
+
+    def may?(ability, resource)
+      !!self.permissions.find do |p|
+        p.resource == resource.to_s && p.ability == ability.to_s
+      end
+    end
+
+
+    def generate_auth_token
+      self.auth_token = SecureRandom.urlsafe_base64
+    end
+
+    def generate_auth_token!
+      generate_auth_token and save
+    end
+  end
+end

data/app/models/asset_host_core/api_user_permission.rb

@@ -0,0 +1,6 @@
+module AssetHostCore
+  class ApiUserPermission < ActiveRecord::Base
+    belongs_to :api_user
+    belongs_to :permission
+  end
+end

data/app/models/asset_host_core/asset.rb

@@ -0,0 +1,265 @@
+module AssetHostCore
+  class Asset < ActiveRecord::Base
+    @queue = :paperclip
+
+    VIA_UNKNOWN   = 0
+    VIA_FLICKR    = 1
+    VIA_LOCAL     = 2
+    VIA_UPLOAD    = 3
+
+    GRAVITY_OPTIONS = [
+      [ "Center (default)", "Center"    ],
+      [ "Top",              "North"     ],
+      [ "Bottom",           "South"     ],
+      [ "Left",             "West"      ],
+      [ "Right",            "East"      ],
+      [ "Top Left",         "NorthWest" ],
+      [ "Top Right",        "NorthEast" ],
+      [ "Bottom Left",      "SouthWest" ],
+      [ "Bottom Right",     "SouthEast" ]
+    ]
+
+
+    define_index do
+      indexes title
+      indexes caption
+      indexes notes
+      indexes owner
+      has created_at
+      has updated_at
+      where "is_hidden = 0"
+    end
+
+
+    scope :visible, -> { where(is_hidden: false) }
+
+    has_many :outputs, :class_name => "AssetOutput", :order => "created_at desc", :dependent => :destroy
+    belongs_to :native, :polymorphic => true
+
+    has_attached_file :image, Rails.application.config.assethost.paperclip_options.merge({
+      :styles       => proc { Output.paperclip_sizes },
+      :processors   => [:asset_thumbnail],
+      :interpolator => self
+    })
+
+    treat_as_image_asset :image
+
+    before_create :sync_exif_data
+
+    after_commit :publish_asset_update, :if => :persisted?
+    after_commit :publish_asset_delete, :on => :destroy
+
+
+    attr_accessible :title,
+      :caption,
+      :owner,
+      :url,
+      :notes,
+      :creator_id,
+      :image,
+      :image_taken,
+      :native,
+      :image_gravity
+
+
+    #----------
+
+    def size(code)
+      @_sizes ||= {}
+      @_sizes[ code ] ||= AssetSize.new(self, Output.where(code: code).first)
+    end
+
+    #----------
+
+    def as_json(options={})
+      {
+        :id                 => self.id,
+        :title              => self.title,
+        :caption            => self.caption,
+        :owner              => self.owner,
+        :size               => [self.image_width, self.image_height].join('x'),
+        :tags               => self.image.tags,
+        :notes              => self.notes,
+        :created_at         => self.created_at,
+        :taken_at           => self.image_taken || self.created_at,
+        :native             => self.native.try(:as_json),
+        :image_file_size    => self.image_file_size,
+
+        :url        => "http://#{Rails.application.config.assethost.server}#{AssetHostCore::Engine.mounted_path}/api/assets/#{self.id}/",
+        :sizes      => Output.paperclip_sizes.inject({}) { |h, (s,_)| h[s] = { width: self.image.width(s), height: self.image.height(s) }; h },
+        :urls       => Output.paperclip_sizes.inject({}) { |h, (s,_)| h[s] = self.image.url(s); h }
+      }
+    end
+
+    alias :json :as_json
+
+    #----------
+
+    def tag(style)
+      self.image.tag(style)
+    end
+
+    #----------
+
+    def isPortrait?
+      self.image_width < self.image_height
+    end
+
+    #----------
+
+    def url_domain
+      return nil if !self.url
+
+      domain = URI.parse(self.url).host
+      domain == 'www.flickr.com' ? 'Flickr' : domain
+    end
+
+    #----------
+
+    def output_by_style(style)
+      @s_outputs ||= self.outputs.inject({}) { |h,o| h[o.output.code] = o; h }
+      @s_outputs[style.to_s] || false
+    end
+
+    def rendered_outputs
+      @rendered ||= Output.paperclip_sizes.collect do |s|
+        ["#{s[0]} (#{self.image.width(s[0])}x#{self.image.height(s[0])})",s[0]]
+      end
+    end
+
+    #----------
+
+    def self.interpolate(pattern, attachment, style)
+      # we support:
+      # global:
+      #   :rails_root -- Rails.root
+      #
+      # style-based:
+      #   :style -- output code
+      #   :extension -- extension for Output
+      #
+      # asset-based:
+      #   :id -- asset id
+      #   :fingerprint -- image fingerprint
+      #
+      # output-based:
+      #   :sprint -- AssetOutput fingerprint
+      #
+      # first see what we've been passed as a style. could be string, symbol,
+      # Output or AssetOutput
+
+      asset   = attachment.instance
+      result  = pattern.clone
+
+      if style.respond_to?(:to_sym) && style.to_sym == :original
+        # special case...
+
+      elsif style.is_a? AssetOutput
+        ao      = style
+        output  = ao.output
+
+      elsif style.is_a? Output
+        output  = style
+        ao      = attachment.instance.outputs.where(output_id: output.id).first
+        return nil if !ao
+
+      else
+        output = Output.where(code: style).first
+        return nil if !output
+
+        ao = attachment.instance.outputs.where(output_id: output.id).first
+      end
+
+
+      # global rules
+      result.gsub!(":rails_root", Rails.root.to_s)
+
+      if asset
+        # asset-based rules
+        result.gsub!(":id", asset.id.to_s)
+        result.gsub!(":fingerprint", asset.image_fingerprint.to_s)
+      else
+        if pattern =~ /:(?:id|fingerprint)/
+          return false
+        end
+      end
+
+      if style.respond_to?(:to_sym) && style.to_sym == :original
+        # hardcoded handling for the original file
+        result.gsub!(":style", "original")
+        result.gsub!(":extension", File.extname(attachment.original_filename).gsub(/^\.+/, ""))
+        result.gsub!(":sprint","original")
+      else
+        if output
+          # style-based rules
+          result.gsub!(":style", output.code.to_s)
+          result.gsub!(":extension", output.extension)
+        else
+          if pattern =~ /:(?:style|extension)/
+            return false
+          end
+        end
+
+
+        if ao && ao.fingerprint
+          # output-based rules
+          result.gsub!(":sprint", ao.fingerprint)
+        else
+          result.gsub!(":sprint", "NOT_YET_RENDERED")
+        end
+      end
+
+      result
+    end
+
+    #----------
+    # syncs the exif to the corresponding Asset attributes
+    # We don't want to override anything that was set explicitly.
+    def sync_exif_data
+      self.title     = self.image_title       if self.title.blank?
+      self.caption   = self.image_description if self.caption.blank?
+      self.owner     = self.image_copyright   if self.owner.blank?
+    end
+
+    #----------
+
+    def method_missing(method, *args)
+      if output = Output.where(code: method.to_s).first
+        self.size(output.code)
+      else
+        super
+      end
+    end
+
+
+    #----------
+
+    private
+
+    def publish_asset_update
+      AssetHostCore::Engine.redis_publish(action: "UPDATE", id: self.id)
+      true
+    end
+
+    def publish_asset_delete
+      AssetHostCore::Engine.redis_publish(action: "DELETE", id: self.id)
+      true
+    end
+  end
+
+  #----------
+
+  class AssetSize
+    attr_accessor  :width, :height, :tag, :url, :asset, :output
+
+    def initialize(asset,output)
+      @asset  = asset
+      @output = output
+
+      @width    = @asset.image.width(output.code_sym)
+      @height   = @asset.image.height(output.code_sym)
+      @url      = @asset.image.url(output.code_sym)
+      @tag      = @asset.image.tag(output.code_sym)
+    end
+  end
+end

data/app/models/asset_host_core/asset_output.rb

@@ -0,0 +1,69 @@
+module AssetHostCore
+  class AssetOutput < ActiveRecord::Base
+    belongs_to :asset
+    belongs_to :output
+
+    before_save :delete_cache_and_img, if: -> { self.fingerprint_changed? || self.image_fingerprint_changed? }
+    before_destroy :delete_cache_and_img_and_fingerprint
+
+    after_commit :cache_img_path, if: -> { self.image_fingerprint.present? && self.fingerprint.present? }
+
+    scope :rendered, -> { where("fingerprint != ''") }
+
+
+    #----------
+
+    protected
+
+    # on save, check whether we should be creating or deleting caches
+    def delete_cache_and_img
+      # -- out with the old -- #
+
+      finger    = self.fingerprint_changed? ? self.fingerprint_was : self.fingerprint
+      imgfinger = self.image_fingerprint_changed? ? self.image_fingerprint_was : self.image_fingerprint
+
+      if finger && imgfinger
+        # -- delete our old cache -- #
+        resp = Rails.cache.delete("img:"+[self.asset.id,imgfinger,self.output.code].join(":"))
+
+        # -- delete our AssetOutput -- #
+        path = self.asset.image.path(self)
+
+        if path
+          # this path could have our current values in it. make sure we've
+          # got old fingerprints
+          path = path.gsub(self.asset.image_fingerprint,imgfinger).gsub(self.fingerprint,finger)
+
+          self.asset.image.delete_path(path)
+        end
+      end
+
+      true
+    end
+
+    #----------
+
+    # on destroy, we need to do the normal save deletes and also delete our fingerprint
+    def delete_cache_and_img_and_fingerprint
+      self.delete_cache_and_img
+
+      # why do we bother clearing our fingerprint if the AssetOutput itself
+      # is about to get deleted? If we don't, the after_commit handler will
+      # rewrite the same cache we just deleted.
+      self.fingerprint = ''
+    end
+
+    #----------
+
+    def cache_img_path
+      # -- in with the new -- #
+      path = self.asset.image.path(self)
+
+      if path && File.exists?(path)
+        Rails.cache.write("img:"+[self.asset.id,self.image_fingerprint,self.output.code].join(":"),path)
+      end
+
+      true
+    end
+  end
+end