def tree_equation_id_pdf(request, id):
    tree_equation = TreeEquation.objects.get(ID=id)

    template = get_template('data/template.tree_equation.pdf.html')

   
    html = template.render(Context({
        'tree_equation': tree_equation
    }))

    def fetch_resources(uri, rel):
        path = 'ERROR'
        if uri[0:6] == 'static':
            path = settings.STATIC_ROOT + uri[6:]
        elif uri[0:5] == 'media':
            path = settings.MEDIA_ROOT + uri[5:]
        print uri, path
        return path

    buffer = StringIO.StringIO()
    pisa.pisaDocument(StringIO.StringIO(html.encode("UTF-8")),
                      buffer,
                      link_callback=fetch_resources)

    pdf = buffer.getvalue()
    buffer.close()
    
    # Create the HttpResponse object with the appropriate PDF headers.
    response = HttpResponse(mimetype='application/pdf')
    response['Content-Disposition'] = 'attachment; filename=TreeEquation_%s.pdf' % tree_equation.ID

    response.write(pdf)
    return response

def defaultview():
    """
    serving landing page index.html
    """
    if request.method == "POST":
        #in case of report generation
        dict = json.loads(request.form['data'])

        if request.form['type'] == "pdf":

            #Generate PDF

            html = flask.render_template('report.html', content=dict)
            result = StringIO.StringIO()
            pisa.pisaDocument(StringIO.StringIO(html), result)
            result.seek(0)
            download_filename = "reports.pdf"
            response = flask.current_app.response_class(result, mimetype='application/pdf')
            response.headers.add('Content-Disposition', 'attachment',
                             filename=download_filename)

            return response
        else:
            #Generate XML
            xml = dicttoxml.dicttoxml(dict)
            download_filename='reports.xml'

            response = flask.current_app.response_class(xml, mimetype='application/pdf')
            response.headers.add('Content-Disposition', 'attachment',
                             filename=download_filename)

            return response
    else:
        #Serve index.html
        return flask.render_template('index.html')

def record_by_id_pdf_view(request, id, model_class, 
        record_content_template, record_title, record_url):
    record = model_class.objects.get(pk=id)

    template = get_template('base/template.record.pdf.html')
   
    html = template.render(Context({
        'record': record.serialize(request=request),
        'record_content_template': record_content_template,
        'record_title': record_title,
        'record_url': record_url,
        'is_pdf': True
    }))

    def fetch_resources(uri, rel):
        path = 'ERROR'
        if uri[0:7] == '/static':
            path = os.path.join(settings.PROJECT_PATH, 'templates', 'static') +  uri[7:]
        return path

    result = StringIO.StringIO()
    pisa.pisaDocument(

        StringIO.StringIO(html.encode("UTF-8")), result, encoding='UTF-8',link_callback=fetch_resources)

    pdf = result.getvalue()
    result.close()
    
    # Create the HttpResponse object with the appropriate PDF headers.
    response = HttpResponse(content_type='application/pdf')
    response['Content-Disposition'] = 'attachment; filename=%s.pdf' % record_title.lower().replace(' ', '_')
    response.write(pdf)
    return response

def buffer_pdf(html):
    """
        Return a cstringio datas containing a pdf
    """
    result = StringIO.StringIO()
    pisa.pisaDocument(html,
                      result,
                      link_callback=fetch_resource,
                      encoding='utf-8', html_encoding="utf-8")
    return result

    def write_img_to_pdf (src, dest):
        # Helper xhtml2pdf function to dump image/template to pdf
        context = dict(img_path = src)
        template = get_template('tracker/pdf_img_template.html')
        html = template.render(Context(context))

        with open(dest, 'wb') as f:
            pisa.pisaDocument(cStringIO.StringIO(
                html.encode('UTF-8')), f
            )

 def generate(self, header, data, output_stream):
     def fetch_resources(uri, rel):
         urls = {settings.MEDIA_ROOT: settings.MEDIA_URL, settings.STATICFILES_ROOT: settings.STATIC_URL}
         for k, v in urls.items():
             if (uri.startswith(v)):
                 return os.path.join(k, uri.replace(v, ""))
         return ''
     pisa.pisaDocument(
         force_text(render_template(self.template_name, {'pagesize': 'A4', 'headers': header, 'data': data})),
         output_stream, encoding=self.encoding, link_callback=fetch_resources
     )

