def initComboBoxScanners(self, select_scanner=None):
"""
Initialization of the combobox list of system scanners.
:param select_scanner: Which scanner to choose after
initialization of the combo box,
if None, then the first one in the list is selected.
"""
scanner_devices = self.scan_manager.getDeviceNames()
self.scanner_comboBox.Clear()
if scanner_devices:
default_select = 0
i = 0
for scanner_name in scanner_devices:
img_filename = os.path.normpath(os.path.join(os.path.dirname(__file__), u'img', u'scanner.png'))
if scanner_name == select_scanner:
default_select = i
self.scanner_comboBox.Append(scanner_name, wx.Image.ConvertToBitmap(wx.Image(img_filename)))
i += 1
self.scanner_comboBox.Select(default_select)
else:
log_func.warning(u'No scan devices found')
msg = u'No scan devices found. Check if the devices are on / connected to them.'
dlg_func.openWarningBox(u'WARNING', msg)
try:
self.EndModal(wx.ID_CANCEL)
except:
log_func.fatal()
def _prevGenerateVar(self, variables, value=None):
"""
Prepare variable dictionary.
:param variables: Valiable dictionary.
:param value: Current value.
"""
if value is None:
for name, value in variables.items():
variables[name] = self._prevGenerateVar(variables, str(value))
return variables
else:
# Replace
value = value.replace('\r\n', '\n').strip()
# Parse
parsed = self._parseFuncText(value)
values = []
for cur_var in parsed['func']:
if re.search(RTF_VAR_PATTERN, cur_var):
if cur_var[1:-1] in variables:
values.append(
self._prevGenerateVar(variables,
variables[cur_var[1:-1]]))
else:
values.append('')
else:
log_func.warning(u'Unsupported tag <%s>' % cur_var)
val_str = self._valueFormat(parsed['fmt'], values)
return val_str
def setExtOptions(self, **options):
"""
Set advanced options.
:param options: Dictionary of options.
"""
log_func.debug(u'Scan options: %s' % options)
if options:
if 'scanner' in options:
self.scanner = options.get('scanner', None)
if 'source' in options:
self.scan_source = options.get('source', None)
if 'mode' in options:
self.scan_mode = options.get('mode', None)
if 'is_multi_scan' in options:
self.is_multi_scan = options.get('is_multi_scan', None)
if 'is_preview' in options:
self.is_preview = options.get('is_preview', None)
if 'page_size' in options:
self.page_size = options.get('page_size', None)
if 'area' in options:
self.scan_area = options.get('area', None)
if 'scan_dir' in options:
self.scan_dir = options.get('scan_dir', None)
if 'file_name' in options:
self.scan_filename = options.get('file_name', None)
if 'file_type' in options:
self.scan_filetype = options.get('file_type', None)
if 'depth' in options:
self.depth = options.get('depth', None)
if 'ext_scan_cmd' in options:
self.ext_scan_cmd = options.get('ext_scan_cmd', None)
else:
log_func.warning(u'Undefined scan options for set')
def _appendItemsReportTree(self, parent_id, items):
"""
Add tree items based on the received report description.
:param parent_id: Parent item id.
:param items: Report data branch.
"""
if not items:
log_func.warning(
u'An empty list of report descriptions when building a report tree'
)
for item_data in items:
item = self.rep_tree.AppendItem(parent_id,
item_data[REP_DESCRIPTION_IDX],
-1,
-1,
data=None)
if item_data[REP_ITEMS_IDX] is not None:
self._appendItemsReportTree(item, item_data[REP_ITEMS_IDX])
self.rep_tree.SetItemImage(item, 0, wx.TreeItemIcon_Normal)
self.rep_tree.SetItemImage(item, 0, wx.TreeItemIcon_Selected)
else:
self.rep_tree.SetItemImage(item, item_data[REP_IMG_IDX],
wx.TreeItemIcon_Normal)
self.rep_tree.SetItemImage(item, item_data[REP_IMG_IDX],
wx.TreeItemIcon_Selected)
self.rep_tree.SetItemData(item, item_data)
def generateReport(self, report=None, *args, **kwargs):
"""
Run report generator.
:param report: Report template data.
:return: Generated report or None if error.
"""
try:
if report is not None:
self._report_template = report
# 1. Get query table
# Variables
variables = kwargs.get('variables', None)
if variables:
kwargs.update(variables)
query_tbl = self.getQueryTbl(self._report_template)
if not query_tbl or not query_tbl['__data__']:
if not global_func.isCUIEngine():
if dlg_func.openAskBox(u'WARNING',
u'No report data\nQuery: %s\nContinue report generation?' % self._report_template['query']):
return None
else:
log_func.warning(u'No report data. Continue generation.')
query_tbl = self.createEmptyQueryTbl()
# 2. Run generation
rep = report_generator.iqReportGenerator()
data_rep = rep.generate(self._report_template, query_tbl)
return data_rep
except:
log_func.fatal(u'Error generate report <%s>' % self._report_template['name'])
return None
def setTestingComponent(self, component):
"""
Set testing component.
:param component: Testing component.
:return:
"""
self.testing_component = component
log_func.info(u'Testing component <%s>' %
(self.testing_component.getName()
if self.testing_component is not None else None))
tab_datasource = component.getTabDataSource() if component else None
if tab_datasource is None:
msg = u'The table datasource object is not set in the transform datasource results view window\nResult is empty'
log_func.warning(msg)
dlg_func.openWarningBox(title=u'WARNING', prompt_text=msg)
elif isinstance(tab_datasource, data_query.COMPONENT):
sql_query = tab_datasource.getSQLText()
if txtgen_func.isGenered(sql_query):
var_names = txtgen_func.getReplaceNames(sql_query)
self.variables = dict([(name, u'') for name in var_names])
self.setVariables(self.variables)
else:
log_func.warning(u'Type error table datasource for testing <%s>' %
tab_datasource.__class__.__name__)
def setScanOptions(self, **options):
"""
Set Scan Options
:param options: Options.
:return: True/False.
"""
try:
global SCAN_OPTIONS_ORDER
for option_name in SCAN_OPTIONS_ORDER:
if option_name in options:
option_val = options[option_name]
try:
setattr(self.scan_device_obj, option_name, option_val)
log_func.info(u'Set scan option <%s>. Value <%s>' %
(option_name, option_val))
# Remember the option values set.
# It may be that we install the options in the device,
# but for some reason they are not set :-(
self.options[option_name] = option_val
except:
log_func.warning(
u'Error setting scan option <%s>. Value <%s>' %
(option_name, option_val))
return True
except:
log_func.fatal(u'Error setting scan options')
return False
def edit(self, rep_filename=None):
"""
Edit report.
:param rep_filename: Report template filename.
"""
rprt_file_name = os.path.abspath(rep_filename)
rep = res_func.loadResource(rprt_file_name)
report_dir = os.path.abspath(self.getReportDir())
rep_file = os.path.join(report_dir, rep['generator'])
reportman_designer_key = utilfunc.getRegValue(
'Software\\Classes\\Report Manager Designer\\shell\\open\\command',
None)
if reportman_designer_key:
reportman_designer_run = reportman_designer_key.replace(
'\'%1\'', '\'%s\'') % rep_file
cmd = 'start %s' % reportman_designer_run
log_func.debug(u'Execute command <%s>' % cmd)
# Run Report Manager Designer
os.system(cmd)
else:
msg = u'Not define Report Manager Designer <%s>' % reportman_designer_key
log_func.warning(msg)
dlg_func.openWarningBox(u'WARNING', msg)
xml_file = os.path.normpath(
os.path.abspath(os.path.splitext(rep_filename)[0] + '.xml'))
cmd = 'start excel.exe \'%s\'' % xml_file
log_func.debug(u'Execute command <%s>' % cmd)
os.system(cmd)
def refreshTableData(self, tab_data_src=None, **kwargs):
"""
Refresh tabular data.
:param tab_data_src: Tabular data source object.
:param kwargs: Extra name arguments.
Additional parameters for generating executable text
SQL query for example.
:return: Updated tabular data.
"""
if tab_data_src is None:
tab_data_src = self._data_source
if isinstance(tab_data_src, data_model.COMPONENT):
self._table_data = tab_data_src.get_normalized(**kwargs)
self._table_data = self.setFilter(self._table_data)
return self._table_data
elif isinstance(tab_data_src, data_query.COMPONENT):
self._table_data = tab_data_src.execute(**kwargs)
self._table_data = self.setFilter(self._table_data)
return self._table_data
elif tab_data_src is None:
log_func.warning(u'Data source table object not defined in control <%s>' % self.getName())
else:
log_func.warning(u'Incorrect table datasource type <%s>' % tab_data_src.__class__.__name__)
return None
def getReportDir(self):
"""
Get report folder path.
:return: Report folder path.
"""
if self._report_dir is None:
prj_dir = file_func.getProjectPath()
prj_dir = prj_dir if prj_dir else DEFAULT_REPORTS_PATH
self._report_dir = os.path.join(prj_dir, DEFAULT_REPORT_DIRNAME)
if not os.path.exists(self._report_dir):
try:
os.makedirs(self._report_dir)
log_func.info(u'Create folder <%s>' % self._report_dir)
description_filename = os.path.join(
self._report_dir, 'descript.ion')
prj_name = os.path.basename(prj_dir)
txtfile_func.saveTextFile(
description_filename,
u'<%s> project reports' % prj_name)
init_filename = os.path.join(self._report_dir,
'__init__.py')
txtfile_func.saveTextFile(init_filename,
DEFAULT_INIT_PY_FMT % prj_name)
except IOError:
log_func.warning(u'Error create folder <%s>' %
self._report_dir)
return self._report_dir
def edit(self, rep_filename=None):
"""
Edit report.
:param rep_filename: Report template filename.
"""
# Set *.xls filename
xls_filename = os.path.abspath(
os.path.splitext(rep_filename)[0] + XLS_FILENAME_EXT)
if sys_func.isLinuxPlatform():
cmd = '%s \"%s\"&' % (report_gen_system.UNIX_OFFICE_OPEN,
xls_filename)
log_func.info('Execute command <%s>' % cmd)
os.system(cmd)
return True
elif sys_func.isWindowsPlatform():
win_office_open = iq.KERNEL.settings.THIS.SETTINGS.win_libreoffice_run.get(
)
cmd = '%s \"%s\"&' % (win_office_open if win_office_open else
report_gen_system.WIN_OFFICE_OPEN,
xls_filename)
log_func.info(u'Execute command <%s>' % cmd)
os.system(cmd)
return True
else:
log_func.warning(u'Unsupported platform <%s>' %
sys_func.getPlatform())
return False
def getLabel(self, record, table_data=None):
"""
Function for getting the label of an element.
:param record: The current record being processed.
:param table_data: Table data.
:return: Selection text.
"""
if table_data is None:
table_data = self.getTableData()
label = u''
label_field_name = self.getLabelField()
if label_field_name:
label = record.get(label_field_name, u'')
else:
# If the field name is not defined,
# then the function of defining the label of the element must be defined
is_label_func = self.isLabelFunc()
if is_label_func:
rec_dict = self._data_source.get_record_dict(normal_data=table_data,
record=record)
label = self.getLabelFunc(RECORD=rec_dict)
if label is None:
label = u''
else:
log_func.warning(u'Method for getting the label of a picklist item in a component is not defined <%s>' % self.__class__.__name__)
return label
def setPlot(self, graph_filename, count=1):
"""
Set charting.
:param graph_filename: Chart data file full name.
:param count: The number of graphs.
:return: True/False.
"""
global DATETIME_GRAPH_DATA_FMT
cmd_sign = 'plot '
if os.path.exists(graph_filename):
# If time is broken down by date and time, then the number in the using section increases
params = ['\'%s\' using 1:%d with lines linestyle %d' % (graph_filename,
i + 2 + DATETIME_GRAPH_DATA_FMT.count(' '),
i + 1) for i in range(count)]
cmd = cmd_sign + ', '.join(params)
else:
# If there is no data, then display an abstract graph
log_func.warning(u'Graph data file <%s> not found' % graph_filename)
cmd = 'plot [-pi:pi] sin(x), cos(x)'
# The chart rendering command can only be the last command.
if not self.commands:
self.commands.append(cmd)
else:
self._deleteCommand(cmd_sign)
last_cmd = self.commands[-1]
if last_cmd.startswith(cmd_sign):
self.commands[-1] = cmd
else:
self.commands.append(cmd)
return True
def openOffice(self, xls_filename):
"""
Open XLS report in Office.
:param xls_filename: Report XLS filename.
"""
if xls_filename and os.path.exists(xls_filename):
if sys_func.isLinuxPlatform():
cmd = '%s %s&' % (report_gen_system.UNIX_OFFICE_OPEN,
xls_filename)
log_func.info('Execute command <%s>' % cmd)
os.system(cmd)
return True
elif sys_func.isWindowsPlatform():
win_office_open = iq.KERNEL.settings.THIS.SETTINGS.win_libreoffice_run.get(
)
cmd = '%s %s&' % (win_office_open if win_office_open else
report_gen_system.WIN_OFFICE_OPEN,
xls_filename)
log_func.info(u'Execute command <%s>' % cmd)
os.system(cmd)
return True
else:
log_func.warning(u'Unsupported platform <%s>' %
sys_func.getPlatform())
else:
log_func.warning(u'Open. Report file <%s> not exists' %
xls_filename)
return False
def setPinMarker(self,
geo_latitude,
geo_longitude,
color='blue',
icon=None,
popup_text=u'',
tooltip_text=u''):
"""
Adding a pointer marker to the map.
:param geo_latitude: Geographic latitude.
:param geo_longitude: Geographic longitude.
:param color: Marker color.
:param icon: Marker icon.
:param popup_text: Marker pop-up text.
A tooltip appears by clicking on the marker.
:param tooltip_text: Marker tooltip text.
A tooltip appears when you hover the mouse over the marker.
:return: True/False.
"""
if self._geo_map is not None:
try:
marker = self._rendering.Marker(
location=[geo_latitude, geo_longitude],
popup=popup_text if popup_text else None,
tooltip=tooltip_text if tooltip_text else None,
icon=icon)
marker.add_to(self._geo_map)
# log_func.debug(u'Pin marker created. Geolocation [%s x %s]' % (geo_latitude, geo_longitude))
return True
except:
log_func.fatal(u'Error adding a pointer marker to the map')
else:
log_func.warning(u'Map object not defined to add a pointer marker')
return False
def setChoices(self, table_data=None, is_empty=True):
"""
Setting the picklist.
:param table_data: Table data.
:param is_empty: Is there an empty string in the list?
:return: True/False.
"""
if table_data is None:
table_data = self.getTableData()
else:
self._table_data = table_data
if table_data is not None:
# First, remove all elements
self.Clear()
# Then fill in
try:
if is_empty:
self.Append(u'')
for record in table_data:
label = self.getLabel(record, table_data)
self.Append(label)
self.SetSelection(0)
return True
except:
log_func.fatal(u'Error filling select list with data')
else:
log_func.warning(u'Not defined table data in control <%s>' % self.getName())
return False
def _imageDrawCanvas(self,
image,
canvas,
n,
page_size=DEFAULT_IMAGE_PAGE_SIZE):
"""
Output the scanned page to a PDF canvas.
:param image: Image object of the scanned page.
:param canvas: PDF canvas object.
:param n: Page number.
:param page_size: Page size in dots,
to which all scanned pages will be brought.
:return: True/False.
"""
if image:
img_filename = os.path.join(file_func.getHomePath(),
MULTISCAN_PAGE_FILENAME % n)
width, height = page_size
image = image.resize((int(width), int(height)))
image.save(img_filename)
canvas.drawImage(img_filename, 0, 0)
canvas.showPage()
return True
else:
log_func.warning(u'Error writing scanned page [%d] to PDF file' %
n)
return False
def setCircleMarker(self,
geo_latitude,
geo_longitude,
radius=100,
color='blue',
is_fill=True,
fill_color='blue',
popup_text=u'',
tooltip_text=u''):
"""
Adding a circle marker to the map.
:param geo_latitude: Geographic latitude.
:param geo_longitude: Geographic longitude.
:param radius: The radius of the circle.
:param color: Circle color.
:param is_fill: Fill the inner area of the circle?
:param fill_color: The fill color of the circle.
:param popup_text: Marker pop-up text.
A tooltip appears by clicking on the marker.
:param tooltip_text: Marker tooltip text.
A tooltip appears when you hover the mouse over the marker.
:return: True/False.
"""
log_func.warning(u'setCircleMarker not defined in <%s> component' %
self.__class__.__name__)
return False
def viewTransforDataSourceDlg(parent=None, component=None):
"""
View transform datasource result dialog.
:param parent: Parent window.
:param component: Testing component.
:return: True/False.
"""
if component is None:
log_func.warning(u'Type error testing component')
return False
if parent is None:
parent = global_func.getMainWin()
dlg = None
try:
dlg = iqViewTransformDataSourceDialog(parent)
dlg.setTestingComponent(component)
dlg.init()
dlg.ShowModal()
dlg.Destroy()
return True
except:
log_func.fatal(u'Error view transform datasource result dialog')
if dlg:
dlg.Destroy()
return False
def getSelectedRecord(self, table_data=None, selected_idx=-1):
"""
Get the selected record by the index of the selected item.
:param table_data: Table data.
:param selected_idx: The index of the selected item.
:return: Dictionary of the selected entry, or None on error.
"""
if selected_idx < 0:
# Nothing selected
selected_idx = self.GetSelection() - (1 if self.getCanEmpty() else 0)
if selected_idx < 0:
# Nothing selected
return None
if table_data is None:
table_data = self.getTableData()
if table_data is not None:
records = table_data
len_records = len(records)
if 0 <= selected_idx < len_records:
try:
record = records[selected_idx]
return record
except:
log_func.fatal(u'Error retrieving selected record')
else:
log_func.warning(u'Incorrect index <%d>. Number of records <%d>' % (selected_idx, len_records))
else:
log_func.warning(u'Not defined table data in control <%s>' % self.getName())
return None
def get(self, parent=None, *arg, **kwarg):
"""
Get an object.
"""
kernel = global_func.getKernel()
if kernel:
psp = self.passport()
obj = kernel.findObject(psp)
if obj:
return obj
context = None
if 'context' in kwarg:
if isinstance(kwarg['context'], dict):
context = object_context.iqContext(kernel=kernel)
context.update(kwarg['context'])
else:
context = kwarg['context']
del kwarg['context']
obj = kernel.getObject(psp=psp,
parent=parent,
context=context,
*arg,
**kwarg)
return obj
else:
log_func.warning(u'Kernel object not defined')
return None
def appendDBFNewField(dbf_filename,
new_fieldname,
field_type,
field_length,
default=None):
"""
Append new field inDBF table.
:param dbf_filename: DBF filename.
:param new_fieldname: New field name.
:param field_type: Field type (C-string and etc).
:param field_length: Field length.
:param default: Default value.
:return: DBF table object.
"""
dbf_filename = os.path.abspath(dbf_filename)
if not os.path.exists(dbf_filename):
log_func.warning(u'DBF file <%s> not found' % dbf_filename)
return None
dbf_connection = None
try:
dbf_url = DBF_DB_URL_FMT % (os.path.dirname(dbf_filename),
DEFAULT_DBF_ENCODING)
dbf_connection = jaydebeapi.connect('com.hxtt.sql.dbf.DBFDriver',
[dbf_url], JDBC_DBF_DRIVER)
if field_type == 'C':
db_cursor = dbf_connection.cursor()
sql = 'ALTER TABLE %s ADD %s VARCHAR(%d)' % (os.path.splitext(
os.path.basename(dbf_filename))[0], new_fieldname,
field_length)
if default is not None:
sql += ' DEFAULT \'%s\'' % str(default)
log_func.debug(u'Execute SQL <%s>' % sql)
db_cursor.execute(sql)
elif field_type == 'L':
db_cursor = dbf_connection.cursor()
sql = 'ALTER TABLE %s ADD %s BOOLEAN' % (os.path.splitext(
os.path.basename(dbf_filename))[0], new_fieldname)
if default is not None:
sql += ' DEFAULT %s' % str(default)
db_cursor.execute(sql)
elif field_type == 'D':
db_cursor = dbf_connection.cursor()
sql = 'ALTER TABLE %s ADD %s DATE' % (os.path.splitext(
os.path.basename(dbf_filename))[0], new_fieldname)
if default is not None:
sql += ' DEFAULT \'%s\'' % str(default)
db_cursor.execute(sql)
else:
log_func.warning(u'Unsupported field type <%s>' % field_type)
dbf_connection.close()
except:
if dbf_connection:
dbf_connection.close()
log_func.fatal(u'Error append new field DBF file <%s>' % dbf_filename)
return None
def write(self, rep_filename, rec_data):
"""
Save the completed report to a file.
:param rep_filename: Report filename.
:param rec_data: Report data.
:return: Created xml filename or None if error.
"""
xml_file = None
if not rep_filename:
log_func.warning(u'Not define report file')
return None
try:
rep_dirname = os.path.dirname(rep_filename)
if not os.path.exists(rep_dirname):
file_func.createDir(rep_dirname)
xml_file = open(rep_filename, 'wt')
xml_gen = iqXMLSSGenerator(xml_file)
xml_gen.startDocument()
xml_gen.startBook()
# Page setup
# xml_gen.savePageSetup(rep_name,report)
# Styles
xml_gen.scanStyles(rec_data['sheet'])
xml_gen.saveStyles()
# Data
xml_gen.startSheet(rec_data['name'], rec_data)
xml_gen.saveColumns(rec_data['sheet'])
for i_row in range(len(rec_data['sheet'])):
xml_gen.startRow(rec_data['sheet'][i_row])
# Reset cell index
xml_gen.cell_idx = 1
for i_col in range(len(rec_data['sheet'][i_row])):
cell = rec_data['sheet'][i_row][i_col]
xml_gen.saveCell(i_row + 1, i_col + 1, cell,
rec_data['sheet'])
xml_gen.endRow()
xml_gen.endSheet(rec_data)
xml_gen.endBook()
xml_gen.endDocument()
xml_file.close()
return rep_filename
except:
if xml_file:
xml_file.close()
log_func.fatal(u'Error report write <%s>' %
str_func.toUnicode(rep_filename))
return None
def doReport(parent_form=None,
report_filename='',
report_dir='',
db_url='',
sql='',
command=None,
stylelib_filename=None,
variables=None):
"""
The function starts the report generator.
:param parent_form: The parent form, if not specified, creates a new application.
:param report_filename: Report filename.
:param report_dir: Directory where reports are stored.
:param db_url: URL Connection string.
For example:
postgresql+psycopg2://postgres:[email protected]:5432/realization.
:param sql: SQL query text.
:param command: After generation command. print/preview/export.
:param stylelib_filename: Style library filename.
:param variables: A dictionary of variables to populate the report.
:return: True/False.
"""
try:
if not report_filename:
return openReportViewer(parent_form, report_dir)
else:
repgen_system = report_gen_func.getReportGeneratorSystem(
report_filename, parent_form)
stylelib = loadStyleLib(stylelib_filename)
data = repgen_system.generate(
res_func.loadResource(report_filename),
db_url,
sql,
stylelib=stylelib,
vars=variables)
if command:
command = command.lower()
if command == DO_COMMAND_PRINT:
repgen_system.printResult(data)
elif command == DO_COMMAND_PREVIEW:
repgen_system.previewResult(data)
elif command == DO_COMMAND_EXPORT:
repgen_system.convertResult(data)
elif command == DO_COMMAND_SELECT:
repgen_system.doSelectAction(data)
else:
log_func.warning(u'Not processed start command <%s>' %
command)
else:
repgen_system.save(data)
return True
except:
log_func.fatal(u'Error starting report generator <%s>' %
report_filename)
def setDB(self, db):
"""
Set database.
:param db: DB object.
"""
self.db = db
if self.db is None:
log_func.warning(u'The database object is not installed in the SQL query results view window')
log_func.warning(u'SQL queries will not be executed')
def getGeneratorType(self):
"""
Type of reporting system.
"""
my_generator_type = self._report_template.get('generator', None) if self._report_template else None
if my_generator_type is None:
log_func.warning(u'Failed define the type of reporting system in <%s>' % self.__class__.__name__)
elif isinstance(my_generator_type, str):
my_generator_type = my_generator_type.lower()
return my_generator_type
def edit(self):
"""
Start editing the INI settings file.
"""
ini_filename = self._getINIFilename()
if os.path.exists(ini_filename):
cmd = 'gedit %s &' % ini_filename
exec_func.execSystemCommand(cmd)
else:
log_func.warning(u'INI file <%s> not found' % ini_filename)
def refreshDataList(self, variables=None):
"""
Refresh transform result dataset.
:param variables: Variables dictionary.
:return: True/False
"""
if variables is None:
variables = self.variables
try:
dataframe = self.testing_component.transform(**variables)
# log_func.debug(u'Transformed DataFrame:')
# log_func.debug(str(dataframe))
dataset = self.testing_component.exportData(dataframe)
if dataset:
# Columns
fields = dataset[0].keys()
if fields == ERROR_FIELD:
cols = [
dict(label=field_name, width=ERROR_COL_WIDTH)
for field_name in fields
]
else:
cols = [
dict(label=field_name, width=-1)
for field_name in fields
]
# Rows
row_count = len(dataset)
# Limit records
limit = self.limit_spinCtrl.GetValue()
if limit:
# log_func.debug(u'Limit records <%s>' % limit)
dataset = dataset[:limit]
rows = [[rec.get(field, u'') for field in fields]
for rec in dataset]
self.setListCtrlColumns(listctrl=self.records_listCtrl,
cols=cols)
self.setListCtrlRows(listctrl=self.records_listCtrl, rows=rows)
if rows:
# Autosize columnns
self.setListCtrlColumnsAutoSize(
listctrl=self.records_listCtrl)
self.count_textCtrl.SetValue(str(row_count))
return True
else:
log_func.warning(u'Empty dataset')
except:
log_func.fatal(u'Error refresh transform datasource result list')
return False
def selectAction(self, report=None, *args, **kwargs):
"""
Start report generation and then select an action.
:param report: Report template data.
"""
ods_rep_file_name = self._genODSReport(report, *args, **kwargs)
if ods_rep_file_name and os.path.exists(ods_rep_file_name):
return self.doSelectAction(ods_rep_file_name)
else:
log_func.warning(u'Report file <%s> not exists' %
ods_rep_file_name)
def getReportDir(self):
"""
Get report folder path.
"""
if self._report_dir is None:
if self._parent_window:
self._report_dir = os.path.abspath(
self._parent_window.getReportDir())
else:
log_func.warning(u'Not define report directory')
self._report_dir = ''
return self._report_dir
