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.
Related
I am trying to create a new file and then write some content to it just to create a basic backup of a template.
When I log out the values of filename and file_content they are correct, but when I send the data all I get is a file named after the method (download_include) and a fixnum inside the file, the last one made was 15.
# POST /download_include/:id
def download_include
#include = Include.find(params[:id])
version_to_download = #include.latest_version_record
filename = "#{version_to_download.name}"
file_content = "#{version_to_download.liquid_code.to_s}"
file = File.open(filename, "w") { |f| f.write (file_content) }
send_data file
end
I also tried send_file but that produces the error
no implicit conversion of Fixnum into String
I also tried to just write dummy values like below, and it still produced a file named after the method with a fixnum inside it.
file = File.open("DOES THIS CHANGE THE FILENAME?", "w") { |f| f.write ("FILE CONTENT?") }
I feel I am missing something obvious but I cannot figure it out after looking at many examples here and in blogs.
If you don't end along the filename as an option for send_data, it defaults to the method name.
Secondly, the download wants to read the data from a buffer. My guess is your syntax is just sending a file handle.
Try this...
send_data(file.read, filename: filename)
Or skip the intermediate file and try...
send_data(version_to_download.liquid_code.to_s, filename: filename)
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.
I want to generate pdf file from DB record. Encode it to Base64 string and store it to DB. Which works fine. Now I want reverse action, How can I decode Base64 string and generate pdf file again?
here is what I tried so far.
def data_pdf_base64
begin
# Create Prawn Object
my_pdf = Prawn::Document.new
# write text to pdf
my_pdf.text("Hello Gagan, How are you?")
# Save at tmp folder as pdf file
my_pdf.render_file("#{Rails.root}/tmp/pdf/gagan.pdf")
# Read pdf file and encode to Base64
encoded_string = Base64.encode64(File.open("#{Rails.root}/tmp/pdf/gagan.pdf"){|i| i.read})
# Delete generated pdf file from tmp folder
File.delete("#{Rails.root}/tmp/pdf/gagan.pdf") if File.exist?("#{Rails.root}/tmp/pdf/gagan.pdf")
# Now converting Base64 to pdf again
pdf = Prawn::Document.new
# I have used ttf font because it was giving me below error
# Your document includes text that's not compatible with the Windows-1252 character set. If you need full UTF-8 support, use TTF fonts instead of PDF's built-in fonts.
pdf.font Rails.root.join("app/assets/fonts/fontawesome-webfont.ttf")
pdf.text Base64.decode64 encoded_string
pdf.render_file("#{Rails.root}/tmp/pdf/gagan2.pdf")
rescue => e
return render :text => "Error: #{e}"
end
end
Now I am getting below error:
Encoding ASCII-8BIT can not be transparently converted to UTF-8.
Please ensure the encoding of the string you are attempting to use is
set correctly
I have tried How to convert base64 string to PNG using Prawn without saving on server in Rails but it gives me error:
"\xFF" from ASCII-8BIT to UTF-8
Can anyone point me what I am missing?
The answer is to decode the Base64 encoded string and either send it directly or save it directly to disk (naming it as a PDF file, but without using prawn).
The decoded string is a binary representation of the PDF file data, so there's no need to use Prawn or to re-calculate the content of the PDF data.
i.e.
raw_pdf_str = Base64.decode64 encoded_string
render :text, raw_pdf_str # <= this isn't the correct rendering pattern, but it's good enough as an example.
EDIT
To clarify some of the information given in the comments:
It's possible to send the string as an attachment without saving it to disk, either using render text: raw_pdf_str or the #send_data method (these are 4.x API versions, I don't remember the 5.x API style).
It's possible to encode the string (from the Prawn object) without saving the rendered PDF data to a file (save it to a String object instead). i.e.:
encoded_string = Base64.encode64(my_pdf.render)
The String data could be used directly as an email attachment, similarly to the pattern provided here only using the String directly instead of reading any data from a file. i.e.:
# inside a method in the Mailer class
attachments['my_pdf.pdf'] = { :mime_type => 'application/pdf',
:content => raw_pdf_str }
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
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?