def html_to_pdf(content, encoding="utf-8", link_callback=fetch_resources, **kwargs):
    """
    Converts html ``content`` into PDF document.

    :param unicode content: html content
    :returns: PDF content
    :rtype: :class:`bytes`
    :raises: :exc:`~easy_pdf.exceptions.PDFRenderingError`
    """
    src = BytesIO(content.encode(encoding))
    dest = BytesIO()
    #result = open("/home/midas/Documentos/appem/infa_web/static/report.pdf", 'wb') # Changed from file to filename

    result = open(os.path.join(settings.MEDIA_ROOT, kwargs["filename_to_save"]), 'w') # Changed from file to filename


    pdf = pisa.pisaDocument(src, result, encoding=encoding, link_callback=link_callback, **kwargs)
    #pdf = pisa.pisaDocument(src, dest, encoding=encoding, link_callback=link_callback, **kwargs)

    if pdf.err:
        logger.error("Error rendering PDF document")
        for entry in pdf.log:
            if entry[0] == xhtml2pdf.default.PML_ERROR:
                logger_x2p.error("line %s, msg: %s, fragment: %s", entry[1], entry[2], entry[3])
        raise PDFRenderingError("Errors rendering PDF", content=content, log=pdf.log)

    if pdf.warn:
        for entry in pdf.log:
            if entry[0] == xhtml2pdf.default.PML_WARNING:
                logger_x2p.warning("line %s, msg: %s, fragment: %s", entry[1], entry[2], entry[3])
    print (".................................")

    result = open(os.path.join(settings.MEDIA_ROOT, kwargs["filename_to_save"]), 'r') # Changed from file to filename

    return result

    def create_page(self, page):
        data = StringIO.StringIO(page.encode('utf-8'))
        temp = StringIO.StringIO()

        pdf = pisa.pisaDocument(data, temp)

        self.pdf_base.addDocument(pdf)

    def _create_pdf(self):

        # Dati di esempio
        #order = self.resource.order
        xres = self.resource
        #querySet = self._get_resource_list(self.request).distinct()
        querySet, nSup, nProducts, nPacts = self._get_pdfrecords_pacts(self._get_resource_list(self.request).order_by('name'))
        context_dict = {
            'order' : xres,
            'recSup' : querySet,
            'Suppliers_count' : nSup,
            'pacts_count' : nPacts,
            'products_count' : nProducts,
            'user' : self.request.user,
        }

        REPORT_TEMPLATE = "blocks/%s/report.html" % self.BLOCK_NAME

        template = get_template(REPORT_TEMPLATE)
        context = Context(context_dict)
        html = template.render(context)
        result = StringIO.StringIO()
        #DOMTHU: <th title='TOT account'>&#8364;</th>
        #pdf = pisa.pisaDocument(StringIO.StringIO(html), result) 
        pdf = pisa.pisaDocument(StringIO.StringIO(html.encode("ISO-8859-1", "ignore")), result)
        #pdf = pisa.pisaDocument(StringIO.StringIO(html.encode("UTF-8", "ignore")), result ) #, link_callback = fetch_resources )
        if not pdf.err:
            response = HttpResponse(result.getvalue(), mimetype='application/pdf')
            response['Content-Disposition'] = "attachment; filename=Suppliers.pdf"
            return response
        return self.response_error(_('We had some errors<pre>%s</pre>') % cgi.escape(html))

def save_pdf(pdf_data,file,diagnoseId,fileName,identityPhone):
    default.DEFAULT_FONT["helvetica"]="msyh"
    fontFile = os.path.join( constant.DirConstant.ROOT_DIR+ '/DoctorSpring/static/font', 'msyh.ttf')
    pdfmetrics.registerFont(TTFont('msyh',fontFile))
    # from xhtml2pdf.pisa.sx.pisa3 import pisa_default
    pdf = pisa.pisaDocument(StringIO(
        pdf_data.encode("UTF-8")), file,encoding='utf-8')
    file.close()

    output = PdfFileWriter()

    with open(fileName, "rb") as f1:
        input1 = PdfFileReader(f1)

        for i in range(input1.getNumPages()):
            output.addPage(input1.getPage(i))

        #print(identityPhone)
        password = str(int(identityPhone))
        owner_pwd = ''.join(random.choice(string.letters + string.digits) for _ in range(64))
        #print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" + owner_pwd)
        output.encrypt(password, owner_pwd)

        output.write(open("temp.pdf", "wb"))

    os.remove(fileName)
    os.rename("temp.pdf", fileName)

    fileUrl=upload_pdf(fileName,diagnoseId)
    return fileUrl

