def json(report_config):
"""
Output report on json-format
:param report_config: report configuration
:type report_config: dict
:return: True if no error
:rtype: bool
"""
data_list = []
connect = database_connect(report_config['connection'].replace('~', os.getenv('HOME')), logger)
cursor = connect.cursor()
logger.info('%s json-%s' % (_('working'), _('generator')))
with open('%s.json' % cmd_args.output, 'w') as f:
for sql in report_config['sql']:
parameters_list = {}
for parm in cmd_args.parameters:
p = parm.split('=')
if p[1].endswith(','):
p[1] = p[1][:-1]
parameters_list[p[0]] = p[1]
for parameter in parameters_list:
sql = sql.replace('{{%s}}' % parameter, parameters_list[parameter])
cursor.execute(sql)
columns = [col[0] for col in cursor.description]
data = [dict(zip(columns, (str(y) if y is not None else '' for y in rw))) for rw in cursor.fetchall()]
data_list.append(data)
f.write(json_lib.dumps(data_list, ensure_ascii=False, indent=4))
return True
def callback_terminate(code, parameters):
"""
Terminate program
:param code: exit code
:type code: int
:param parameters: post parameters for callback
:type parameters: dict
"""
parameters['status'] = code
if cmd_args.token:
response = callback(parameters)
logger.debug('%s: %s' %
(_('callback response'), response.get('result', 'None')))
if server.is_alive():
server.terminate()
server.join()
logger.debug('%s: %s' % (_('reporter result'), json.dumps(parameters)))
logger.info(_('reporter ended'))
exit(code)
def bottle_callback():
"""
Callback handler
:return: response
:rtype: str
"""
logger.debug(
'%s: \'%s\'' %
(_('callback received data'), unquote(request.body.read().decode())))
return '{"result": "Ok"}'
def tab(report_config):
"""
Output report for jquery.dataTables
:param report_config: report configuration
:type report_config: dict
:return: True if no error
:rtype: bool
"""
data_list, columns_list, suppress = [], [], report_config.get(
'suppress', 0)
connect = database_connect(
report_config['connection'].replace('~', os.getenv('HOME')), logger)
cursor = connect.cursor()
logger.info('%s tab-%s' % (_('working'), _('generator')))
with open('%s.tab' % cmd_args.output, 'w') as f:
for sql in report_config['sql']:
if sql.startswith('SKIP'):
data, skip, description = [], [
x.strip() for x in sql.split('=')
], ()
for _x in range(int(skip[1]) if len(skip) > 1 else 1):
data_list.append([])
else:
parameters_list = {}
for parm in cmd_args.parameters:
p = parm.split('=')
if p[1].endswith(','):
p[1] = p[1][:-1]
parameters_list[p[0]] = p[1]
for parameter in parameters_list:
sql = sql.replace('{{%s}}' % parameter,
parameters_list[parameter])
cursor.execute(sql)
columns = [col[0] for col in cursor.description]
data = [
dict(zip(columns, (str(y) for y in rw)))
for rw in cursor.fetchall()
]
columns_list.append(columns)
data_list.append(data)
max_row_len = max([len(x) for x in columns_list])
data_file = []
if len(data_list):
for i, columns in enumerate(columns_list):
while data_list and not data_list[i]:
data_file.append(['' for _x in range(max_row_len)])
data_list.pop(i)
if not data_list:
data_file = []
suppress_list = [None] * max_row_len
if len(columns_list) > 1:
row_data = [
'<b><u>%s</u></b>' % report_config['headings'][i]
]
while len(row_data) < max_row_len:
row_data.append('')
data_file.append(row_data)
row_data = []
for column in columns:
row_data.append('<b>%s</b>' % column)
while len(row_data) < max_row_len:
row_data.append('')
data_file.append(row_data)
if not data_list:
break
data_length = len(data_list[i])
for j, row in enumerate(data_list[i]):
suppress_enable, row_data = True, []
for k, column in enumerate(columns_list[i]):
if not row[column] or row[column] == 'None':
row[column] = ''
if row[column] != suppress_list[k]:
suppress_list[k] = row[column]
suppress_enable = False
elif k < suppress and suppress_enable:
row[column] = ''
row_data.append(row[column].split('/////')[0].strip())
while len(row_data) < max_row_len:
row_data.append('')
data_file.append(row_data)
if i == len(columns_list) - 1 and not (j + 1) % int(
cmd_args.frequency):
callback({
'status': -1,
'progress_data': j + 1,
'message': 'In progress',
'length_data': data_length
})
if i == len(columns_list) - 1:
callback({
'status': -1,
'progress_data': data_length,
'message': 'In progress',
'length_data': data_length
})
if len(columns_list) > 1:
row_data = []
while len(row_data) < max_row_len:
row_data.append('')
data_file.append(row_data)
if len(columns_list) > 1:
data_file = data_file[:-1]
f.write(json.dumps({"data": data_file}, indent=4))
return True
def main():
sys.path.append('../')
sys.path.append('/app')
from db_report.utils.callback import server
from db_report.utils.helpers import error_handler
from db_report.utils.callback import callback_terminate
from db_report.config import translate as _, logger, cmd_args
if cmd_args.callback_url == 'http://localhost:8080' and cmd_args.token:
server.start()
time.sleep(1)
form = None
logger.info(
'%s, %s: %s' %
(_('reporter started'), _('logging level'), cmd_args.log_level))
logger.info('%s \'%s\'' % (_('report name'), cmd_args.name))
try:
with open('%s%s.json' % (cmd_args.reports, cmd_args.name),
'r') as config_file:
report_config = json.load(config_file)
form = report_config.get('format', 'csv')
if cmd_args.database:
report_config['connection'] = cmd_args.database
report_config['headings'] = [
x[1]
for x in sorted([[int(parm.split('=')[0][5:]),
parm.split('=')[1]]
for parm in cmd_args.parameters
if parm.split('=')[0].startswith('title')])
]
if not report_config['headings'] and cmd_args.headings:
report_config['headings'] = cmd_args.headings
if cmd_args.sql:
report_config['sql'] = cmd_args.sql.split('|||')
condition_code = getattr(
importlib.import_module('db_report.formats.%s' % form),
form)(report_config)
file_path = '%s.%s' % (cmd_args.output, form)
logger.info('%s \'%s\'' % (_('output file'), file_path))
if condition_code:
callback_terminate(0, {'result': file_path, 'message': 'Success'})
else:
callback_terminate(3, {
'result': 'empty',
'message': 'Fatal error'
})
except FileNotFoundError:
logger.error("%s \'%s\' %s" %
(_('report'), cmd_args.name, _('does not exists')))
callback_terminate(
1, {
'result': 'empty',
'message': 'Report \'%s\' does not exists' % cmd_args.name
})
except ImportError as e:
logger.error("%s \'%s\' %s" %
(_('format'), form, _('not implemented')))
callback_terminate(2, {
'result': 'empty',
'message': 'Format \'%s\' not implemented' % form
})
except Exception as e:
error_handler(logger, e, '', False, True)
callback_terminate(3, {
'result': 'empty',
'message': 'Unexpected error: %s' % str(e)
})
def csv(report_config):
"""
Output report in csv
:param report_config: report configuration
:type report_config: dict
:return: True if no error
:rtype: bool
"""
suppress = report_config.get('suppress', 0)
connect = database_connect(
report_config['connection'].replace('~', os.getenv('HOME')), logger)
cursor = connect.cursor()
logger.info('%s csv-%s' % (_('working'), _('generator')))
skips = 0
with open('%s.csv' % cmd_args.output, 'w') as f:
for i, sql in enumerate(report_config['sql']):
if sql.startswith('SKIP'):
data, skip, description = [], [
x.strip() for x in sql.split('=')
], ()
for _x in range(int(skip[1]) if len(skip) > 1 else 1):
data.append(('', ))
skips += 1
else:
parameters_list = {}
for parm in cmd_args.parameters:
p = parm.split('=')
if p[1].endswith(','):
p[1] = p[1][:-1]
parameters_list[p[0]] = p[1]
for parameter in parameters_list:
sql = sql.replace('{{%s}}' % parameter,
parameters_list[parameter])
cursor.execute(sql)
data, description = cursor.fetchall(), cursor.description
title_found = False
title = 'title%s' % (i - skips)
for parm in cmd_args.parameters:
if parm.startswith(title):
title_found = True
heading = parm.split('=')[1]
if heading[-1] == ',':
heading = heading[:-1]
f.write(heading)
if not title_found:
f.write(report_config['headings'][i - skips])
f.write('\n\n')
description_string = ''
for column_name in description:
description_string += '%s%s' % (
column_name[0], report_config.get('field_delimiter', ';'))
if description_string:
f.write(description_string[:-1])
f.write('\n')
length_data = len(data)
suppress_list = [None] * len(description)
for j, row in enumerate(data):
suppress_enable, data_string = True, ''
for k, column in enumerate(row):
if not column or column == 'None':
column = ''
if suppress_list and column != suppress_list[k]:
suppress_list[k] = column
suppress_enable = False
elif k < suppress and suppress_enable:
column = ''
column = str(column).split('/////')[0].strip()
data_string += '%s%s' % (
column, report_config.get('field_delimiter', ';'))
f.write(data_string[:-1])
f.write('\n')
if not (j + 1) % int(cmd_args.frequency):
callback({
'status': -1,
'progress_data': j + 1,
'message': 'In progress',
'length_data': length_data
})
if not sql.startswith('SKIP'):
callback({
'status': -1,
'progress_data': length_data,
'message': 'In progress',
'length_data': length_data
})
cursor.close()
connect.close()
return True