def order_results_print(request,pk):
order = Orders.objects.get(pk=pk)
input_file_header = settings.RESULT_REPORT_FILE_HEADER
input_file_main = settings.RESULT_REPORT_FILE_MAIN
input_file = settings.RESULT_REPORT_FILE
ts = datetime.today().strftime('%Y%m%d%H%M%S')
parameters ={'ORDER_ID': pk}
output = settings.MEDIA_ROOT+'\\report\\'+str(order.number)+'_'+ts
con = settings.JASPER_CONN
jasper = JasperPy()
jasper.compile(input_file_header)
jasper.compile(input_file_main)
jasper.process(
input_file,
output_file=output,
format_list=["pdf"],
parameters=parameters,
db_connection=con,
locale='en_US',
resource= settings.RESULT_REPORT_DIR
)
base_url = request.build_absolute_uri('/')[:-1].strip("/")
url_pdf = base_url+'/media/report/'+str(order.number)+'_'+ts+'.pdf'
# save report URL
oe, _created = models.OrderExtended.objects.get_or_create(order_id=pk)
oe.result_pdf_url = url_pdf
oe.save()
# set validation printed
if request.user.is_authenticated():
order_res = models.OrderResults.objects.filter(order_id=pk,validation_status=3).update(validation_status=4,print_user=str(request.user),print_date=datetime.now())
template = 'middleware/result_pdf_preview.html'
context = {'order':order,'url_pdf' : url_pdf}
return render(request,template,context)
def do_print_pdf(request):
post_id = request.matchdict['id']
input_file = c_report_paths['jasper'] + '/hello-world.jrxml'
jasper = JasperPy()
jasper.compile(input_file)
jasper.process(input_file, c_report_paths['pdf'], format_list=['pdf'])
response = FileResponse(c_report_paths['pdf'] + '/hello-world.pdf',
request=request)
response.headers['Content-Disposition'] = 'inline; filename={}'.format(
c_report_paths['pdf'] + '/hello-world.pdf')
response.headers['Content-Type'] = 'application/pdf'
# delete generated pdf file
if os.path.exists(c_report_paths['pdf'] + '/hello-world.pdf'):
os.remove(c_report_paths['pdf'] + '/hello-world.pdf')
return response
def get_inoive_pdf(self, InvoiceNumber):
input_file = os.path.dirname(os.path.abspath(
__file__)) + '/Reports/RptFiles/RptInvoicePrint.jrxml'
output = os.path.dirname(os.path.abspath(
__file__)) + '/Reports/OutPutFiles/' + InvoiceNumber
con = {
'driver': 'mysql',
'username': '******',
'password': '******',
'host': 'localhost',
'database': 'imsapp',
'port': '3306'
}
jasper = JasperPy()
jasper.process(input_file,
output_file=output,
format_list=["pdf"],
db_connection=con,
locale='en_US',
parameters={'InvoiceNO': str(InvoiceNumber)})
return output
def json_to_reports():
users = {'results': [{"name": "User {}".format(i)} for i in range(1, 11)]}
input_file = os.path.join(CURRENT_DIR, 'users-list.jrxml')
with open(JSON_FILENAME, 'w') as f:
json.dump(users, f)
json_query = 'results.name'
jasper = JasperPy()
jasper.process(
input_file,
output_file=OUTPUT_FILENAME,
format_list=['pdf', 'docx', 'html'],
parameters={},
db_connection={
'data_file': JSON_FILENAME,
'driver': 'json',
'json_query': json_query,
},
locale='pt_BR'
)
print('Files available in /tmp/ directory.')
def getReportDatabase():
try:
now = datetime.datetime.now()
datetimeStr = now.strftime('%Y%m%d_%H%M%S%f')
isSuccess = True
reasonCode = 200
reasonText = ""
dataInput = request.json
paramList = ['report_name', "param"]
paramCheckStringList = ['report_name']
msgError = checkParamDataInput(dataInput, paramList,
paramCheckStringList)
if msgError != None:
return jsonify(msgError)
reportName = dataInput['report_name']
param = dataInput['param']
input_file = '{}/report/{}.jrxml'.format(
os.path.dirname(os.path.abspath(__file__)), reportName)
compile_file = '{}/report/{}.jasper'.format(
os.path.dirname(os.path.abspath(__file__)), reportName)
output_file = '{}/output/{}'.format(
os.path.dirname(os.path.abspath(__file__)), datetimeStr)
resource_file = '{}/font/THSarabunPSK.jar'.format(
os.path.dirname(os.path.abspath(__file__)))
con = {
'driver':
'generic',
'jdbc_driver':
'com.microsoft.sqlserver.jdbc.SQLServerDriver',
'jdbc_url':
'jdbc:sqlserver://{};databaseName={}'.format(
mssql_server, mssql_database),
'username':
mssql_user,
'password':
mssql_password
}
jasper = JasperPy()
jasper.process(compile_file,
output_file=output_file,
format_list=["pdf"],
parameters=param,
db_connection=con,
locale='en_US',
resource=resource_file)
with open(output_file + '.pdf', "rb") as pdf_file:
encoded_string = base64.b64encode(pdf_file.read())
os.remove(output_file + '.pdf')
errColumns = ['isSuccess', 'reasonCode', 'reasonText', 'pdf_base64']
errData = [(isSuccess, reasonCode, reasonText, encoded_string)]
return jsonify(toJsonOne(errData, errColumns))
except Exception as e:
isSuccess = False
reasonCode = 500
errColumns = ['isSuccess', 'reasonCode', 'reasonText']
errData = [(isSuccess, reasonCode, str(e))]
return jsonify(toJsonOne(errData, errColumns))
def getReportByJSONBase64():
try:
now = datetime.datetime.now()
datetimeStr = now.strftime('%Y%m%d_%H%M%S%f')
isSuccess = True
reasonCode = 200
reasonText = ""
dataInput = request.json
paramList = ['report_name', 'data_json']
paramCheckStringList = ['report_name', 'data_json']
msgError = checkParamDataInput(dataInput, paramList,
paramCheckStringList)
if msgError != None:
return jsonify(msgError)
dataJson = dataInput['data_json']
reportName = dataInput['report_name']
input_file = '{}/report/{}.jrxml'.format(
os.path.dirname(os.path.abspath(__file__)), reportName)
compile_file = '{}/report/{}.jasper'.format(
os.path.dirname(os.path.abspath(__file__)), reportName)
output_file = '{}/output/{}'.format(
os.path.dirname(os.path.abspath(__file__)), datetimeStr)
data_file = '{}/data/data_tmp{}.json'.format(
os.path.dirname(os.path.abspath(__file__)), datetimeStr)
resource_file = '{}/font/THSarabunPSK.jar'.format(
os.path.dirname(os.path.abspath(__file__)))
file = codecs.open(data_file, "w", "utf-8")
file.write(json.dumps(dataJson[0]))
# file.write(str(dataJson))
file.close()
con = {
'data_file': data_file,
'driver': 'json',
'json_query': 'data',
}
jasper = JasperPy()
# jasper.compile(input_file)
jasper.process(compile_file,
output_file=output_file,
format_list=['pdf'],
parameters={},
db_connection=con,
locale='en_US',
resource=resource_file)
with open(output_file + '.pdf', "rb") as pdf_file:
encoded_string = base64.b64encode(pdf_file.read())
os.remove(output_file + '.pdf')
os.remove(data_file)
errColumns = ['isSuccess', 'reasonCode', 'reasonText', 'pdf_base64']
errData = [(isSuccess, reasonCode, reasonText, encoded_string)]
return jsonify(toJsonOne(errData, errColumns))
except Exception as e:
isSuccess = False
reasonCode = 500
errColumns = ['isSuccess', 'reasonCode', 'reasonText']
errData = [(isSuccess, reasonCode, str(e))]
return jsonify(toJsonOne(errData, errColumns))
class TestJasperPy(TestCase):
def setUp(self):
self.input_file = 'examples/hello_world.jrxml'
self.jasper = JasperPy()
def test_compile(self):
self.assertRaises(NameError, self.jasper.compile, False)
self.assertEqual(self.jasper.compile(self.input_file), 0)
def test_process(self):
self.assertRaises(NameError, self.jasper.process, False)
# test invalid format input. Must be list ['pdf']
kwargs = {
'input_file': self.input_file,
'format_list': 'pdf'
}
self.assertRaises(NameError, self.jasper.process, **kwargs)
# test invalid input format
kwargs = {
'input_file': self.input_file,
'format_list': 5
}
self.assertRaises(NameError, self.jasper.process, **kwargs)
# test invalid report format
kwargs = {
'input_file': self.input_file,
'format_list': ['mp3']
}
self.assertRaises(NameError, self.jasper.process, **kwargs)
# test
self.assertEqual(
self.jasper.process(self.input_file,
format_list=['pdf']), 0)
def test_list_parameters(self):
self.input_file = 'examples/hello_world_params.jrxml'
self.assertRaises(NameError, self.jasper.list_parameters, False)
self.assertEqual(self.jasper.list_parameters(self.input_file),
{
'myString': ['java.lang.String', ''],
'myInt': ['java.lang.Integer', ''],
'myDate': ['java.util.Date', ''],
'myImage': ['java.awt.Image',
'This is the description'
' of parameter myImage']
})
def test_execute(self):
self.assertEqual(self.jasper.execute(), 0)
self.jasper.path_executable = ''
self.assertRaises(NameError, self.jasper.execute, False)
def test_subreports(self):
input_file_header = 'examples/subreports/header.jrxml'
input_file_details = 'examples/subreports/details.jrxml'
input_file_main = 'examples/subreports/main.jrxml'
self.input_file = 'examples/subreports/main.jasper'
data_file = 'examples/subreports/contacts.xml'
self.jasper.compile(input_file_header)
self.jasper.compile(input_file_details)
self.jasper.compile(input_file_main)
self.assertEqual(
self.jasper.process(
self.input_file,
format_list=["pdf"],
parameters={},
db_connection={
'data_file': data_file,
'driver': 'xml',
'xml_xpath': '"/"',
},
locale='pt_BR', # LOCALE Ex.:(en_US, de_GE)
resource='examples/subreports/'
), 0)
def test_jsonql(self):
self.input_file = 'examples/jsonql.jrxml'
data_file = 'examples/contacts.json'
self.assertEqual(
self.jasper.process(
self.input_file,
format_list=["pdf"],
parameters={},
db_connection={
'data_file': data_file,
'driver': 'jsonql',
'jsonql_query': 'contacts.person',
},
locale='pt_BR', # LOCALE Ex.:(en_US, de_GE)
), 0)
def test_csv(self):
self.input_file = 'examples/csvMeta.jrxml'
data_file = 'examples/csvExampleHeaders.csv'
self.assertEqual(
self.jasper.process(
self.input_file,
format_list=["pdf"],
parameters={},
db_connection={
'data_file': data_file,
'driver': 'csv',
'csv_charset': 'utf8',
'csv_field_del': '|',
'csv_record_del': '\r\n',
#'csv_first_row': True,
'csv_columns': 'Name,Street,City,Phone'
},
locale='en_US', # LOCALE Ex.:(en_US, de_GE)
), 0)
class TestJasperPy(TestCase):
def setUp(self):
self.input_file = 'examples/hello_world.jrxml'
self.jasper = JasperPy()
def test_compile(self):
self.assertRaises(NameError, self.jasper.compile, False)
self.assertEqual(self.jasper.compile(self.input_file), 0)
def test_process(self):
self.assertRaises(NameError, self.jasper.process, False)
# test invalid format input. Must be list ['pdf']
kwargs = {'input_file': self.input_file, 'format_list': 'pdf'}
self.assertRaises(NameError, self.jasper.process, **kwargs)
# test invalid input format
kwargs = {'input_file': self.input_file, 'format_list': 5}
self.assertRaises(NameError, self.jasper.process, **kwargs)
# test invalid report format
kwargs = {'input_file': self.input_file, 'format_list': ['mp3']}
self.assertRaises(NameError, self.jasper.process, **kwargs)
# test
self.assertEqual(
self.jasper.process(self.input_file,
format_list=['pdf', 'odt', 'xls']), 0)
def test_list_parameters(self):
self.input_file = 'examples/hello_world_params.jrxml'
self.assertRaises(NameError, self.jasper.list_parameters, False)
self.assertEqual(
self.jasper.list_parameters(self.input_file), {
'myString': ['java.lang.String', ''],
'myInt': ['java.lang.Integer', ''],
'myDate': ['java.util.Date', ''],
'myImage': [
'java.awt.Image', 'This is the description'
' of parameter myImage'
]
})
def test_execute(self):
self.assertEqual(self.jasper.execute(), 0)
self.jasper.path_executable = ''
self.assertRaises(NameError, self.jasper.execute, False)
def test_subreports(self):
input_file_header = 'examples/subreports/header.jrxml'
input_file_details = 'examples/subreports/details.jrxml'
input_file_main = 'examples/subreports/main.jrxml'
self.input_file = 'examples/subreports/main.jasper'
data_file = 'examples/subreports/contacts.xml'
self.jasper.compile(input_file_header)
self.jasper.compile(input_file_details)
self.jasper.compile(input_file_main)
self.assertEqual(
self.jasper.process(
self.input_file,
format_list=["pdf"],
parameters={},
db_connection={
'data_file': data_file,
'driver': 'xml',
'xml_xpath': '"/"',
},
locale='pt_BR', # LOCALE Ex.:(en_US, de_GE)
resource='examples/subreports/'),
0)
class TestJasperPy(TestCase):
EXAMPLES_DIR = os.path.join(
os.path.dirname(os.path.abspath(os.path.dirname(__file__))),
'examples')
@ignore_warnings
def setUp(self):
self.input_file = os.path.join(self.EXAMPLES_DIR, 'hello_world.jrxml')
self.jasper = JasperPy()
@ignore_warnings
def test_compile(self):
self.assertRaises(NameError, self.jasper.compile, False)
self.assertEqual(self.jasper.compile(self.input_file), 0)
@ignore_warnings
def test_process(self):
self.assertRaises(NameError, self.jasper.process, False)
# test invalid format input. Must be list ['pdf']
kwargs = {'input_file': self.input_file, 'format_list': 'pdf'}
self.assertRaises(NameError, self.jasper.process, **kwargs)
# test invalid input format
kwargs = {'input_file': self.input_file, 'format_list': 5}
self.assertRaises(NameError, self.jasper.process, **kwargs)
# test invalid report format
kwargs = {'input_file': self.input_file, 'format_list': ['mp3']}
self.assertRaises(NameError, self.jasper.process, **kwargs)
# test
kwargs = {'input_file': self.input_file, 'format_list': ['pdf']}
self.assertEqual(self.jasper.process(**kwargs), 0)
@ignore_warnings
def test_subreports(self):
input_file_header = os.path.join(self.EXAMPLES_DIR, 'subreports',
'header.jrxml')
input_file_details = os.path.join(self.EXAMPLES_DIR, 'subreports',
'details.jrxml')
input_file_main = os.path.join(self.EXAMPLES_DIR, 'subreports',
'main.jrxml')
self.input_file = os.path.join(self.EXAMPLES_DIR, 'subreports',
'main.jasper')
data_file = os.path.join(self.EXAMPLES_DIR, 'subreports',
'contacts.xml')
resources = os.path.join(self.EXAMPLES_DIR, 'subreports') + os.sep
self.jasper.compile(input_file_header)
self.jasper.compile(input_file_details)
self.jasper.compile(input_file_main)
self.assertEqual(
self.jasper.process(
self.input_file,
format_list=["pdf"],
parameters={},
db_connection={
'data_file': data_file,
'driver': 'xml',
'xml_xpath': '/',
},
locale='pt_BR', # LOCALE Ex.:(en_US, de_GE)
resource=resources),
0)
@ignore_warnings
def test_jsonql(self):
self.input_file = os.path.join(self.EXAMPLES_DIR, 'jsonql.jrxml')
data_file = os.path.join(self.EXAMPLES_DIR, 'contacts.json')
self.assertEqual(
self.jasper.process(
self.input_file,
format_list=["pdf"],
parameters={},
db_connection={
'data_file': data_file,
'driver': 'jsonql',
'jsonql_query': 'contacts.person',
'json_locale': 'es_ES'
},
locale='pt_BR', # LOCALE Ex.:(en_US, de_GE)
),
0)
@ignore_warnings
def test_json_process(self):
self.input_file = os.path.join(self.EXAMPLES_DIR, 'jsonql.jrxml')
data_file = os.path.join(self.EXAMPLES_DIR, 'contacts.json')
self.assertEqual(
self.jasper.process_json(
self.input_file,
format_list=["pdf"],
parameters={},
connection={
'data_file': data_file,
'driver': 'jsonql',
'jsonql_query': 'contacts.person',
'json_locale': 'es_ES',
'json_date_pattern': 'yyyy-MM-dd',
'json_number_pattern': '#,##0.##"'
},
locale='pt_BR', # LOCALE Ex.:(en_US, de_GE)
),
0)
@ignore_warnings
def test_json_url(self):
self.input_file = os.path.join(self.EXAMPLES_DIR, 'jsonql.jrxml')
self.assertEqual(
self.jasper.process_json(
self.input_file,
format_list=["pdf"],
parameters={},
connection={
'url_file':
'https://acesseonline-arquivos-publicos.s3.us-east-2.amazonaws.com/contacts.json',
'url_method': 'GET', # POST, PUT
# 'url_params': {'param1': 'test'},
# 'url_data': {'data_field': 'abc123'},
# 'url_header': {'Authorization': 'Bearer xxxxxxxxxxxxxxxxxx'},
'driver': 'jsonql',
'jsonql_query': 'contacts.person',
'json_locale': 'es_ES',
'json_date_pattern': 'yyyy-MM-dd',
'json_number_pattern': '#,##0.##"'
},
locale='pt_BR', # LOCALE Ex.:(en_US, de_GE)
),
0)
@ignore_warnings
def test_csv(self):
self.input_file = os.path.join(self.EXAMPLES_DIR, 'csvMeta.jrxml')
data_file = os.path.join(self.EXAMPLES_DIR, 'csvExampleHeaders.csv')
self.assertEqual(
self.jasper.process(
self.input_file,
format_list=["pdf"],
parameters={},
db_connection={
'data_file': data_file,
'driver': 'csv',
'csv_charset': 'utf8',
'csv_field_del': '|',
'csv_record_del': '\r\n',
'csv_columns': 'Name,Street,City,Phone'
},
locale='en_US', # LOCALE Ex.:(en_US, de_GE)
),
0)