def render_pdf(html):
    # Function to generate the pdf document and return it throught HttpResponse
    result = StringIO.StringIO()
    pdf = pisa.pisaDocument(StringIO.StringIO(html.encode("UTF-8")), result)
    if not pdf.err:
        return HttpResponse(result.getvalue(), mimetype='application/pdf')
    return HttpResponse('Error when generating the pdf: %s' % cgi.escape(html))

 def pdf(self):
     """
     Converts html to pdf and returns the char stream
     """
     result = StringIO()
     # h3 and down shouldn't make chapters
     html = self.html.encode("UTF-8")
     html = html.replace('<h3>', '<h3 class="not_outline">')
     html = html.replace('<h4>', '<h4 class="not_outline">')
     html = html.replace('<h5>', '<h5 class="not_outline">')
     html = html.replace('<h6>', '<h6 class="not_outline">')
     # add page breaks before each h2
     html = html.replace('<h2>', '<h2 class="break">')
     # generate the pdf
     pisa.pisaDocument(StringIO(html), result)
     return result.getvalue()

def transform_to_pdf(response, pdfname, return_stringIO=False):
    """
    call xhtml2pdf.pisa to convert html responce to pdf
    """
    # response['mimetype'] = 'application/pdf'

    # TODO : on the fly filename from url
    # response['Content-Disposition'] = 'attachment; filename=%s.pdf' % pdfname

    content = response.content

    if not return_stringIO:
        new_response = HttpResponse(content="", mimetype="application/pdf")
        new_response["Content-Disposition"] = "attachment; filename=%s.pdf" % pdfname
    else:
        new_response = StringIO.StringIO()

    pdf = pisa.pisaDocument(StringIO.StringIO(content), new_response, link_callback=fetch_resources)

    if not pdf.err:
        if return_stringIO:
            pdf = new_response.getvalue()
            new_response.close()
            return pdf
        else:
            return new_response
    else:
        # TODO return error and redirect to default view
        return HttpResponse(
            "We had some errors in pdfMiddleWare : \
                            <br/><pre>%s</pre>"
            % pdf
        )

 def create_pdf_body(self):
     from apps.mail.models import Attachment
     from xhtml2pdf import pisa
     import os
     try:
         #ghetto tmp file for pdf creation, will this work on HEROKU? I think so but could be slow...
         if not os.path.exists('tmp'):
             os.makedirs('tmp')
         #TODO: need default attachment
         attachment = None
         html = self.free_edit_body
         fname = 'tmp/request_%s_tmp.pdf' % self.id
         with open(fname, 'wb') as f:
             doc = pisa.pisaDocument(html, f)
         if not doc.err:
             with open(fname, 'rb') as f:
                 to_file = ContentFile(f.read())
                 attachment = Attachment()
                 attachment.user = self.author
                 attachment.file.save('request_%s.pdf' % self.id, to_file)
                 attachment.save()
             os.remove(fname)
         else:
             logger.error("error writing to PDF: %s" % doc.err)
         self.printed = attachment
         self.save()
         return attachment.url
     except Exception as e:
         logger.exception(e)
         return None 

def factura_pdf(html):

    reporventa = StringIO.StringIO()
    pdf = pisa.pisaDocument(StringIO.StringIO(html.encode("UTF:8")), reporventa)
    if not pdf.err:
        return HttpResponse(reporventa.getvalue(), mimetype='application/pdf')
    return HttpResponse("Error en generar el pdf")

