app-old.py

#! /usr/bin/env python

# DEPRECATED
import sys
import os
import time

# PROJECT_ROOT = os.path.dirname(os.path.abspath(__file__))
# sys.path.insert(0, os.path.abspath(os.path.join(PROJECT_ROOT, "..")))

import json
import tempfile

from jinja2 import Template

from jinja2 import Environment, PackageLoader, select_autoescape

env = Environment(
    loader=PackageLoader('app', 'templates'),
    autoescape=select_autoescape(['html', 'xml'])
)


def formatFloat(val):

    try:
        float(val)
    except ValueError:
        return ''

    return format(float(val), '.12f').rstrip("0").rstrip('.')


env.globals.update(formatFloat=formatFloat)

from werkzeug.wsgi import wrap_file
from werkzeug.wrappers import Request, Response
from executor import execute

from werkzeug.datastructures import Headers

import logging

logger = logging.getLogger()

gunicorn_error_logger = logging.getLogger('gunicorn.error')
logger.handlers.extend(gunicorn_error_logger.handlers)
logger.setLevel(logging.DEBUG)


def get_report(data):
    html = ''

    template = env.get_template('base.html')

    html = template.render(**data)

    return html


def create_file(html, options):
    file_name = ''

    with tempfile.NamedTemporaryFile(suffix='.html') as source_file:
        # source_file.write(payload['contents'].decode('base64'))
        source_file.write(html)
        # options = payload.get('options', {})

        source_file.flush()

        # Evaluate argument to run with subprocess
        args = ['wkhtmltopdf']

        # Add Global Options
        if options:
            for option, value in options.items():
                args.append('--%s' % option)
                if value:
                    args.append('%s' % value)

        # Add source file name and output file name
        file_name = source_file.name
        args += [file_name, file_name + ".pdf"]

        # Execute the command using executor
        execute(' '.join(args))

    return file_name


def fit_columns_to_a4_width(layout, scale, margin, columns):
    columns_to_remove = 0

    current_width = 0

    limit_width = 0

    # scale_modifier = 1

    # if scale > 1:
    
    #    scale_modifier = 1 - (scale - 1)

    #    if scale_modifier == 0:
    #        scale_modifier = 0.1

    # else:

    #    scale_modifier = 1 + (1 - scale)

    # A4 (21 x 29.7 cm), width:794px; height:1122px - data from internet

    # A4 estimated width equals to 1173px - data recieved by testing

#     logger.info('layout %s' % layout)
    logger.info('scale %s' % scale)
    # logger.info('scale_modifier %s' % scale_modifier)
    logger.info('margin %s' % margin)

    if layout == 'portrait':
        limit_width = 833
        # limit_width = 794 * scale_modifier

    if layout == 'landscape':
        limit_width = 1173
        # limit_width = 1047 * scale_modifier

    # one margin unit estimately equals to 4.1px
    limit_width = float(limit_width) - float(margin) * 8.2

    logger.info('limit_width %s' % limit_width)

    columns_fit_count = 0

    if len(columns):

        for column in columns:

            column_width = int(float(column['style']['width'].split('px')[0])) * scale

            if column_width + current_width <= limit_width:
                current_width = current_width + column_width

                logger.info('current_width: %s' % current_width)
                print('current_width %s' % current_width)
                print('columns_fit_count %s' % str(columns_fit_count + 1))

                columns_fit_count = columns_fit_count + 1
            else:
                break

        columns_len = len(columns)

        columns_to_remove = columns_len - columns_fit_count

        columns = columns[:columns_len - columns_to_remove]

    return columns


@Request.application
def application(request):
    if request.method != 'POST':
        return

    # logger.info("Request data %s" % request.data)

    requestData = json.loads(request.data)

    entityType = requestData['entityType']
    settings = requestData['settings']
    contentSettings = requestData['contentSettings']

    templateData = {}

    templateData['entityType'] = entityType
    templateData['content'] = requestData['content']
    templateData['layoutName'] = contentSettings['layoutName']
    templateData['reportOptions'] = contentSettings['reportOptions']

    # requestData['layout'] = 'portrait'

    # requestData['margin'] = '4'

    options = {
        'orientation': settings['layout'],
        # 'viewport-size': '1280x1024',
        # 'viewport-size': '1920x1080',
        # 'page-width': 1600 * 0.271,
        # 'page-height': 1200 * 0.271,
        # 'zoom': 1,
        'zoom': settings['zoom'],
        # 'zoom': 0.5,
        # 'zoom': '0.25',
        'disable-smart-shrinking': '',
        'page-width': '210mm',
        'page-height': '297mm',
        #'page-size': 'A4',
        'footer-right': '[page]/[toPage]',
        'footer-font-size': '8',

        'margin-top': str(settings['margin']),
        'margin-bottom': str(settings['margin']),
        'margin-left': str(settings['margin']),
        'margin-right': str(settings['margin'])

        #'dpi': '300'
    }

    logger.info('Columns total: %s' % len(contentSettings["columns"]))

    templateData["columns"] = fit_columns_to_a4_width(settings['layout'],
                                                      float(settings['zoom']),
                                                      settings['margin'],
                                                      contentSettings["columns"])

    logger.info("Columns fit: %s" % len(templateData["columns"]))

    templateData["pageLayout"] = settings['layout']

    logger.info('templateData["pageLayout"] %s' % templateData["pageLayout"])

    conv = None

    if entityType == 'balance-report':

        conv = time.strptime(contentSettings["reportOptions"]["report_date"], "%Y-%m-%d")
        templateData["reportDate"] = time.strftime("%d/%m/%Y", conv)

    if entityType == 'transaction-report':

        beginDateConverted = time.strptime(contentSettings["reportOptions"]["begin_date"], "%Y-%m-%d")
        templateData["beginDate"] = time.strftime("%d/%m/%Y", beginDateConverted)

        endDateConverted = time.strptime(contentSettings["reportOptions"]["end_date"], "%Y-%m-%d")
        templateData["endDate"] = time.strftime("%d/%m/%Y", endDateConverted)

    if entityType == 'pl-report':

        beginDateConverted = time.strptime(contentSettings["reportOptions"]["pl_first_date"], "%Y-%m-%d")
        templateData["beginDate"] = time.strftime("%d/%m/%Y", beginDateConverted)

        endDateConverted = time.strptime(contentSettings["reportOptions"]["report_date"], "%Y-%m-%d")
        templateData["endDate"] = time.strftime("%d/%m/%Y", endDateConverted)



    html = get_report(templateData)

    # Get result of html page creation

    # f = open('page.html', mode='w')
    # f.write(html)
    # f.close()
    
    # return Response(wrap_file(request.environ, open('page.html')), mimetype="text/html")

    # < Get result of html page creation >

    logger.info('options %s' % options)

    file_name = create_file(html, options)

    headers = Headers()
    headers.add('Content-Type', 'application/pdf')
    headers.add('Content-Disposition', 'attachment', filename='report.pdf')

    pdf = open(file_name + '.pdf')

    os.remove(file_name + '.pdf')

    response = Response(pdf.read(),
                        mimetype='application/pdf', headers=headers
                        )

    pdf.close()

    return response


if __name__ == '__main__':
    from werkzeug.serving import run_simple

    run_simple(
        '127.0.0.1', 5000, application, use_debugger=True, use_reloader=True
    )