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