Background
I retrieved a pdf in binary form from an API call:
base_64_binary_data = #response_label[:generate_label_response][:response_shipments][:response_shipment][:labels][:label][:content]
#pdf_file = File.open('label.pdf', 'wb') do |file|
content = Base64.decode64 base_64_binary_data
file << content
end
The above code results in a file that I can look up and is the crystal clear image I need.
Issue
I need to place this image inside a view in order to function as a label on an invoice.
The following seems to be leading to a fine solution:
#pdf = MiniMagick::Image.new(#pdf_file.path)
#pdf.pages.first.write("preview.png")
It fails on the second line.
MiniMagick::Error
`identify label.pdf` failed with error:
...2nd line...
I'd like to work to something like this functioning:
pdf = MiniMagick::Image.open "doc.pdf"
MiniMagick::Tool::Convert.new do |convert|
convert.background "white"
convert.flatten
convert.density 150
convert.quality 100
convert << pdf.pages.first.path
convert << "png8:preview.png"
end
Related
I'm struggling to attach a Vips:Image object to an ActiveStorage object.
I use Vips to compress a PNG image. I'm then looking to save this compressed PNG version into a second ActiveStorage attachment. The code is failing when attempting to attach. All I get is: Process finished with exit code -1073741819 (0xC0000005)
# compress the image and save the compressed version of the file as a PNG
# both img and img_to_compress are active storage attachments
def compress_charlie(img, img_to_compress)
# load the image as a Vips Image object
vips_img = Vips::Image.new_from_buffer (URI.open(img.url) { |f| f.read }), ''
# do compression, etc ... not bothering to show this code as it has no impact on the issue I have
# save the compressed png
img_to_compress.attach(
io: StringIO.new(vips_img .write_to_buffer('.png')),
filename: img.filename
)
end
Any help is appreciated, Charlie
Ruby 3.1
Rails 7.0.1
You're decompressing and recompressing twice. How about (untested):
def convert_to_png(img, img_to_compress)
# load the image as a Vips Image object
vips_img = Vips::Image.new_from_buffer (URI.open(img.url) { |f| f.read }), ''
# save as a PNG string
png = StringIO.new(vips_img.write_to_buffer('.png')),
img_to_compress.attach(io: png, filename: img.filename)
end
pngsave_buffer gives you a String with binary encoding, you don't need to save a second time. Try this test program:
require "vips"
x = Vips::Image.new_from_file ARGV[0]
y = x.pngsave_buffer
puts "y.class = #{y.class}"
I see:
$ ./pngsave.rb ~/pics/k2.jpg
y.class = String
If the image is already a PNG you'll be wasting a lot of time, of course. You could add something to detect the format and skip the conversion.
The way I'm working right now is I'm generating multiple pdf files and sending them all one at a time for the user to download, but the problem is sometimes they end up with too many files.
How can I merge all pdfs in a single file before sending them to the user?
I use combine_pdf gem.
To combine PDF files:
pdf = CombinePDF.new
pdf << CombinePDF.load("file1.pdf") # one way to combine, very fast.
pdf << CombinePDF.load("file2.pdf")
pdf.save "combined.pdf"
You can also parse PDF files from memory. Loading from the memory is
especially effective for importing PDF data recieved through the
internet or from a different authoring library such as Prawn:
pdf_data = prawn_pdf_document.render # Import PDF data from Prawn
pdf = CombinePDF.parse(pdf_data)
If you want to use some tool like PDFTk or CombinePDF, all you should need to do is prerender your individual PDFs by using something like:
pdf1 = render_to_string(pdf: 'pdf1', template: 'pdf1')
pdf2 = render_to_string(pdf: 'pdf2', template: 'pdf2')
or
pdf1 = WickedPdf.new.pdf_from_string(some_html_string)
pdf2 = WickedPdf.new.pdf_from_string(another_html_string)
If those tools won't take a PDF as a string, you may need to write them to tempfiles first.
If you don't want to introduce another dependency to merge things, wkhtmltopdf can take multiple pdf files (or urls), and render them all as one pdf with a command similar to this:
wkhtmltopdf tmp/tempfile1.html tmp/tempfile2.html tmp/output.pdf
Knowing this, you could prerender your templates, with layouts and everything, out to HTML strings, then pass them into wkhtmltopdf something like this:
# app/models/concerns/multipage_pdf_renderer.rb
require 'open3'
class MultipagePdfRenderer
def self.combine(documents)
outfile = WickedPdfTempfile.new('multipage_pdf_renderer.pdf')
tempfiles = documents.each_with_index.map do |doc, index|
file = WickedPdfTempfile.new("multipage_pdf_doc_#{index}.html")
file.binmode
file.write(doc)
file.rewind
file
end
filepaths = tempfiles.map{ |tf| tf.path.to_s }
binary = WickedPdf.new.send(:find_wkhtmltopdf_binary_path)
command = [binary, '-q']
filepaths.each { |fp| command << fp }
command << outfile.path.to_s
err = Open3.popen3(*command) do |stdin, stdout, stderr|
stderr.read
end
raise "Problem generating multipage pdf: #{err}" if err.present?
return outfile.read
ensure
tempfiles.each(&:close!)
end
end
And call in your controller something like this:
def fancy_report
respond_to do |format|
format.pdf do
doc1 = render_to_string(template: 'pages/_page1')
doc2 = render_to_string(template: 'pages/_page2')
pdf_file = MultipagePdfRenderer.combine([doc1, doc2])
send_data pdf_file, type: 'application/pdf', disposition: 'inline'
end
end
end
However, this only covers the simplest of cases, you'll have to do the work of rendering the headers and footers if you need them, parsing (or adding) any options you might need.
This solution originally came from https://github.com/mileszs/wicked_pdf/issues/339 so it may be helpful to look there for more details on this strategy.
Try PDFtk. In my opinon, it is the best library for editing PDF files, and there are some gems that wraps it for access from Ruby.
When using a web service I receive a string that looks like this:
JVBERi0xLjIgDQoxIDAgb2JqDQo8PA0KL1R5cGUgL0NhdGFsb2cNCi9QYWdlcyAzIDAgUg0KL1BhZ2VNb2RlIC9Vc2VOb25lDQovUGFnZUxheW91dCAvU2luZ2xlUGFnZQ0KPj4NCmVuZG9iag0KMiAwIG9iag0KPDwNCi9Qcm9kdWNlciAoUGRmQ3JlYXRvciB2ZXJzaW9uIDEuMCkNCi9BdXRob3IgKCkNCi9DcmVhdGlvbkRhdGUgKEQ6MjAxNzA4MjUxMTM0MDApDQovQ3JlYXRvciAoKQ0KL0tleXdvcmRzICgpDQovU3ViamVjdCAoKQ0KL1RpdGxlICgpDQovTW9kRGF0ZSAoRDoyMDE3MDgyNTExMzQwMCkNCj4+DQplbmRvYmoNCjMgMCBvYmoNCjw8DQovVHlwZSAvUGFnZXMNCi9LaWRzIFs0IDAgUiBdDQovQ291bnQgMQ0KPj4NCmVuZG9iag0KNCAwIG9iag0KPDwNCi9UeXBlIC9QYWdlDQovUGFyZW50IDMgMCBSDQovTWVkaWFCb3ggWzAgMCA0MjUgMjkyIF0NCi9SZXNvdXJjZXMgPDwNCi9Gb250IDw8DQovRjAgNiAwIFINCi9GMSA4IDAgUg0KPj4NCi9YT2JqZWN0IDw8DQovMCA3IDAgUg0KPj4NCi9Qcm9jU2V0IFsvUERGIC9UZXh0IC9JbWFnZUMgXQ0KPj4NCi9Db250ZW50cyA1IDAgUg0KPj4NCmVuZG9iag0KNSAwIG9iag0KPDwNCi9MZW5ndGggNDE4DQovRmlsdGVyIFsvRmxhdGVEZWNvZGUgXQ0KPj4NCnN0cmVhbQ0KeF6lVMtu2zAQvPMr9tjmwHCXD1G9uXkiCBI3VtND0YNj0akL20ppGQX69V1Slp2iRWI4ECCMRHJmd2ek43MFpSwsVFORMKqEFKQrPoqPlUCpFD89u3dvtHe820g+uhDvEE6a+bx5D9UPcVbtCBAl8Y7rl5k8kKYN0+D+omf5+k1BLbQpgbyFhTBoMpp3yDlGeTWjrui7C4HwS6z264EPUtErn8fxcrJtoRMnVQBRmcV5L6Mkzp2jZ5RWO7QVV3uLI4tjP78jPTo9uz+xxnhntTNH/Qx+CnJWKpObs066EpyXSgNZaQ1MFuJYwWkjPmX7/F/ula8MPg+RJGUHB9PfYVmH+OEfD1+jyTNi/zqe4e2ournuSf6TqX0ikSoz5SYRw2bV7hi32dyXRxcbntEsztarOoYwBUMwOCisqTJyG0ZCTV8quGyaaV038ekgRuJvjtC/vdlMpPrahqENEeoAd+sZo4NLw5KDlp29nddh+bCOjyGu2jget4C62BmNgJyAZz8P1Ongi59+Khk9Ss4tC2hb6NEVfG5jmHxve+Y/1ub6WwplbmRzdHJlYW0NCmVuZG9iag0KNiAwIG9iag0KPDwNCi9UeXBlIC9Gb250DQovU3VidHlwZSAvVHlwZTENCi9GaXJzdENoYXIgMzINCi9MYXN0Q2hhciAyNTUNCi9CYXNlRm9udCAvSGVsdmV0aWNhDQovRW5jb2RpbmcgPDwNCi9UeXBlIC9FbmNvZGluZw0KL0RpZmZlcmVuY2VzIFszMiAvc3BhY2UgMTk2IC9BZGllcmVzaXMgMjE0IC9PZGllcmVzaXMgMjIwIC9VZGllcmVzaXMgMjI4IC9hZGllcmVzaXMgMjQ2IC9vZGllcmVzaXMgMjUyIC91ZGllcmVzaXMgMjIzIC9nZXJtYW5kYmxzIDE5MiAvQWdyYXZlIDE5NCAvQWNpcmN1bWZsZXggMTk4IC9BRSAxOTkgL0NjZWRpbGxhIDIwMCAvRWdyYXZlIDIwMSAvRWFjdXRlIDIwMiAvRWNpcmN1bWZsZXggMjAzIC9FZGllcmVzaXMgMjA2IC9JY2lyY3VtZmxleCAyMDcgL0lkaWVyZXNpcyAyMTIgL09jaXJjdW1mbGV4IDE0MCAvT0UgMjE3IC9VZ3JhdmUgMjE5IC9VY2lyY3VtZmxleCAxNTkgL1lkaWVyZXNpcyAyMjQgL2FncmF2ZSAyMjYgL2FjaXJjdW1mbGV4IDIzMCAvYWUgMjMxIC9jY2VkaWxsYSAyMzIgL2VncmF2ZSAyMzMgL2VhY3V0ZSAyMzQgL2VjaXJjdW1mbGV4IDIzNSAvZWRpZXJlc2lzIDIzOCAvaWNpcmN1bWZsZXggMjM5IC9pZGllcmVzaXMgMjQ0IC9vY2lyY3VtZmxleCAxNTYgL29lIDI0OSAvdWdyYXZlIDI1MSAvdWNpcmN1bWZsZXggMjU1IC95ZGllcmVzaXMgMTk3IC9BcmluZyAyMTYgL09zbGFzaCAxOTMgL0FhY3V0ZSAyMDUgL0lhY3V0ZSAyMTggL1VhY3V0ZSAyMjEgL1lhY3V0ZSAyMjkgL2FyaW5nIDI0OCAvb3NsYXNoIDIyNSAvYWFjdXRlIDIzNyAvaWFjdXRlIDI1MCAvdWFjdXRlIDI1MyAveWFjdXRlIDIxMCAvT2dyYXZlIDI0MiAvb2dyYXZlIDIwNCAvSWdyYXZlIDIzNiAvaWdyYXZlIDE5NSAvQXRpbGRlIDIxMyAvT3RpbGRlIDIyNyAvYXRpbGRlIDI0NSAvb3RpbGRlIDIyMiAvVGhvcm4gMjU0IC90aG9ybiAyMDkgL050aWxkZSAyNDEgL250aWxkZSAxMzggL1NjYXJvbiAxNTQgL3NjYXJvbiAyNDMgL29hY3V0ZSAyMTEgL09hY3V0ZSBdDQo+Pg0KL1dpZHRocyBbMjc4IDI3OCAzNTUgNTU2IDU1NiA4ODkgNjY3IDE5MSAzMzMgMzMzIDM4OSA1ODQgMjc4IDMzMyAyNzggMjc4IDU1NiA1NTYgNTU2IDU1NiA1NTYgNTU2IDU1NiA1NTYgNTU2IDU1NiAyNzggMjc4IDU4NCA1ODQgNTg0IDU1NiAxMDE1IDY2NyA2NjcgNzIyIDcyMiA2NjcgNjExIDc3OCA3MjIgMjc4IDUwMCA2NjcgNTU2IDgzMyA3MjIgNzc4IDY2NyA3NzggNzIyIDY2NyA2MTEgNzIyIDY2NyA5NDQgNjY3IDY2NyA2MTEgMjc4IDI3OCAyNzggNDY5IDU1NiAzMzMgNTU2IDU1NiA1MDAgNTU2IDU1NiAyNzggNTU2IDU1NiAyMjIgMjIyIDUwMCAyMjIgODMzIDU1NiA1NTYgNTU2IDU1NiAzMzMgNTAwIDI3OCA1NTYgNTAwIDcyMiA1MDAgNTAwIDUwMCAzMzQgMjYwIDMzNCA1ODQgMCA1NTYgMCAyMjIgNTU2IDMzMyAxMDAwIDU1NiA1NTYgMzMzIDEwMDAgNjY3IDMzMyAxMDAwIDAgNjExIDAgMCAyMjIgMjIyIDMzMyAzMzMgMzUwIDU1NiAxMDAwIDMzMyAxMDAwIDUwMCAzMzMgOTQ0IDAgNTAwIDY2NyAwIDY2NyA1NTYgNTU2IDU1NiA1NTYgNjY3IDU1NiAzMzMgNzM3IDM3MCA1NTYgNjExIDAgNzM3IDYxMSA0MDAgNTU2IDMzMyAyMjIgMzMzIDU1NiA1MDAgMzMzIDMzMyAyNzggMzY1IDU1NiA1MDAgODM0IDgzNCA1MDAgNjY3IDY2NyA2NjcgNjY3IDY2NyA2NjcgMTAwMCA3MjIgNjY3IDY2NyA2NjcgNjY3IDI3OCAyNzggMzMzIDMzMyA3MjIgNzIyIDc3OCA3NzggNzc4IDc3OCA3NzggNTg0IDc3OCA3MjIgNzIyIDcyMiA3MjIgNjY3IDY2NyA2MTEgNTU2IDU1NiA1NTYgNTU2IDU1NiA1NTYgODg5IDUwMCA1NTYgNTU2IDU1NiA1NTYgMjc4IDI3OCAzMzMgMzMzIDU1NiA1NTYgNTU2IDU1NiA1NTYgNTU2IDU1NiA1ODQgNjExIDU1NiA1NTYgNTU2IDU1NiA1MDAgNTU2IDUwMCBdDQovTmFtZSAvRjANCj4+DQplbmRvYmoNCjcgMCBvYmoNCjw8DQovTGVuZ3RoIDE2Mg0KL0ZpbHRlciBbL0ZsYXRlRGVjb2RlIF0NCi9UeXBlIC9YT2JqZWN0DQovU3VidHlwZSAvSW1hZ2UNCi9Db2xvclNwYWNlIFsvSW5kZXhlZCAvRGV2aWNlUkdCIDIyMyA8MDAwMDAwIDAwMDAzMyAwMDAwNjYgMDAwMDk5IDAwMDBjYyAwMDAwZmYgMDAzMzAwIDAwMzMzMyAwMDMzNjYgMDAzMzk5IDAwMzNjYyAwMDMzZmYgMDA2NjAwIDAwNjYzMyAwMDY2NjYgMDA2Njk5IDAwNjZjYyAwMDY2ZmYgMDA5OTAwIDAwOTkzMyAwMDk5NjYgMDA5OTk5IDAwOTljYyAwMDk5ZmYgMDBjYzAwIDAwY2MzMyAwMGNjNjYgMDBjYzk5IDAwY2NjYyAwMGNjZmYgMDBmZjAwIDAwZmYzMyAwMGZmNjYgMDBmZjk5IDAwZmZjYyAwMGZmZmYgMzMwMDAwIDMzMDAzMyAzMzAwNjYgMzMwMDk5IDMzMDBjYyAzMzAwZmYgMzMzMzAwIDMzMzMzMyAzMzMzNjYgMzMzMzk5IDMzMzNjYyAzMzMzZmYgMzM2NjAwIDMzNjYzMyAzMzY2NjYgMzM2Njk5IDMzNjZjYyAzMzY2ZmYgMzM5OTAwIDMzOTkzMyAzMzk5NjYgMzM5OTk5IDMzOTljYyAzMzk5ZmYgMzNjYzAwIDMzY2MzMyAzM2NjNjYgMzNjYzk5IDMzY2NjYyAzM2NjZmYgMzNmZjAwIDMzZmYzMyAzM2ZmNjYgMzNmZjk5IDMzZmZjYyAzM2ZmZmYgNjYwMDAwIDY2MDAzMyA2NjAwNjYgNjYwMDk5IDY2MDBjYyA2NjAwZmYgNjYzMzAwIDY2MzMzMyA2NjMzNjYgNjYzMzk5IDY2MzNjYyA2NjMzZmYgNjY2NjAwIDY2NjYzMyA2NjY2NjYgNjY2Njk5IDY2NjZjYyA2NjY2ZmYgNjY5OTAwIDY2OTkzMyA2Njk5NjYgNjY5OTk5IDY2OTljYyA2Njk5ZmYgNjZjYzAwIDY2Y2MzMyA2NmNjNjYgNjZjYzk5IDY2Y2NjYyA2NmNjZmYgNjZmZjAwIDY2ZmYzMyA2NmZmNjYgNjZmZjk5IDY2ZmZjYyA2NmZmZmYgOTkwMDAwIDk5MDAzMyA5OTAwNjYgOTkwMDk5IDk5MDBjYyA5OTAwZmYgOTkzMzAwIDk5MzMzMyA5OTMzNjYgOTkzMzk5IDk5MzNjYyA5OTMzZmYgOTk2NjAwIDk5NjYzMyA5OTY2NjYgOTk2Njk5IDk5NjZjYyA5OTY2ZmYgOTk5OTAwIDk5OTkzMyA5OTk5NjYgOTk5OTk5IDk5OTljYyA5OTk5ZmYgOTljYzAwIDk5Y2MzMyA5OWNjNjYgOTljYzk5IDk5Y2NjYyA5OWNjZmYgOTlmZjAwIDk5ZmYzMyA5OWZmNjYgOTlmZjk5IDk5ZmZjYyA5OWZmZmYgY2MwMDAwIGNjMDAzMyBjYzAwNjYgY2MwMDk5IGNjMDBjYyBjYzAwZmYgY2MzMzAwIGNjMzMzMyBjYzMzNjYgY2MzMzk5IGNjMzNjYyBjYzMzZmYgY2M2NjAwIGNjNjYzMyBjYzY2NjYgY2M2Njk5IGNjNjZjYyBjYzY2ZmYgY2M5OTAwIGNjOTkzMyBjYzk5NjYgY2M5OTk5IGNjOTljYyBjYzk5ZmYgY2NjYzAwIGNjY2MzMyBjY2NjNjYgY2NjYzk5IGNjY2NjYyBjY2NjZmYgY2NmZjAwIGNjZmYzMyBjY2ZmNjYgY2NmZjk5IGNjZmZjYyBjY2ZmZmYgZmYwMDAwIGZmMDAzMyBmZjAwNjYgZmYwMDk5IGZmMDBjYyBmZjAwZmYgZmYzMzAwIGZmMzMzMyBmZjMzNjYgZmYzMzk5IGZmMzNjYyBmZjMzZmYgZmY2NjAwIGZmNjYzMyBmZjY2NjYgZmY2Njk5IGZmNjZjYyBmZjY2ZmYgZmY5OTAwIGZmOTkzMyBmZjk5NjYgZmY5OTk5IGZmOTljYyBmZjk5ZmYgZmZjYzAwIGZmY2MzMyBmZmNjNjYgZmZjYzk5IGZmY2NjYyBmZmNjZmYgZmZmZjAwIGZmZmYzMyBmZmZmNjYgZmZmZjk5IGZmZmZjYyBmZmZmZmYgYzBjMGMwIDgwODA4MCA4MDAwMDAgMDA4MDAwIDAwMDA4MCA4MDgwMDAgODAwMDgwIDAwODA4MCA+IF0NCi9XaWR0aCAyMjA5DQovSGVpZ2h0IDENCi9CaXRzUGVyQ29tcG9uZW50IDgNCi9OYW1lIC8wDQo+Pg0Kc3RyZWFtDQp4XsWVUQ7AIAxCvf8Fvc7+tImEPuKy+bXUKZTSOtaaaontHSpf+6zfpveNdWEDV0mLVM6QZUBRHVIlnGsqGFBSXgqpI5b5n4RlRlLfi6rmGlAGmv5ZTto8k/aqJyjg0lDJDPuK2hh1cesMVdWYwduF1qOBJcznIB3QrOh3GvgnwjHAvpIQXz4L22qtK9l0D//iqGqAxO81lbYxO/XVA7D3SAYKZW5kc3RyZWFtDQplbmRvYmoNCjggMCBvYmoNCjw8DQovVHlwZSAvRm9udA0KL1N1YnR5cGUgL1R5cGUxDQovRmlyc3RDaGFyIDMyDQovTGFzdENoYXIgMjU1DQovQmFzZUZvbnQgL0hlbHZldGljYS1Cb2xkDQovRW5jb2RpbmcgPDwNCi9UeXBlIC9FbmNvZGluZw0KL0RpZmZlcmVuY2VzIFszMiAvc3BhY2UgMTk2IC9BZGllcmVzaXMgMjE0IC9PZGllcmVzaXMgMjIwIC9VZGllcmVzaXMgMjI4IC9hZGllcmVzaXMgMjQ2IC9vZGllcmVzaXMgMjUyIC91ZGllcmVzaXMgMjIzIC9nZXJtYW5kYmxzIDE5MiAvQWdyYXZlIDE5NCAvQWNpcmN1bWZsZXggMTk4IC9BRSAxOTkgL0NjZWRpbGxhIDIwMCAvRWdyYXZlIDIwMSAvRWFjdXRlIDIwMiAvRWNpcmN1bWZsZXggMjAzIC9FZGllcmVzaXMgMjA2IC9JY2lyY3VtZmxleCAyMDcgL0lkaWVyZXNpcyAyMTIgL09jaXJjdW1mbGV4IDE0MCAvT0UgMjE3IC9VZ3JhdmUgMjE5IC9VY2lyY3VtZmxleCAxNTkgL1lkaWVyZXNpcyAyMjQgL2FncmF2ZSAyMjYgL2FjaXJjdW1mbGV4IDIzMCAvYWUgMjMxIC9jY2VkaWxsYSAyMzIgL2VncmF2ZSAyMzMgL2VhY3V0ZSAyMzQgL2VjaXJjdW1mbGV4IDIzNSAvZWRpZXJlc2lzIDIzOCAvaWNpcmN1bWZsZXggMjM5IC9pZGllcmVzaXMgMjQ0IC9vY2lyY3VtZmxleCAxNTYgL29lIDI0OSAvdWdyYXZlIDI1MSAvdWNpcmN1bWZsZXggMjU1IC95ZGllcmVzaXMgMTk3IC9BcmluZyAyMTYgL09zbGFzaCAxOTMgL0FhY3V0ZSAyMDUgL0lhY3V0ZSAyMTggL1VhY3V0ZSAyMjEgL1lhY3V0ZSAyMjkgL2FyaW5nIDI0OCAvb3NsYXNoIDIyNSAvYWFjdXRlIDIzNyAvaWFjdXRlIDI1MCAvdWFjdXRlIDI1MyAveWFjdXRlIDIxMCAvT2dyYXZlIDI0MiAvb2dyYXZlIDIwNCAvSWdyYXZlIDIzNiAvaWdyYXZlIDE5NSAvQXRpbGRlIDIxMyAvT3RpbGRlIDIyNyAvYXRpbGRlIDI0NSAvb3RpbGRlIDIyMiAvVGhvcm4gMjU0IC90aG9ybiAyMDkgL050aWxkZSAyNDEgL250aWxkZSAxMzggL1NjYXJvbiAxNTQgL3NjYXJvbiAyNDMgL29hY3V0ZSAyMTEgL09hY3V0ZSBdDQo+Pg0KL1dpZHRocyBbMjc4IDMzMyA0NzQgNTU2IDU1NiA4ODkgNzIyIDIzOCAzMzMgMzMzIDM4OSA1ODQgMjc4IDMzMyAyNzggMjc4IDU1NiA1NTYgNTU2IDU1NiA1NTYgNTU2IDU1NiA1NTYgNTU2IDU1NiAzMzMgMzMzIDU4NCA1ODQgNTg0IDYxMSA5NzUgNzIyIDcyMiA3MjIgNzIyIDY2NyA2MTEgNzc4IDcyMiAyNzggNTU2IDcyMiA2MTEgODMzIDcyMiA3NzggNjY3IDc3OCA3MjIgNjY3IDYxMSA3MjIgNjY3IDk0NCA2NjcgNjY3IDYxMSAzMzMgMjc4IDMzMyA1ODQgNTU2IDMzMyA1NTYgNjExIDU1NiA2MTEgNTU2IDMzMyA2MTEgNjExIDI3OCAyNzggNTU2IDI3OCA4ODkgNjExIDYxMSA2MTEgNjExIDM4OSA1NTYgMzMzIDYxMSA1NTYgNzc4IDU1NiA1NTYgNTAwIDM4OSAyODAgMzg5IDU4NCAwIDU1NiAwIDI3OCA1NTYgNTAwIDEwMDAgNTU2IDU1NiAzMzMgMTAwMCA2NjcgMzMzIDEwMDAgMCA2MTEgMCAwIDI3OCAyNzggNTAwIDUwMCAzNTAgNTU2IDEwMDAgMzMzIDEwMDAgNTU2IDMzMyA5NDQgMCA1MDAgNjY3IDAgNzIyIDU1NiA2MTEgNTU2IDU1NiA2NjcgNTU2IDMzMyA3MzcgMzcwIDU1NiA2MTEgMCA3MzcgNjExIDQwMCA1NTYgMzMzIDI3OCAzMzMgNjExIDU1NiAyNzggMzMzIDMzMyAzNjUgNTU2IDUwMCA4MzQgODM0IDUwMCA3MjIgNzIyIDcyMiA3MjIgNzIyIDcyMiAxMDAwIDcyMiA2NjcgNjY3IDY2NyA2NjcgMjc4IDI3OCAyNzggMjc4IDcyMiA3MjIgNzc4IDc3OCA3NzggNzc4IDc3OCA1ODQgNzc4IDcyMiA3MjIgNzIyIDcyMiA2NjcgNjY3IDYxMSA1NTYgNTU2IDU1NiA1NTYgNTU2IDU1NiA4ODkgNTU2IDU1NiA1NTYgNTU2IDU1NiAyNzggMjc4IDI3OCAyNzggNjExIDYxMSA2MTEgNjExIDYxMSA2MTEgNjExIDU4NCA2MTEgNjExIDYxMSA2MTEgNjExIDU1NiA2MTEgNTU2IF0NCi9OYW1lIC9GMQ0KPj4NCmVuZG9iag0KeHJlZg0KMCA5DQowMDAwMDAwMDAwIDY1NTM1IGYNCjAwMDAwMDAwMTEgMDAwMDAgbg0KMDAwMDAwMDExMSAwMDAwMCBuDQowMDAwMDAwMjk4IDAwMDAwIG4NCjAwMDAwMDAzNjMgMDAwMDAgbg0KMDAwMDAwMDU3MyAwMDAwMCBuDQowMDAwMDAxMDc0IDAwMDAwIG4NCjAwMDAwMDMwMDcgMDAwMDAgbg0KMDAwMDAwNDk1MSAwMDAwMCBuDQp0cmFpbGVyDQo8PA0KL1NpemUgOQ0KL1Jvb3QgMSAwIFINCi9JbmZvIDIgMCBSDQo+Pg0Kc3RhcnR4cmVmDQo2ODg4DQolJUVPRg0K
Sorry for that.
Anyway, this should be a pdf because that was one of the request parameters. (I could also have chosen for .gif, or .jpg in different qualities.)
I tried reading the content, like this:
#label_binary = #response_label[:generate_label_response][:response_shipments][:response_shipment][:labels][:label][:content]
binary_data = Base64.decode64(#label_binary)
#label = File.open('file_name.pdf', 'wb') {|f| f.write(Base64.decode64(binary_data))}
But what this prints then as #label is just a number (three of four digits). Same when I use urlsafe_decode64.
Not very helpful.
Preferred end-result would be a pdf image file that I can immediately display (in this case a barcode on top of an invoice for sending a package).
Could I for this purpose save the file temporarily? Meaning: every time I need to display I rebuild this image. I think that would be best.
EDIT
I am making the call now directly to a 600dpi .jpg image and then:
base_64_binary_data = #response_label[:generate_label_response][:response_shipments][:response_shipment][:labels][:label][:content]
#jpg_file = File.open('label.jpg', 'wb') do |file|
content = Base64.decode64 base_64_binary_data
file << content
end
This file shows up at my_apps_name/label.jpg.
In my filesystem I can see the picture crystal clear.
In my view I then put:
<%= image_tag #jpg_file.path %>
When I inspect my html in the browser I see:
<img src="/images/label.jpg" alt="Label">
I suppose this is easily fixed, suggestions are still welcome of course, but...
..more importantly: What if this call is made several times at once. Will rails manage? Should I maybe save these images (to my S3) or build some kind of chronejob to manage it?
(I am not sure of the added value of mini_magic anymore, since I can see the .jpg being already there.)
Then on a complete side note, maybe better left for a separate question: what if the API on the other side fails?
Step one
decode http response
require "base64"
BASE_64_BINARY_DATA = "PASTE YOUR BIG STRING HERE"
pdf_file = File.open('your_pdf.pdf', 'wb') do |file|
content = Base64.decode64 BASE_64_BINARY_DATA
file << content
end
Step two
convert pdf file to an image
add to gemfile 'gem 'mini_magick' and use 'bundle install' command
put somewhere in your code
require 'mini_magick'
pdf = MiniMagick::Image.new(pdf_file.path)
pdf.pages.first.write("preview.png")
image saved as preview.png
To display pdf image put in the view
<%= image_tag ("path_to_image/preview.jpg")%>
I have tried the approach in
this example and the duplicate
I still continue to receive a blank image when I render it. I need to generate a png file from this base64 string. The label_string is the base64 encoded pdf that I receive from a shipping label creater.
file = Tempfile.new(['order', '.png'])
File.open(file.path.to_s, 'wb') do |f|
f.write(Base64.decode64(label_string))
end
pdf = Services::Invoices::Pdf.new(invoice).process(file.path)
file.unlink
pdf
here is my label_string
"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"
UPDATE: I found a similar problem at this question
In Imagemagick, you can do that with the INLINE: input structure. See http://www.imagemagick.org/Usage/files/#inline. For example:
convert 'inline:data:image/png;base64,
R0lGODlhIAAgAPIEAAAAAB6Q/76+vvXes////wAAAAAAAAAAACH5BAEAAAUALAAA
AAAgACAAAAOBWLrc/jDKCYG1NBcwegeaxHkeGD4j+Z1OWl4Yu6mAYAu1ebpwL/OE
YCDA0YWAQuJqRwsSeEyaRTUwTlxUqjUymmZpmeI3u62Mv+XWmUzBrpeit7YtB1/r
pTAefv942UcXVX9+MjNVfheGCl18i4ddjwwpPjEslFKDUWeRGj2fnw0JADs=
' b64_noseguy.png
file1 = Tempfile.new(['order', '.pdf'])
File.open(file1.path.to_s, 'wb') do |f|
f.write(Base64.decode64(label_string))
end
file = Tempfile.new(['order', '.png'])
im = Magick::Image.from_blob(open(file1.path.to_s).read).first
im.write(file.path.to_s)
pdf = Services::Invoices::Pdf.new(invoice).process(file.path)
file.unlink
pdf
This works, however; it does not seem like it would be the best solution.
I have a Dragonfly processor which should take a given PDF and return a PNG of the first page of the document.
When I run this processor via the console, I get back the PNG as expected, however, when in the context of Rails, I'm getting it as a PDF.
My code is roughly similar to this:
def to_pdf_thumbnail(temp_object)
tempfile = new_tempfile('png')
args = "'#{temp_object.path}[0]' '#{tempfile.path}'"
full_command = "convert #{args}"
result = `#{full_command}`
tempfile
end
def new_tempfile(ext=nil)
tempfile = ext ? Tempfile.new(['dragonfly', ".#{ext}"]) : Tempfile.new('dragonfly')
tempfile.binmode
tempfile.close
tempfile
end
Now, tempfile is definitely creating a .png file, but the convert is generating a PDF (when run from within Rails 3).
Any ideas as to what the issue might be here? Is something getting confused about the content type?
I should add that both this and a standard conversion (asset.png.url) both yield a PDF with the PDF content as a small block in the middle of the (A4) image.
An approach I’m using for this is to generate the thumbnail PNG on the fly via the thumb method from Dragonfly’s ImageMagick plugin:
<%= image_tag rails_model.file.thumb('100x100#', format: 'png', frame: 0).url %>
So long as Ghostscript is installed, ImageMagick/Dragonfly will honour the format / frame (i.e. page of the PDF) settings. If file is an image rather than a PDF, it will be converted to a PNG, and the frame number ignored (unless it’s a GIF).
Try this
def to_pdf_thumbnail(temp_object)
ret = ''
tempfile = new_tempfile('png')
system("convert",tmp_object.path[0],tmpfile.path)
tempfile.open {|f| ret = f.read }
ret
end
The problem is you are likely handing convert ONE argument not two
Doesn't convert rely on the extension to determine the type? Are you sure the tempfiles have the proper extensions?