Paperclip avatar update original while keeping old resized images - ruby-on-rails

I am using paperclip with s3 in a rails 4 app. It is working fine everywhere, but I have a specific use case that is requiring some special behavior.
I need to upload an image as an avatar, and have it resize to all the thumbnail sizes, but then I need to be able to update only the original image, while preserving all the thumbnail links.
Currently, I'm using a Proc to determine attachment sizes based on a class variable. This is causing image 1 to be uploaded and resized, then I am setting image 2 with no styles. I was hoping this would create all the thumbs, then replace the original. Unfortunately, it is updating the URLs for each size, but they are empty.
tl;dr - I need to have avatars resized, but I need to be able to update ONLY the original and leave the rest alone.
Controller
class StudentsController < ApplicationController
# POST /students/:id/avatar
def new_avatar
current_student.avatar = params[:avatar]
current_student.set_orginial_only TRUE
current_student.avatar = params[:avatar_orig]
if current_student.save
render json: current_student, serializer: StudentAvatarSerializer, status: 200
else
render json: ErrorSerializer.new(current_student), status: 400
end
end
# DELETE /students/:id/avatar
def destroy_avatar
current_student.avatar.destroy
if current_student.save
render json: {success: true}, status: 200
else
render json: ErrorSerializer.new(current_student), status: 400
end
end
private
# find student by id and cache
def current_student
#student ||= Student.find(params[:id])
end
end
Model
class Student < ActiveRecord::Base
##orginial_only = FALSE
def set_orginial_only value
##orginial_only = value
end
# Paperclip attachements
has_attached_file :avatar, :styles => Proc.new { |clip| clip.instance.attachment_sizes },
path: "/:class/:attachment/:id/:content_type_extension/:style/:filename",
:default_url => "/images/:style/missing.png"
validates_attachment_content_type :avatar, :content_type => /image/
validates_attachment_size :avatar, :in => 0..2.megabytes
def attachment_sizes
if ##orginial_only
styles = {}
else
styles = {
tiny: '50x50#',
tiny_retina: '100x100#',
small: '60x60#',
small_retina: '120x120#',
medium: '108x108#',
medium_retina: '216x216#',
large: '205x205#',
large_retina: '410x410#'
}
end
styles
end
end
Is there a way to only update the original image while keeping all my thumbs?

Solution: I ended up just using paperclip for the resized image, and aws-sdk to manually replace the original image in the paperclip assigned path.

Related

How can I get complete absolute URL for paperclip attachment?