def download_merged_pdf(obj, files):
    """
    Returns a HTTPResponse that contains all PDF files merged into a
    single PDF file.
    """
    warnings.simplefilter('ignore', DeprecationWarning)

    filename = u"%s_%s_%s_files.pdf" % (obj.type, obj.reference, obj.revision)
    output = StreamedPdfFileWriter()

    # generate a summary
    ctx = { "obj" : obj, "files" : files,
            "state_histories" : get_state_histories(obj),
            }
    template = get_template("summary.xhtml")
    html  = template.render(Context(ctx))
    result = StringIO.StringIO()
    pdf = pisa.pisaDocument(StringIO.StringIO(html.encode("utf-16")), result)
    result.seek(0)
    inp = PdfFileReader(result)
    for page in inp.pages:
        output.addPage(page)

    # append all pdfs
    for pdf_file in files:
        inp = PdfFileReader(file(pdf_file.file.path, "rb"))
        for page in inp.pages:
            output.addPage(page)
    response = http.StreamingHttpResponse(output, content_type='application/pdf')
    response['Content-Disposition'] = 'attachment; filename="%s"' % filename
    warnings.simplefilter('default', DeprecationWarning)
    return response

def html_to_pdf(content, encoding="utf-8",
                link_callback=fetch_resources, **kwargs):
    """
    Converts html ``content`` into PDF document.

    :param unicode content: html content
    :returns: PDF content
    :rtype: :class:`bytes`
    :raises: :exc:`~easy_pdf.exceptions.PDFRenderingError`
    """
    src = BytesIO(content.encode(encoding))
    dest = BytesIO()

    pdf = pisa.pisaDocument(src, dest, encoding=encoding,
                            link_callback=link_callback, **kwargs)
    if pdf.err:
        logger.error("Error rendering PDF document")
        for entry in pdf.log:
            if entry[0] == xhtml2pdf.default.PML_ERROR:
                logger_x2p.error("line %s, msg: %s, fragment: %s", entry[1], entry[2], entry[3])
        raise PDFRenderingError("Errors rendering PDF", content=content, log=pdf.log)

    if pdf.warn:
        for entry in pdf.log:
            if entry[0] == xhtml2pdf.default.PML_WARNING:
                logger_x2p.warning("line %s, msg: %s, fragment: %s", entry[1], entry[2], entry[3])

    return dest.getvalue()

    def _generatePDF(write_file=False, title="Latest CCOL Events", school_id="", grade="", subject=""):        
        events = Event.objects.all().order_by('-start_date')[:4]

        context_dict = {'events':events,
                        'title':title}
        
        template = get_template("flyer_pdf.html")
        context = Context(context_dict)
        html  = template.render(context)
        result = StringIO()
        pdf = pisa.pisaDocument(StringIO( "{0}".format(html) ), result)
        
        if not pdf.err:
            if write_file:
                tempFileName = settings.MEDIA_ROOT+"/"+title.replace(" ","")+".pdf"
                tempFile = open(tempFileName, 'wb+')
                tempFile.write(result.getvalue())
                tempFile.close()
                return tempFileName
                
            else:
                return HttpResponse(result.getvalue(), content_type='application/pdf')
        
        if write_file:
            return None
        
        return HttpResponse('We had some errors<pre>%s</pre>' % cgi.escape(html))

def generar_pdf(html):
	# Función para generar el archivo PDF y devolverlo mediante HttpResponse
	result = StringIO.StringIO()
	pdf = pisa.pisaDocument(StringIO.StringIO(html.encode("UTF-8")), result)
	if not pdf.err:
		return HttpResponse(result.getvalue(), mimetype='application/pdf')
	return HttpResponse('Error al generar el PDF: %s' % cgi.escape(html))

    def export_pdf(self, request, pk):
        group = get_object_or_404(Group, pk=pk)
        attrs = {'group__pk': pk}

        if request.GET.get('finished', '0') == '1':
            attrs['enroll_finished'] = True

        elif request.GET.get('finished', '0') == '2':
            attrs['enroll_finished'] = False

        if request.GET.get('activate', '0') == '1':
            attrs['enroll_activate'] = True

        elif request.GET.get('activate', '0') == '2':
            attrs['enroll_activate'] = False

        student_list = Enroll.objects.filter(**attrs)

        template = get_template('Pdf/student_list.html')
        html = template.render(Context({'student_list': student_list,
                                        'group': group}))
        result = io.StringIO()
        pdf = pisa.pisaDocument(io.StringIO(html), result)
        if not pdf.err:
            response = HttpResponse(result.getvalue(), content_type='application/pdf')
            response['Content-Disposition'] = 'attachment; filename="student_list_%s.pdf"' % (group.name)
            return response

        return HttpResponse("Error " + str(pdf.err) + "  " + html)