def set_selected_state(self,selected_state,initial_state): mainlog.debug("selected_state {}".format(selected_state)) mainlog.debug("initial_state {}".format(initial_state)) self.initial_state = initial_state self.selected_state = selected_state self._drawNodes(self.scene,selected_state,self.initial_state)
def _show_filter(self, fq): if fq: mainlog.debug("_show_filter : {}".format(fq.query)) if fq.owner_id == user_session.user_id: self.query_label.setText("<b>{}</b>".format(fq.name)) else: self.query_label.setText("<b>{}</b> ({})".format( fq.name, fq.owner.fullname)) self.super_filter_entry.setText(fq.query) self.save_filter_button.setEnabled( fq.owner_id == user_session.user_id) self.delete_filter_button.setEnabled( fq.owner_id == user_session.user_id) if fq.shared: self.share_filter.setCheckState(Qt.Checked) else: self.share_filter.setCheckState(Qt.Unchecked) else: mainlog.debug("_show_filter : {}".format(None)) self.super_filter_entry.setText("") self.share_filter.setCheckState(Qt.Unchecked) self.save_filter_button.setEnabled(True) self.delete_filter_button.setEnabled(True)
def createEditor(self, parent, option, index): proxy = index.model().index( index.row(), index.column() - 2).data( Qt.UserRole) # FIXME hardcoding columns is baaaad :-) if not proxy: return machines = machine_service.find_machines_for_operation_definition( proxy.operation_definition_id) editor = AutoCompleteComboBox(self, parent) editor.section_width = [400] labels = [None] # Null machine is OK items = [None] for m in machines: labels.append(m.fullname) items.append(m.machine_id) mainlog.debug(labels) editor.make_str_model(labels, items) # if option: # editor.setGeometry(option.rect) return editor
def __init__(self,parent): super(HorsePanel,self).__init__(parent) self._needs_refresh = True self._panel_visible = False self._panel_manager = None # Will be set when the panel is registerd in the panel manager self._panel_title = None # Title of the panel to be shown to the user, use the setter mainlog.debug( "HorsePanel.__init__()")
def alter_data(): # For the moment I skip this because I think that adding a role that is not # supported by the user session might lock people out of Horse # return import os import shutil q = session().query(Document).order_by(Document.document_id).all() for document in q: path, filename = os.path.split(document.server_location) new_path = documents_service._make_path_to_document( document.document_id, document.filename) mainlog.debug(u"Document {} -> filename:{} -- new_name:{}".format( document.document_id, document.filename, new_path)) try: shutil.copy(document.server_location, new_path) document.server_location = new_path except Exception as ex: mainlog.error("Unable to copy !") mainlog.exception(ex) session().rollback() return session().commit()
def dragLeaveEvent(self, e): # For some reason, I don't always receive the leave event. Don't know why... e.accept() mainlog.debug("dragLeaveEvent") self.show_drop_zones(False) self._set_buttons_visible(True)
def _add_file(self, full_path_client: str, document_category_id=None): mainlog.debug( "document widget _add_file categ={}".format(document_category_id)) if self._test_file_access(full_path_client): progress_bar = make_progress(_("Uploading"), 100) def progress_tracker(percent): progress_bar.setValue(int(percent)) try: doc_id = upload_document(full_path_client, progress_tracker) except Exception as exc: progress_bar.close() showErrorBox(_( "There was a problem while uploading the file to the server" ), ex=exc, object_name="file_upload_error") return d = self.documents_service.find_by_id(doc_id) doc = Document() doc.document_id = d.document_id doc.file_size = d.file_size doc.description = d.description doc.filename = d.filename doc.server_location = d.server_location doc.upload_date = d.upload_date if document_category_id: doc.document_category_id = document_category_id self.model.append_objects([doc])
def load_network_param(self): """ Load the network parameters. The priority is the config file first, then, if empty or not properly filled in, we guess it for net.cfg. This is for the delivery_slips side. :return: """ ip_address = None try: f = open(os.path.join(resource_dir, "net.cfg")) ip_address = f.read().strip() f.close() except Exception as ex: mainlog.warn("net.cfg file not found, using current configuration") return # if string_represents_ip_address(ip_address): mainlog.debug( "net.cfg file was read. Server is there : {}".format(ip_address)) if ":" in ip_address: host, port = ip_address.split(":") port = int(port) mainlog.debug("Address has port : {}:{}".format(host, port)) self.set_server_network_address(host, port, overwrite=False) else: self.set_server_network_address(ip_address, overwrite=False)
def accept(self): global dao # FIXME I gusess it's the one below, but I must make sure mainlog.debug("Accept() : Current item {}".format( self.customer_select.currentIndex())) # if not (self.customer_select.currentIndex() == 0 and self.customer_select.list_view.currentIndex().row() == -1): if self.customer_select.currentIndex() >= 0: customer = self.customer_select.itemData( self.customer_select.currentIndex(), Qt.UserRole) else: customer = None if customer is None: msgBox = makeErrorBox(_("Please choose a customer for the new order")) msgBox.exec_() super(CreateNewOrderDialog,self).accept() return False self.customer_select.list_view.itemSelected.disconnect() self.customer_select.list_view.setVisible(False) self.customer_select = None self.current_customer = customer # self.customer_select.hide() # FIXME Very hackish. If I don't do this then the QApplication loses focus when this dialog is closed... #self.setFocus() return super(CreateNewOrderDialog,self).accept()
def build_client_side_rpc_request(self, func: JsonCallable, *func_params): assert hasattr( func, '_json_callable' ), "Function is not decorated as a JSON callable function" func_sig = signature(func._original_func) # mainlog.debug("build_client_side_rpc_request : analyzing {}".format(func)) # if ismethod(func): mainlog.debug("Client calling method {}, params : {}".format( func._original_func.__name__, func_params)) jsonrpc = { "jsonrpc": "2.0", "method": func.get_service_name(), "params": self.params_to_jsonable(func_sig, func.in_recursive_set, func_params), "id": 1 } mainlog.debug("rpc request is : {}".format(jsonrpc)) # elif isfunction(func): # mainlog.debug("Client calling function {}, params : {}".format(func._original_func.__name__, func_params)) # jsonrpc = { # "jsonrpc": "2.0", # "method": "service." + func.__name__, # "params": json_caller.params_to_jsonable( func_sig, False, func.in_recursive_set, func_params), # "id": 1} # mainlog.debug("rpc request is : {}".format( jsonrpc)) # else: # raise Exception("Unable to guess the type of function {} maybe {} ?".format(func, type(func))) return jsonrpc
def in_process_call(self, func: JsonCallable, *func_params): """ Make an in process call. That is, a call that goes through JSON serialisation/deserialisation but without using an http connection. This is useful when testing serialisation. This shall be called from the JsonCallable decorator. :param func: :param func_params: :return: """ assert hasattr( func, '_json_callable' ), "Function is not decorated as a JSON callable function" func_sig = signature(func._original_func) intermediate = jsonable_to_json( self.params_to_jsonable(func_sig, func.in_recursive_set, func_params)) params = self.jsonable_to_params(func_sig, func.in_recursive_set, json_to_jsonable(intermediate)) call_result = func.call_decorated(**params) intermediate = jsonable_to_json( self.return_values_to_jsonable(func_sig, func.out_recursive_set, call_result)) mainlog.debug("in process mode : {}".format(intermediate)) return self.jsonable_to_return_values(func_sig, func.out_recursive_set, json_to_jsonable(intermediate))
def __call__(self, *args, **kwargs): if self._call_mode == CallMode.transparent: mainlog.debug( "JsoncCallableDecorator : transparent call transfer") mainlog.debug("args = {}".format(args)) return self.call_decorated(*args, **kwargs) elif self._call_mode == CallMode.http: assert self._call_handler, "Call handler not set for http mode" mainlog.debug("JsoncCallableDecorator : making http call") rpc_request = self._call_handler.build_client_side_rpc_request( self, *args) jsonable_res = self._call_handler.call_json_rpc_over_http( rpc_request) mainlog.debug( "JsoncCallableDecorator : making http call, result is {}". format(jsonable_res)) func_sig = signature(self._decorated_func) return self._call_handler.jsonable_to_return_values( func_sig, self.out_recursive_set, jsonable_res['result']) # return self._call_handler.jsonable_to_return_values( jsonable_res) elif self._call_mode == CallMode.in_process: assert self._call_handler, "Call handler not set for in process mode" mainlog.debug( "JsoncCallableDecorator : making in process call, params are {}" .format(args)) return self._call_handler.in_process_call( self, *args, **kwargs) else: mainlog.error("Unsupported call mode {}, {}".format( self._call_mode, self._call_mode == CallMode.in_process))
def typed_values_to_jsonable(metadata: SQLAMetaData, type_, recursive_set, value): mainlog.debug("typed_values_to_jsonable : {}, value is {}".format( type_, value)) # Check fundamental types first to optimize conversion speed if value is None: return None elif type_ in (int, float, str, bool, sqltypes.Integer, sqltypes.Float, sqltypes.String, sqltypes.Boolean): return value elif type_ == Decimal: return Decimal(value) elif type_ in (date, sqltypes.Date): return value.strftime("%Y-%m-%d") elif type_ == datetime: return value.strftime("%Y-%m-%dT%H:%M:%S.%f") elif isinstance(type_, Enum): return value elif type_ == KeyedTuplesSequence: return keyed_tuple_sequence_to_jsonable(metada, recursive_set, type_, value) elif type_ == sqlalchemy.util._collections.KeyedTuple: # We assume each keyed tuple only contains only jsonable values. # FIXME That's rather bold ! r = value._asdict() # mainlog.debug(r) return r elif type_ == bytes: # Python 3 return base64.b64encode(value).decode('ascii') elif isinstance(type_, Sequence): # In particular, this works for Sequence[KeyedTuples] return [ typed_values_to_jsonable(metadata, type_.target, recursive_set, v) for v in value ] elif isinstance(type_, Tuple): mainlog.debug("typed_values_to_jsonable : Tuple") assert len(type_.targets) == len( value ), "Value (of type tuple) length doesn't match prototype's length" return [ typed_values_to_jsonable(metadata, type_.targets[i], recursive_set, value[i]) for i in range(len(type_.targets)) ] elif metadata.is_class_mapped(type_): return sqla_to_dict(metadata, type_, value, recursive_set) elif hasattr(type_, 'to_jsonable'): return type_.to_jsonable(value) elif isinstance(value, object): raise Exception( "Unable to transform object to jsonable : {} - {} (was it mapped ? {})" .format(type_, value, metadata.is_class_mapped(type_))) # return value.__dict__ else: mainlog.warn("Unable to serialize type {}".format(type_)) return value
def copy_operations_slot(self): mainlog.debug("copy_operations_slot") view = self.view model = self.model # Collect the rows indices rows = set() for ndx in view.selectedIndexes(): if ndx.row() >= 0: rows.add(ndx.row()) # There are no guarantee on the selectedIndexes order rows = sorted(list(rows)) # Copy for elsewhere in Horse if len(rows): operations = [] for row_ndx in rows: operation = model.object_at(row_ndx) mainlog.debug(operation) operations.append(operation) copy_paste_manager.copy_operations(operations) else: # If nothing to copy then we leave the copy/paste clipboard # as it is. So one could paste again what he copied before. pass
def init_test_database(): # My idea is that the tests run under the same database constraints # as production. That is, the code can only change data, not database # structure. admin_url = configuration.get("Database", "admin_url") client_url = configuration.get("Database", "url") # login, password, dbname, host, port = _extract_db_params_from_url(client_url) set_up_database(admin_url, client_url) init_db_session(admin_url) create_all_tables() disconnect_db() # Do client level stuff init_db_session(client_url, koi.db_mapping.metadata, echo_query=False) mainlog.debug("Initializing DB for tests") create_root_account() do_basic_inserts(do_sequence=False) init_sequences(session()) add_user('dd', 'dd', 'Gandalf', 'TimeTrackModify,ModifyParameters') session().flush() session().expunge_all()
def attribute_analysis(model): global attribute_analysis_cache if model not in attribute_analysis_cache: mainlog.debug("Analysing model {}".format(model)) # Warning ! Some column properties are read only ! fnames = [ prop.key for prop in inspect(model).iterate_properties if isinstance(prop, ColumnProperty) ] single_rnames = [] rnames = [] for key, relation in inspect(model).relationships.items(): if relation.uselist == False: single_rnames.append(key) else: rnames.append(key) # Order is important to rebuild composite keys (I think, not tested so far. # See SQLA comment for query.get operation : # http://docs.sqlalchemy.org/en/rel_1_0/orm/query.html#sqlalchemy.orm.query.Query.get ) knames = [key.name for key in inspect(model).primary_key] mainlog.debug( "For model {}, I have these attributes : keys={}, fields={}". format(model, knames, fnames)) attribute_analysis_cache[model] = (fnames, rnames, single_rnames, knames) return attribute_analysis_cache[model]
def dragEnterEvent(self, e: QDragEnterEvent): """ Only accept what looks like a file drop action :param e: :return: """ if e.mimeData() and e.mimeData().hasUrls() and e.mimeData().urls( )[0].toString().startswith( "file://") and e.proposedAction() == Qt.DropAction.CopyAction: mainlog.debug("dragEnterEvent : I accept") # Attention ! The actual drop area is smaller # than the dragEnter area ! e.acceptProposedAction() e.accept() # I don't use childAt because childAt will be fooled by the buttons # I have in this tableview (the buttons are the children of the # tableview, not the viewport... I guess) #if self.viewport().geometry().contains(e.pos()): self._compute_drop_zone(e.pos(), e.mimeData()) self.show_drop_zones(True) self._set_buttons_visible(False) self.update() else: mainlog.debug("dragEnterEvent : I ignore") e.ignore()
def upload_template_document3(self, encoding_safe_filename, doc_id, uploaded_file): """ Create or replace a new template document. :param encoding_safe_filename: :param uploaded_file: :param doc_id: :return: """ mainlog.warn("upload_template_document3 : DEPRECATED") doc_id = int(doc_id) if doc_id == 0: mainlog.debug("upload_template_document3 : upload") file_id = documents_service.save_template(uploaded_file.file, encoding_safe_filename) return str(file_id) elif doc_id > 0: mainlog.debug( "upload_template_document3 : replace doc_id={}".format( doc_id)) documents_service.replace_template(doc_id, uploaded_file.file, encoding_safe_filename) return
def rows_inserted(self, parent, first, last): mainlog.debug("rows_inserted {} {} / row_count={}/{}".format( first, last, self.model.rowCount(), self.model.columnCount())) for row in range(first, last + 1): self._set_widget_buttons(row) self.documents_list_changed.emit()
def open_a_file_on_os(filepath): if filepath.endswith(".pdf"): pdf_cmd = configuration.get('Programs', 'pdf_viewer') mainlog.debug("Opening PDF {} with {}".format(filepath, pdf_cmd)) if pdf_cmd: # Start our own viewer (which is way faster than acrobat) p1 = subprocess.Popen([pdf_cmd, filepath]) p1.wait() else: os.startfile(filepath) return if sys.platform.startswith('darwin'): subprocess.call(('open', filepath)) elif os.name == 'nt': if filepath.endswith(".docx"): import win32com.client # See http://stackoverflow.com/questions/26907177/key-error-while-using-cx-freeze-for-making-exe # word = win32com.delivery_slips.gencache.EnsureDispatch('Word.Application') word = win32com.client.dynamic.Dispatch('Word.Application') word.Visible = True doc = word.Documents.Open(filepath) else: os.startfile(filepath) elif os.name == 'posix': subprocess.call(('xdg-open', filepath))
def _open_file_dialog(self): # This method exists to allow the test to avoid the file dialog. # Automating test of QFileDialog is super complex. mainlog.debug("__open_file_dialog") return QFileDialog.getOpenFileName(self, _('Add a document'), "", "")[0]
def p_date_in_period_expression(p): ''' date_in_period_expression : date_term IN period_term ''' mainlog.debug(p[3][0]) mainlog.debug(p[3][1]) p[0] = and_(p[1] != None, p[1].between(p[3][0], p[3][1]))
def set_visibility(self, visible): if self._panel_visible != visible: self._panel_visible = visible if self._panel_visible and self._needs_refresh: mainlog.debug("Panel is being refreshed now") self.refresh_action() self._needs_refresh = False
def change_several_order_parts_state(self, order: Order, order_parts_states_map: dict): """ Set the state of one or more order parts to the give state. All the parts *must* belong to the given order. Once this is done the state of the given order is adapted to match the states of the parts. """ if not order_parts_states_map: mainlog.debug("change_several_order_parts_state : nothing to do") return for state in order_parts_states_map.values(): if state not in OrderPartStateType: raise DataException("Improper target state {}".format(state), DataException.IMPROPER_STATE_TRANSITION) mainlog.debug("change_several_order_parts_state {}".format( order_parts_states_map)) for order_part in order.parts: if order_part in order_parts_states_map: # order_part.transition_state(state) business_computations_service.transition_part_state( order_part, order_parts_states_map[order_part]) # Adapt the order's state to its parts' states business_computations_service.compute_order_state_from_parts(order)
def completion_selected(self, ndx): self.completion.hide() self.activateWindow() self.setFocus(Qt.OtherFocusReason) t = self.text() cp = self.cursorPosition() w, start, end = word_at_point(self.text(), cp) action, start, end = self.replacement_area completion = self.completion.get_current_completion() if self.quote: completion = u"\"{}\"".format(completion) completion = u" {} ".format(completion) if action == 'rep': mainlog.debug("Replacing {} in |{}|={} [{},{}] by {}".format( w, t, self.cursorPosition(), start, end, self.completion.get_current_completion())) t_start = (t[0:start] + completion).lstrip() t_end = t[end + 1:len(t)] cp = len(t_start) t = t_start + t_end else: t_start = (t[0:start] + u" " + completion + u" ").lstrip() t_end = t[end + 1:len(t)] cp = len(t_start) t = t_start + t_end self.setText(t) self.setCursorPosition(cp)
def p_period_function_month_term(p): ''' period_term : MONTH_BEFORE ''' d = month_before(date.today()) p[0] = ( _first_moment_of_month(d), _last_moment_of_month(d) ) mainlog.debug(p[0])
def init_db_session(db_url, metadata=None, echo_query=False, autocommit=False, params=dict()): global _config mainlog.debug("Init DB session " + str(db_url)) if 'session' in _config: raise Exception( "Sorry, but you're trying ot double initialize the db session") db_url, params_from_url = parse_db_url(db_url) params = dict(list(params_from_url.items()) + list(params.items())) mainlog.debug("Creating engine to {} with params {}".format( db_url, params)) engine = create_engine(db_url, encoding='utf-8', echo=echo_query, poolclass=NullPool, connect_args=params) _config['engine'] = engine if metadata: metadata.bind = engine # Scoped session gives us thread safety which is very important # in our web server (multi thread) context _config['session_factory'] = sessionmaker(bind=engine, autocommit=autocommit) _config['session'] = scoped_session(_config['session_factory'])
def p_period_function_current_month_term(p): ''' period_term : CURRENT_MONTH ''' d = date.today() p[0] = ( _first_moment_of_month(d), _last_moment_of_month(d) ) mainlog.debug("CurrentMonth") mainlog.debug(p[0])
def save(self): mainlog.debug("EditTimeTracksDialog.save()") errors = self.controller.model.validate() if errors: showTableEntryErrorBox(errors) return False tt_start_time = datetime(self.edit_date.year, self.edit_date.month, self.edit_date.day, 6, 0, 0) edited_proxy_tts = self.controller.model.model_to_objects( lambda: TimetrackProxy()) employee_id = self.current_employee_id_selected # for tt in edited_proxy_tts: # mainlog.debug(type(tt)) # mainlog.debug(str(tt)) try: save_proxy_timetracks(edited_proxy_tts, tt_start_time, employee_id) return True except Exception as e: msgBox = QMessageBox(self) msgBox.setIcon(QMessageBox.Critical) msgBox.setText("There was an error while saving your data") msgBox.setInformativeText(str(e)) msgBox.setStandardButtons(QMessageBox.Ok) # msgBox.setDefaultButton(QMessageBox.Ok); ret = msgBox.exec_() return False
def contextMenuEvent(self, event): p = self.mapToScene(event.pos()) item = self.scene().itemAt(p) if item: item.setSelected(True) selected = item.data(0) if hasattr(selected, "type"): stype = selected.type else: stype = None if selected is None: self.tar_presence_menu.move(event.globalPos()) self.tar_presence_menu.show() elif isinstance(selected, TaskActionReport): self.tar_menu.move(event.globalPos()) self.tar_menu.show() elif stype in (Task, TaskOnOperation, TaskOnNonBillable, TaskOnOrder): self.task_menu.move(event.globalPos()) self.task_menu.show() else: mainlog.debug( "contextMenuEvent : can't do anything on {} (type={})". format(selected, stype)) else: self.all_menu.move(event.globalPos()) self.all_menu.show()