I'm working on JSON data, I want to display complete image url with localhost name
but I'm getting half item_image_url..
"item_image_url": "/system/images/item_images/000/000/001/original/images_%284%29.jpeg?1545807832"
{
"id": 1,
"title": "Pasta",
"filename": "Burger.",
"item_image_file_name": "images_(4).jpeg",
"item_image_content_type": "image/jpeg",
"item_image_file_size": 12944,
"item_image_updated_at": "2018-12-26T07:03:52.284Z",
"updated_at": "2018-12-26T07:03:52.355Z",
"created_at": "2018-12-26T07:03:52.355Z",
"item_image_url": "/system/images/item_images/000/000/001/original/images_%284%29.jpeg?1545807832"
}
how can i get this complete ulr like this
http://localhost:3000/system/images/item_images/000/000/001/original/images_%284%29.jpeg?1545807832
in controller
class V1::ImagesController < ApplicationController
skip_before_action :verify_authenticity_token
def index
#images = Image.all
render :json => #images.to_json(:methods => [:item_image_url])
end
def show
image = Image.find(params[:id])
render json: {status: 'success', data:image},status: :ok
end
def create
image = Image.new(image_params)
if image.save
render json: {status: 'success', data:image},status: :ok
else
render json: {status: 'error', message:'image not saved', data:image.errors},status: :unprocessable_entity
end
end
def destroy
image = Image.find(params[:id])
image.destory
render json: {status: 'success', data:image},status: :ok
end
private def image_params
params.permit(:item_image_url,:title,:filename)
end
end
in model
class Image < ApplicationRecord
has_attached_file :item_image, styles: { medium: "300x300>", thumb: "100x100>" }, default_url: "/images/:style/missing.png"
validates_attachment_content_type :item_image, content_type: /\Aimage\/.*\z/
def item_image_url
self.item_image.url(:original)
end
end
Pleas need help..
Define constant APP_URL in config/development.rb as,
APP_URL = 'http://localhost:3000'
For test.rb & production.rb, You have to set as per your domain environment set up.
And get it as,
def item_image_abs_url
"#{APP_URL}#{item_image.url(:original)}"
end
Check following url you get in rails console,
image = Image.first
image.item_image.url
According to this github issue, it is cleaner to use ActionController::Base.asset_host so it would result the helper:
def add_host_prefix(url)
URI.join(ActionController::Base.asset_host, url)
end
This supposes you have the following in every /config/environments/environment.rb file:
Appname::Application.configure do
# ....
config.action_controller.asset_host = 'http://localhost:3000' # Locally
# ....
end
Hope it helps
As per the description mentioned in the post it seems like you haven't specified the asset host in specific environment file.
Appropriate way as defined in the above mentioned answer as well is to define asset hosts in the relevant config/environments/{environment} file:
where the environment mentioned in the above line signifies development.rb, production.rb and test.rb(others as well if you have defined a custom environment)
onfig.action_controller.asset_host = "http://localhost:3000"
If you want to access it in views then use below mentioned code:
asset_url(model.attachment.url(:style))
If you want to access it rails console then use below mentioned code
helper.asset_url(model.attachment.url(:style))
If you want to use it in a model then use below mentioned code:
ApplicationController.helpers.asset_url(model.attachment.url(:style))
Hope it helps!!

Handling images in rails 5

I'm developing a api applicacion with Rails 5. From client side I have an Anuglar app.
I have the following requirements to do:
Async upload of images. (Note that implies that the images have no attached to a model at the first time).
The model to be create can have N images attached.
For each uploaded image, create M specified thumbnails. (Note that also that thumbnails should be attached to the model.)
I have read about CarrierWave and paperclip but I don't found how can I do all of these requirements.
I will really appreciate any suggestion, lib, gem, etc that covers all of these requirements.
I have implemented something similar with CarrierWave gem. Assuming you want images attached to a model Post.
in the model:
class Post < ActiveRecord::Base
has_many :photos, inverse_of: :post
end
you can then have a photo model:
class Photo < ActiveRecord::Base
belongs_to :post
mount_uploader :post_image, PostImageUploader
end
Then you can add this to app/uploaders/post_image_uploader.rb
class PostImageUploader < CarrierWave::Uploader::Base
# Create different versions of your uploaded files:
version :standard do
process resize_to_fit: [800, 800]
end
version :thumb do
process resize_to_fit: [100, 100]
end
end
since you are creating the images via an api, you'll have to convert the image to Base64 string and send as a param. on this example the base64 string is in param [:photo][:photo_data] before sending it to the server. in photos_controller.rb have this:
def create
#photo = Photo.new(photo_params)
#photo.post_image = decode_photo_data(params[:photo][:photo_data])
if #photo.save
render json: #photo, status: :created, location: #photo
else
render json: #photo.errors, status: :unprocessable_entity
end
end
#decode base64 data to an jpg image:
def decode_photo_data(photo_data)
data = StringIO.new(Base64.decode64(photo_data))
data.class.class_eval { attr_accessor :original_filename, :content_type }
data.original_filename = "upload.jpg"
data.content_type = "image/jpg"
# return decoded data
data
end
def photo_params
params.require(:photo).permit(:caption, :post_id)
end
With this, when you make a post request to your create photo api endpoint with a body like this
{"photo": {"caption": "an image", "post_id": 1, "photo_data":<your image base64 string>}}
it will create a photo with both a standard and a thumb version for the post with an id of 1.

Domain name missing in image paperclip in to_json rails 4

I have the model that uses paperclip like this
has_attached_file :image, styles: { :medium => "50x50>" }
validates_attachment_content_type :image, content_type: /\Aimage\/.*\Z/
def image_url
image.url(:medium)
end
I need it Json, So in my controller,
respond_to do |format|
format.json { render json: #celebrity.to_json(:methods => [:image_url])}
end
And the result is
"image_url":"/system/celebrities/images/000/000/003/medium/Designed___developed_by_wd_ApS.png?1430926991"
but, I need to include the domain name, localhost:3000 ,
So what I have to do here
Try this.
Create module:
module WithDomain
def domain
#domain
end
def domain=(val)
#domain = val
end
def domain?
#domain.present?
end
end
Change you model accordingly:
class Celebtiry < ActiveRecord::Base
include WithDomain
# existing staff
def image_url
if domain?
URI.join(domain, image.url(:medium)).to_s
else
image.url(:medium)
end
end
end
and in your controller:
respond_to do |format|
format.json {
#celebrity.domain = request.base_url
render json: #celebrity.to_json(:methods => [:image_url])
}
end
Solution 1: (with existing code)
You can use asset_url from ActionView::Helpers::AssetUrlHelper module which will give you the absolute url of your image. Just include ActionView::Helpers::AssetUrlHelper this in your model so that asset_url becomes available inside your model.
So, your method inside the model would be:
include ActionView::Helpers::AssetUrlHelper
def image_url
asset_url(image.url(:medium))
end
This is the easiest solution for you with your current code.
Solution 2: (inside the controller)
In your controller request is available, so you can do:
URI.join(request.url, #celebrity.image.url(:medium))
which will give you the absolute url of the image. This will be an URI object, which can be converted to a String with .to_s method.
Here is the issue from paperclip from where this solution is derived. Hope this helps.

Ruby on Rails - Paperclip and dynamic parameters

I'm writing some image upload code for Ruby on Rails with Paperclip, and I've got a working solution but it's very hacky so I'd really appreciate advice on how to better implement it. I have an 'Asset' class containing information about the uploaded images including the Paperclip attachment, and a 'Generator' class that encapsulates sizing information. Each 'Project' has multiple assets and generators; all Assets should be resized according to the sizes specified by each generator; each Project therefore has a certain set of sizes that all of its assets should have.
Generator model:
class Generator < ActiveRecord::Base
attr_accessible :height, :width
belongs_to :project
def sym
"#{self.width}x#{self.height}".to_sym
end
end
Asset model:
class Asset < ActiveRecord::Base
attr_accessible :filename,
:image # etc.
attr_accessor :generators
has_attached_file :image,
:styles => lambda { |a| a.instance.styles }
belongs_to :project
# this is utterly horrendous
def styles
s = {}
if #generators == nil
#generators = self.project.generators
end
#generators.each do |g|
s[g.sym] = "#{g.width}x#{g.height}"
end
s
end
end
Asset controller create method:
def create
#project = Project.find(params[:project_id])
#asset = Asset.new
#asset.generators = #project.generators
#asset.update_attributes(params[:asset])
#asset.project = #project
#asset.uploaded_by = current_user
respond_to do |format|
if #asset.save_(current_user)
#project.last_asset = #asset
#project.save
format.html { redirect_to project_asset_url(#asset.project, #asset), notice: 'Asset was successfully created.' }
format.json { render json: #asset, status: :created, location: #asset }
else
format.html { render action: "new" }
format.json { render json: #asset.errors, status: :unprocessable_entity }
end
end
end
The problem I am having is a chicken-egg issue: the newly created Asset doesn't know which generators (size specifications) to use until after it's been instantiated properly. I tried using #project.assets.build, but then the Paperclip code is still executed before the Asset gets its project association set and nils out on me.
The 'if #generators == nil' hack is so the update method will work without further hacking in the controller.
All in all it feels pretty bad. Can anyone suggest how to write this in a more sensible way, or even an approach to take for this kind of thing?
Thanks in advance! :)
I ran into the same Paperclip chicken/egg issue on a project trying to use dynamic styles based on the associated model with a polymorphic relationship. I've adapted my solution to your existing code. An explanation follows:
class Asset < ActiveRecord::Base
attr_accessible :image, :deferred_image
attr_writer :deferred_image
has_attached_file :image,
:styles => lambda { |a| a.instance.styles }
belongs_to :project
after_save :assign_deferred_image
def styles
project.generators.each_with_object({}) { |g, hsh| hsh[g.sym] = "#{g.width}x#{g.height}" }
end
private
def assign_deferred_image
if #deferred_image
self.image = #deferred_image
#deferred_image = nil
save!
end
end
end
Basically, to get around the issue of Paperclip trying to retrieve the dynamic styles before the project relation information has been propagated, you can assign all of the image attributes to a non-Paperclip attribute (in this instance, I have name it deferred_image). The after_save hook assigns the value of #deferred_image to self.image, which kicks off all the Paperclip jazz.
Your controller becomes:
# AssetsController
def create
#project = Project.find(params[:project_id])
#asset = #project.assets.build(params[:asset])
#asset.uploaded_by = current_user
respond_to do |format|
# all this is unrelated and can stay the same
end
end
And the view:
<%= form_for #asset do |f| %>
<%# other asset attributes %>
<%= f.label :deferred_upload %>
<%= f.file_field :deferred_upload %>
<%= f.submit %>
<% end %>
This solution also allows using accepts_nested_attributes for the assets relation in the Project model (which is currently how I'm using it - to upload assets as part of creating/editing a Project).
There are some downsides to this approach (ex. validating the Paperclip image in relation to the validity of the Asset instance gets tricky), but it's the best I could come up with short of monkey patching Paperclip to somehow defer execution of the style method until after the association information had been populated.
I'll be keeping an eye on this question to see if anyone has a better solution to this problem!
At the very least, if you choose to keep using your same solution, you can make the following stylistic improvement to your Asset#styles method:
def styles
(#generators || project.generators).each_with_object({}) { |g, hsh| hsh[g.sym] = "#{g.width}x#{g.height}" }
end
Does the exact same thing as your existing method, but more succinctly.
While I really like Cade's solution, just a suggestion. It seems like the 'styles' belong to a project...so why aren't you calculating the generators there?
For example:
class Asset < ActiveRecord::Base
attr_accessible :filename,
:image # etc.
attr_accessor :generators
has_attached_file :image,
:styles => lambda { |a| a.instance.project.styles }
end
class Project < ActiveRecord::Base
....
def styles
#generators ||= self.generators.inject {} do |hash, g|
hash[g.sym] = "#{g.width}x#{g.height}"
end
end
end
EDIT: Try changing your controller to (assuming the project has many assets):
def create
#project = Project.find(params[:project_id])
#asset = #project.assets.new
#asset.generators = #project.generators
#asset.update_attributes(params[:asset])
#asset.uploaded_by = current_user
end
I've just solved a similar problem that I had.
In my "styles" lambda I am returning a different style depending on the value of a "category" attribute. The problem though is that Image.new(attrs), and image.update_attributes(attrs) doesn't set the attributes in a predictable order, and thus I can't be guaranteed that image.category will have a value before my styles lambda is called. My solution was to override attributes=() in my Image model as follows:
class Image
...
has_attached_file :image, :styles => my_lambda, ...
...
def attributes=(new_attributes, guard_protected_attributes = true)
return unless new_attributes.is_a?(Hash)
if new_attributes.key?("image")
only_attached_file = {
"image" => new_attributes["image"]
}
without_attached_file = new_attributes
without_attached_file.delete("image")
# set the non-paperclip attributes first
super(without_attached_file, guard_protected_attributes)
# set the paperclip attribute(s) after
super(only_attached_file, guard_protected_attributes)
else
super(new_attributes, guard_protected_attributes)
end
end
...
end
This ensures that the paperclip attribute is set after the other attributes and can thus use them in a :style lambda.
It clearly won't help in situations where the paperclip attribute is "manually" set. However in those circumstances you can help yourself by specifying a sensible order. In my case I could write:
image = Image.new
image.category = "some category"
image.image = File.open("/somefile") # styles lambda can use the "category" attribute
image.save!
(Paperclip 2.7.4, rails 3, ruby 1.8.7)

Rails 3 Paperclip Uploadify : Save Uploaded Object Attachments Before Saving Object

I am working with Rails 3 and Paperclip to attach uploaded files to several object types using a polymorphic association. I have created an Asset model and an inherited Image model (will be adding others, like Video and Documents later) as follows:
# app/models/asset.rb
class Asset < ActiveRecord::Base
# Nothing here yet
end
# app/models/image.rb
class Image < Asset
belongs_to :assetable, :polymorphic => true
has_attached_file :file, {
:styles => {
:small => { :geometry => '23x23#', :format => 'png' },
:medium => { :geometry => '100x100#', :format => 'png' } }
}.merge(PAPERCLIP_STORAGE_OPTIONS).merge(PAPERCLIP_STORAGE_OPTIONS_ASSET_IMAGE) # Variables sent in environments to direct uploads to filesystem storage in development.rb and S3 in production.rb
validates_attachment_presence :file
validates_attachment_size :file, :less_than => 5.megabytes
end
I then have another object type, Unit, which I am attaching multiple images to as follows:
# app/models/unit.rb
class Unit < ActiveRecord::Base
# ...
has_many :images, :as => :assetable, :dependent => :destroy
accepts_nested_attributes_for :images
end
# app/controllers/units_controller.rb
class UnitsController < ApplicationController
# ...
def new
#unit = current_user.units.new
# ...
#unit.images.build
end
def create
#unit = current_user.units.new(params[:unit])
# ...
respond_to do |format|
if #unit.save
format.html { redirect_to(#unit, :notice => 'Unit creation successful!') }
else
format.html { render :action => "new" }
end
end
end
def show
#unit = current_user.units.find(params[:id])
#unit_images = #unit.images
# ...
end
def edit
#unit = current_user.units.find(params[:id])
# ...
#unit.images.build
end
def update
#unit = current_user.units.find(params[:id], :readonly => false)
respond_to do |format|
if #unit.update_attributes(params[:unit])
format.html { redirect_to(#unit, :notice => 'Unit was successfully updated.') }
else
format.html { render :action => "edit" }
end
end
end
def destroy
#unit = current_user.units.find(params[:id])
#unit.destroy
respond_to do |format|
format.html { redirect_to(units_url) }
end
end
end
# app/views/units/_form.html.haml
.field # Display already uploaded images
= f.fields_for :images do |assets|
- unless assets.object.new_record?
= link_to(image_tag(assets.object.file.url(:medium)), assets.object.file.url(:original))
.field # Display field to add new image
= f.fields_for :images do |assets|
- if assets.object.new_record?
= assets.label :images, "Image File"
= assets.file_field :file, :class => 'uploadify'
Using these settings I am able to upload images one at at time, per display of the form.
The issues start when I try to integrate Uploadify to add multi file uploading/previewing. I have satisfied all the Uploadify dependancies, but in order to save the images associated with the Unit model I need to somehow include a reverence to the unit_id so that the polymorphic association can be made properly. Below is my current Uploadify code:
%script
$(document).ready(function() {
$('.uploadify').uploadify({
uploader : '/uploadify/uploadify.swf',
cancelImg : '/uploadify/cancel.png',
auto : true,
multi : true,
script : '#{units_path}',
scriptData : {
"#{key = Rails.application.config.session_options[:key]}" : "#{cookies[key]}",
"#{request_forgery_protection_token}" : "#{form_authenticity_token}",
}
});
});
So while I can easily upload with Paperclip along, Uploadify will not work. Any help would be much appreciated. Thank you in advance.
UPDATE:
After doing more research I ran across this comment to a similar issue: Rails3, S3, Paperclip Attachment as it's own model?. Any thoughts on whether or not that would work in this situation? Is there an easy way of determining the unit.id from the /new method and passing it to the Uploadify-created Asset?
We had solved a very similar problem once by saving the model right away when loading the form in a draft state (using state machine). Like this the model is available when you're trying to attach the files you're uploading and once you're submitting the rest of the form, you're basically just updating the model which changes it's state to e.g. published. It's a little work to update the controllers etc., but it did the trick.

Resources