def validate_confirm(self): till = self.model.till removed = abs(self.model.value) if removed and removed > till.get_balance(): warning(_("The amount that you want to remove is " "greater than the current balance.")) return False return True
def on_ManageStock__activate(self, action): user = api.get_current_user(self.store) if not user.profile.check_app_permission(u'inventory'): return warning(_('Only users with access to the inventory app can' ' change the stock quantity')) product = self.results.get_selected().product if product.storable and product.storable.is_batch: return warning(_("It's not possible to change the stock quantity of" " a batch product")) branch = self.branch_filter.combo.get_selected() if not branch: return warning(_('You must select a branch first')) if (api.sysparam.get_bool('SYNCHRONIZED_MODE') and branch != api.get_current_branch(self.store)): return warning(_('You can only change the stock of your current branch')) with api.new_store() as store: self.run_dialog(ProductStockQuantityEditor, store, store.fetch(product), branch=branch) if store.committed: self.refresh()
def _add_sellable(self, sellable, batch=None): quantity = self._read_quantity() if quantity == 0: return if not sellable.is_valid_quantity(quantity): warning( _(u"You cannot sell fractions of this product. " u"The '%s' unit does not allow that") % sellable.unit_description) return if sellable.product: # If the sellable has a weight unit specified and we have a scale # configured for this station, go and check what the scale says. if (sellable and sellable.unit and sellable.unit.unit_index == UnitType.WEIGHT and self._scale_settings): self._read_scale(sellable) storable = sellable.product_storable if storable is not None: if not self._check_available_stock(storable, sellable): info( _("You cannot sell more items of product %s. " "The available quantity is not enough.") % sellable.get_description()) self.barcode.set_text('') self.barcode.grab_focus() return self._update_list(sellable, batch=batch) self.barcode.grab_focus()
def _check_user(self, username, password): username = unicode(username) password = unicode(password) # This function is really just a post-validation item. default_store = api.get_default_store() user = default_store.find(LoginUser, username=username).one() if not user: raise LoginError(_("Invalid user or password")) if not user.is_active: raise LoginError(_('This user is inactive')) branch = api.get_current_branch(default_store) # current_branch may not be set if we are registering a new station if branch and not user.has_access_to(branch): raise LoginError(_('This user does not have access to this branch')) if user.pw_hash != password: raise LoginError(_("Invalid user or password")) # Dont know why, but some users have this empty. Prevent user from # login in, since it will break later if not user.profile: msg = (_("User '%s' has no profile set, " "but this should not happen.") % user.username + '\n\n' + _("Please contact your system administrator or Stoq team.")) warning(msg) raise LoginError(_("User does not have a profile")) user.login() # ICurrentUser might already be provided which is the case when # creating a new database, thus we need to replace it. provide_utility(ICurrentUser, user, replace=True) return user
def finish(self): missing = get_missing_items(self.model, self.store) if missing: run_dialog(MissingItemsDialog, self, self.model, missing) return False invoice_ok = InvoiceSetupEvent.emit() if invoice_ok is False: # If there is any problem with the invoice, the event will display an error # message and the dialog is kept open so the user can fix whatever is wrong. return # FIXME: If any issue happen at any point of the "send process", # trying to issue it again would make some products have their stock # decreased twice. Make sure we undo it first. # The issue itself was related to missing stock. Why get_missing_items # failed above? self.store.savepoint('before_send_transfer') try: self.model.send() except Exception as e: warning(_("An error happened when trying to confirm the transfer"), str(e)) self.store.rollback_to_savepoint('before_send_transfer') raise self.retval = self.model self.close() StockTransferWizardFinishEvent.emit(self.model) # Commit before printing to avoid losing data if something breaks self.store.confirm(self.retval) self._receipt_dialog(self.model)
def on_add_product_button__clicked(self, widget): if not self.model.description: warning(_('You should fill the description first')) return False self.model.add_grid_child(self._option_list.values()) self.product_list.add_list(self.model.children) self.add_product_button.set_sensitive(False)
def on_confirm(self): till = self.model.till removed = abs(self.model.value) if removed: # We need to do this inside a new transaction, because if the # till closing fails further on, this still needs to be recorded # in the database store = api.new_store() t_till = store.fetch(till) TillRemoveCashEvent.emit(till=t_till, value=removed) reason = _('Amount removed from Till by %s') % ( api.get_current_user(self.store).get_description(), ) till_entry = t_till.add_debit_entry(removed, reason) # Financial transaction _create_transaction(store, till_entry) # DB transaction store.confirm(True) store.close() if self._close_ecf: try: retval = TillCloseEvent.emit(till=till, previous_day=self._previous_day) except (TillError, DeviceError), e: warning(str(e)) return None # If the event was captured and its return value is False, then we # should not close the till. if retval is False: return False
def _cancel_last_document(self): try: self._validate_printer() except DeviceError as e: warning(str(e)) return store = new_store() last_doc = self._get_last_document(store) if not self._confirm_last_document_cancel(last_doc): store.close() return if last_doc.last_till_entry: self._cancel_last_till_entry(last_doc, store) elif last_doc.last_sale: # Verify till balance before cancel the last sale. till = Till.get_current(store) if last_doc.last_sale.total_amount > till.get_balance(): warning(_("You do not have this value on till.")) store.close() return cancelled = self._printer.cancel() if not cancelled: info(_("Cancelling sale failed, nothing to cancel")) store.close() return else: self._cancel_last_sale(last_doc, store) store.commit()
def _finish(self, returncode): logger.info('CreateDatabaseStep._finish (returncode=%s)' % returncode) if returncode: self.wizard.enable_back() # Failed to execute/create database if returncode == 30: # This probably happened because the user either; # - pressed cancel in the authentication popup # - user erred the password 3 times # Allow him to try again if yesno(_("Something went wrong while trying to create " "the database. Try again?"), gtk.RESPONSE_NO, _("Change settings"), _("Try again")): return self._launch_stoqdbadmin() return elif returncode == 31: # Missing postgresql-contrib package self.expander.set_expanded(True) warning(_("Your database is missing the postgresql-contrib " "package. Install it and try again")) else: # Unknown error, just inform user that something went wrong. self.expander.set_expanded(True) warning(_("Something went wrong while trying to create " "the Stoq database")) return self.label.set_text("") self.wizard.load_config_and_call_setup() create_default_profile_settings() self.progressbar.set_text(_("Done.")) self.progressbar.set_fraction(1.0) self.wizard.enable_next() self.done_label.set_markup( _("Installation successful, click <b>Forward</b> to continue."))
def check_serial(self): driver_serial = self._driver.get_serial() if self._printer.device_serial != driver_serial: warning(_("Invalid serial number for fiscal printer connected to %s") % (self._printer.device_name)) return False return True
def return_sale(parent, sale, store): from stoqlib.gui.wizards.salereturnwizard import SaleReturnWizard cancel_last_coupon = sysparam.get_bool('ALLOW_CANCEL_LAST_COUPON') if cancel_last_coupon and ECFIsLastSaleEvent.emit(sale): info(_("That is last sale in ECF. Return using the menu " "ECF - Cancel Last Document")) return if sale.can_return(): need_document = not sysparam.get_bool('ACCEPT_SALE_RETURN_WITHOUT_DOCUMENT') if need_document and not sale.get_client_document(): warning(_('It is not possible to accept a returned sale from clients ' 'without document. Please edit the client document or change ' 'the sale client')) return returned_sale = sale.create_sale_return_adapter() retval = run_dialog(SaleReturnWizard, parent, store, returned_sale) elif sale.can_cancel(): retval = cancel_sale(sale) else: retval = False return retval
def summarize(self): """sends a summarize (leituraX) command to the printer""" try: self._register_emitted_document(ECFDocumentHistory.TYPE_SUMMARY) self._driver.summarize() except DriverError as details: warning(_("Could not print summary"), str(details))
def _read_import_file(self): data = {} not_found = set() with open(self.import_file.get_filename()) as fh: for line in fh: # The line should have 1 or 2 parts parts = line[:-1].split(',') assert 1 <= len(parts) <= 2 if len(parts) == 2: barcode, quantity = parts elif len(parts) == 1: barcode = parts[0] if not barcode: continue quantity = 1 sellable = self.store.find(Sellable, barcode=str(barcode)).one() if not sellable: sellable = self.store.find(Sellable, code=str(barcode)).one() if not sellable: not_found.add(barcode) continue data.setdefault(sellable, 0) data[sellable] += int(quantity) if not_found: warning(_('Some barcodes were not found'), ', '.join(not_found)) self.wizard.imported_count = data
def on_PrintProductListing__activate(self, button): selected = self.results.get_selected() sellables = list(self._get_sellables_by_inventory(selected)) if not sellables: warning(_("No products found in the inventory.")) return self.print_report(ProductCountingReport, sellables)
def validate_confirm(self): if not self.model.change_reason: msg = self.get_validate_message() if bool(msg): warning(msg) return False return True
def return_sale(parent, sale, store): from stoqlib.gui.wizards.salereturnwizard import SaleReturnWizard # A plugin (e.g. ECF) can avoid the cancelation of a sale # because it wants it to be cancelled using another way if SaleAvoidCancelEvent.emit(sale, Sale.STATUS_RETURNED): return if sale.can_return(): need_document = not sysparam.get_bool('ACCEPT_SALE_RETURN_WITHOUT_DOCUMENT') if need_document and not sale.get_client_document(): warning(_('It is not possible to accept a returned sale from clients ' 'without document. Please edit the client document or change ' 'the sale client')) return returned_sale = sale.create_sale_return_adapter() retval = run_dialog(SaleReturnWizard, parent, store, returned_sale) elif sale.can_cancel(): reason = _(u'Sale cancelled due to client return.') retval = cancel_sale(sale, reason) else: retval = False return retval
def _remove_work_order(self, holder, name, work_order, work_order_id): if work_order.is_finished(): warning(_("You cannot remove workorder with the status '%s'") % work_order.status_str) return if not work_order.get_items().find().is_empty(): warning(_("This workorder already has items and cannot be removed")) return # We cannot remove the WO from the database (since it already has some # history), but we can disassociate it from the sale, cancel and leave # a reason for it. reason = (_(u'Removed from sale %s') % work_order.sale.identifier) work_order.sale = None work_order.cancel(reason=reason) self._work_order_ids.remove(work_order_id) # Remove the tab self.detach_slave(name) pagenum = self.work_orders_nb.page_num(holder) self.work_orders_nb.remove_page(pagenum) # And remove the WO self.wizard.workorders.remove(work_order) self.force_validation()
def _can_add_payment(self): if self.base_value.read() is ValueUnset: return False if self._outstanding_value <= 0: return False payments = self.model.group.get_valid_payments() payment_count = payments.find( Payment.method_id == self._method.id).count() if payment_count >= self._method.max_installments: info(_(u'You can not add more payments using the %s ' 'payment method.') % self._method.description) return False # If we are creaing out payments (PurchaseOrder) or the Sale does not # have a client, assume all options available are creatable. if (isinstance(self.model, (PurchaseOrder, StockDecrease)) or not self.model.client): return True method_values = {self._method: self._holder.value} for i, payment in enumerate(self.model.group.payments): method_values.setdefault(payment.method, 0) method_values[payment.method] += payment.value for method, value in method_values.items(): try: self.model.client.can_purchase(method, value) except SellError as e: warning(str(e)) return False return True
def check_till(self): try: self._check_needs_closing() self.emit('ecf-changed', True) except (DeviceError, DriverError) as e: warning(str(e)) self.emit('ecf-changed', False)
def add_item(self, item): """ @param item: A :class:`SellableItem` subclass @returns: id of the item.: 0 >= if it was added successfully -1 if an error happend 0 if added but not printed (gift certificates, free deliveries) """ sellable = item.sellable max_len = self._get_capability("item_description").max_len description = sellable.description[:max_len] unit_desc = '' if not sellable.unit: unit = UnitType.EMPTY else: if sellable.unit.unit_index == UnitType.CUSTOM: unit_desc = sellable.unit.description unit = sellable.unit.unit_index or UnitType.EMPTY max_len = self._get_capability("item_code").max_len code = sellable.code[:max_len] try: tax_constant = self._printer.get_tax_constant_for_device(sellable) except DeviceError, e: warning(_("Could not print item"), str(e)) return -1
def validate_step(self): if any(i.need_adjust_batch for i in self.purchase_items): warning(_("Before proceeding you need to adjust quantities for " "the batch products (highlighted in red)")) return False return True
def validate_confirm(self): if self._get_diff_quantity() < 0: warning(_("There's some outstanding quantity. Adjust them " "before you can confirm")) return False return True
def _check_user(self, username, pw_hash): username = unicode(username) pw_hash = unicode(pw_hash) # This function is really just a post-validation item. default_store = api.get_default_store() current_branch = api.get_current_branch(default_store) user = LoginUser.authenticate(default_store, username, pw_hash, current_branch) # Dont know why, but some users have this empty. Prevent user from # login in, since it will break later if not user.profile: msg = (_("User '%s' has no profile set, " "but this should not happen.") % user.username + '\n\n' + _("Please contact your system administrator or Stoq team.")) warning(msg) raise LoginError(_("User does not have a profile")) user.login() # ICurrentUser might already be provided which is the case when # creating a new database, thus we need to replace it. provide_utility(ICurrentUser, user, replace=True) return user
def open(self): while True: log.info("opening coupon") try: self.emit('open') break except CouponOpenError: if not self.cancel(): return False except OutofPaperError: if not yesno( _("The fiscal printer has run out of paper.\nAdd more paper " "before continuing."), gtk.RESPONSE_YES, _("Resume"), _("Confirm later")): return False return self.open() except PrinterOfflineError: if not yesno( (_(u"The fiscal printer is offline, turn it on and try " "again")), gtk.RESPONSE_YES, _(u"Resume"), _(u"Confirm later")): return False return self.open() except (DriverError, DeviceError) as e: warning(_(u"It is not possible to emit the coupon"), str(e)) return False self._coo = self.emit('get-coo') self.totalized = False self.coupon_closed = False self.payments_setup = False return True
def _receive(self): with api.new_store() as store: till = Till.get_current(store) assert till in_payment = self.results.get_selected() payment = store.fetch(in_payment.payment) assert self._can_receive(payment) retval = run_dialog(SalePaymentConfirmSlave, self, store, payments=[payment], show_till_info=False) if not retval: return try: TillAddCashEvent.emit(till=till, value=payment.value) except (TillError, DeviceError, DriverError) as e: warning(str(e)) return till_entry = till.add_credit_entry(payment.value, _(u'Received payment: %s') % payment.description) TillAddTillEntryEvent.emit(till_entry, store) if store.committed: self.search.refresh()
def _install_postgres(self): self.wizard.disable_back() self.wizard.disable_next() self.label.set_markup( _("Please wait while the package installation is completing.")) packageinstaller = library.get_resource_filename( 'stoq', 'scripts', 'packageinstaller.py') p = subprocess.Popen( [sys.executable, packageinstaller, 'postgresql', 'postgresql-contrib', 'stoq-server'], stdout=subprocess.PIPE, stderr=subprocess.PIPE) stdout, stderr = p.communicate() self.wizard.enable_back() if p.returncode == 0: self.done = True self.wizard.enable_next() self.label.set_markup( _("Postgresql installation succeeded. You may now proceed " "to the next step by clicking the <b>Forward</b> button")) elif p.returncode == 11: self.wizard.enable_next() self.label.set_markup( _("Authorization failed, try again or connect to " "another database")) else: warning(_("Something went wrong while trying to install " "the PostgreSQL server.")) self.label.set_markup( _("Sorry, something went wrong while installing PostgreSQL, " "try again manually or go back and configure Stoq to connect " "to another."))
def confirm(self, sale, store, savepoint=None, subtotal=None): """Confirms a |sale| on fiscalprinter and database If the sale is confirmed, the store will be committed for you. There's no need for the callsite to call store.confirm(). If the sale is not confirmed, for instance the user cancelled the sale or there was a problem with the fiscal printer, then the store will be rolled back. :param sale: the |sale| to be confirmed :param trans: a store :param savepoint: if specified, a database savepoint name that will be used to rollback to if the sale was not confirmed. :param subtotal: the total value of all the items in the sale """ # Actually, we are confirming the sale here, so the sale # confirmation process will be available to others applications # like Till and not only to the POS. total_paid = sale.group.get_total_confirmed_value() model = run_dialog(ConfirmSaleWizard, self._parent, store, sale, subtotal=subtotal, total_paid=total_paid) if not model: CancelPendingPaymentsEvent.emit() store.rollback(name=savepoint, close=False) return False if sale.client and not self.is_customer_identified(): self.identify_customer(sale.client.person) if not self.totalize(sale): store.rollback(name=savepoint, close=False) return False if not self.setup_payments(sale): store.rollback(name=savepoint, close=False) return False if not self.close(sale, store): store.rollback(name=savepoint, close=False) return False try: sale.confirm() except SellError as err: warning(str(err)) store.rollback(name=savepoint, close=False) return False if not self.print_receipts(sale): warning(_("The sale was cancelled")) sale.cancel() print_cheques_for_payment_group(store, sale.group) # Only finish the transaction after everything passed above. store.confirm(model) return True
def _update_list(self, sellable): assert isinstance(sellable, Sellable) try: sellable.check_taxes_validity() except TaxError as strerr: # If the sellable icms taxes are not valid, we cannot sell it. warning(strerr) return quantity = self.sellableitem_proxy.model.quantity is_service = sellable.service if is_service and quantity > 1: # It's not a common operation to add more than one item at # a time, it's also problematic since you'd have to show # one dialog per service item. See #3092 info(_("It's not possible to add more than one service " "at a time to an order. So, only one was added.")) sale_item = TemporarySaleItem(sellable=sellable, quantity=quantity) if is_service: with api.trans() as store: rv = self.run_dialog(ServiceItemEditor, store, sale_item) if not rv: return self._update_added_item(sale_item)
def _send_selected_items_to_supplier(self): orders = self.results.get_selected_rows() valid_order_views = [ order for order in orders if order.status == PurchaseOrder.ORDER_PENDING] if not valid_order_views: warning(_("There are no pending orders selected.")) return msg = stoqlib_ngettext( _("The selected order will be marked as sent."), _("The %d selected orders will be marked as sent.") % len(valid_order_views), len(valid_order_views)) confirm_label = stoqlib_ngettext(_("Confirm order"), _("Confirm orders"), len(valid_order_views)) if not yesno(msg, gtk.RESPONSE_YES, confirm_label, _("Don't confirm")): return with api.new_store() as store: for order_view in valid_order_views: order = store.fetch(order_view.purchase) order.confirm() self.refresh() self.select_result(orders)
def print_receipts(self, sale): # supports_duplicate = self.emit('get-supports-duplicate-receipt') # Vamos sempre imprimir sempre de uma vez, para simplificar supports_duplicate = False log.info('Printing payment receipts') # Merge card payments by nsu card_payments = {} for payment in sale.payments: if payment.method.method_name != 'card': continue operation = payment.method.operation card_data = operation.get_card_data_by_payment(payment) card_payments.setdefault(card_data.nsu, []) card_payments[card_data.nsu].append(payment) any_failed = False for nsu, payment_list in card_payments.items(): receipt = CardPaymentReceiptPrepareEvent.emit( nsu, supports_duplicate) if receipt is None: continue value = sum([p.value for p in payment_list]) # This is BS, but if any receipt failed to print, we must print # the remaining ones in Gerencial Rports if any_failed: retval = self.reprint_payment_receipt(receipt) else: retval = self.print_payment_receipt(payment_list[0], value, receipt) while not retval: if not yesno( _(u"An error occurred while trying to print. " u"Would you like to try again?"), gtk.RESPONSE_YES, _("Try again"), _(u"Don't try again")): CancelPendingPaymentsEvent.emit() try: GerencialReportCancelEvent.emit() except (DriverError, DeviceError) as details: log.info('Error canceling last receipt: %s' % details) warning( _(u"It wasn't possible to cancel " u"the last receipt")) return False any_failed = True _flush_interface() retval = self.reprint_payment_receipt( receipt, close_previous=True) # Only confirm payments receipt printed if *all* receipts wore # printed. for nsu in card_payments.keys(): CardPaymentReceiptPrintedEvent.emit(nsu) return True
def validate_step(self): if self.packages.get_selected() is None: warning(_(u"You need to select a package to receive first.")) return False return True
def _set_error(self, msg, long_msg=None): warning(msg, long_msg) self._set_processing(False)
def confirm(self, sale, store, savepoint=None, subtotal=None): """Confirms a |sale| on fiscalprinter and database If the sale is confirmed, the store will be committed for you. There's no need for the callsite to call store.confirm(). If the sale is not confirmed, for instance the user cancelled the sale or there was a problem with the fiscal printer, then the store will be rolled back. :param sale: the |sale| to be confirmed :param trans: a store :param savepoint: if specified, a database savepoint name that will be used to rollback to if the sale was not confirmed. :param subtotal: the total value of all the items in the sale """ # Actually, we are confirming the sale here, so the sale # confirmation process will be available to others applications # like Till and not only to the POS. payments_total = sale.group.get_total_confirmed_value() sale_total = sale.get_total_sale_amount() payment = get_formatted_price(payments_total) amount = get_formatted_price(sale_total) msg = _(u"Payment value (%s) is greater than sale's total (%s). " "Do you want to confirm it anyway?") % (payment, amount) if (sale_total < payments_total and not yesno(msg, gtk.RESPONSE_NO, _(u"Confirm Sale"), _(u"Don't Confirm"))): return False model = run_dialog(ConfirmSaleWizard, self._parent, store, sale, subtotal=subtotal, total_paid=payments_total) if not model: CancelPendingPaymentsEvent.emit() store.rollback(name=savepoint, close=False) return False if sale.client and not self.is_customer_identified(): self.identify_customer(sale.client.person) if not self.totalize(sale): store.rollback(name=savepoint, close=False) return False if not self.setup_payments(sale): store.rollback(name=savepoint, close=False) return False if not self.close(sale, store): store.rollback(name=savepoint, close=False) return False # FIXME: This used to be done inside sale.confirm. Maybe it would be # better to do a proper error handling till = Till.get_current(store) assert till try: sale.confirm(till=till) except SellError as err: warning(str(err)) store.rollback(name=savepoint, close=False) return False if not self.print_receipts(sale): warning(_("The sale was cancelled")) sale.cancel(force=True) print_cheques_for_payment_group(store, sale.group) # Only finish the transaction after everything passed above. store.confirm(model) # Try to print only after the transaction is commited, to prevent # losing data if something fails while printing group = sale.group booklets = list(group.get_payments_by_method_name(u'store_credit')) bills = list(group.get_payments_by_method_name(u'bill')) if (booklets and yesno( _("Do you want to print the booklets for this sale?"), gtk.RESPONSE_YES, _("Print booklets"), _("Don't print"))): try: print_report(BookletReport, booklets) except ReportError: warning(_("Could not print booklets")) if (bills and BillReport.check_printable(bills) and yesno( _("Do you want to print the bills for this sale?"), gtk.RESPONSE_YES, _("Print bills"), _("Don't print"))): try: print_report(BillReport, bills) except ReportError: # TRANSLATORS: bills here refers to "boletos" in pt_BR warning(_("Could not print bills")) return True
def validate_step(self): if len(self.slave.get_selected_attributes()) == 0: warning(_("You should select an attribute first")) return False return True
def new_activate(self): if not self.NewInventory.get_sensitive(): warning(_("You cannot open an inventory without having a " "branch with stock in it.")) return self._open_inventory()
def next_step(self): if not self.wizard.need_create_payment(): if self.cash_change_slave.credit_checkbutton.get_active(): self._create_change_payment() return selected_method = self.get_selected_method() if selected_method.method_name == u'money': if not self.cash_change_slave.can_finish(): warning( _(u"Invalid value, please verify if it was " "properly typed.")) self.cash_change_slave.received_value.select_region( 0, len(self.cash_change_slave.received_value.get_text())) self.cash_change_slave.received_value.grab_focus() return self # We have to modify the payment, so the fiscal printer can # calculate and print the payback, if necessary. payment = self.setup_cash_payment() if payment is None: return total = self.cash_change_slave.get_received_value() payment.base_value = total # Return None here means call wizard.finish, which is exactly # what we need return None elif selected_method.method_name == u'credit': client = self.model.client total = self.wizard.get_total_to_pay() assert client.can_purchase(selected_method, total) try: payment = selected_method.create_payment( Payment.TYPE_IN, self.model.group, self.model.branch, total) except PaymentMethodError as err: warning(str(err)) return self # Return None here means call wizard.finish, which is exactly # what we need return None elif selected_method.method_name == u'store_credit': client = self.model.client total = self.wizard.get_total_to_pay() assert client.can_purchase(selected_method, total) step_class = PaymentMethodStep elif selected_method.method_name == 'card': providers = CreditProvider.get_card_providers(self.store) if providers.is_empty(): warning( _("You need active credit providers to use the " "card payment method.")) return self step_class = PaymentMethodStep else: step_class = PaymentMethodStep retval = CreatePaymentEvent.emit(selected_method, self.model, self.store) # None means no one catched this event if retval is None or retval == CreatePaymentStatus.UNHANDLED: # FIXME: We cannot send outstanding_value to multiple editor # since if we have a trade going on, it will be calculated wrong if selected_method.method_name == 'multiple': outstanding_value = None else: outstanding_value = self.wizard.get_total_to_pay() manager = get_plugin_manager() return step_class(self.wizard, self, self.store, self.model, selected_method, outstanding_value=outstanding_value, finish_on_total=manager.is_active('tef')) # finish the wizard if retval == CreatePaymentStatus.SUCCESS: return None # returning self to stay on this step return self
def validate_confirm(self): if not any(i.will_send for i in self.workorders): warning(_(u"You need to select at least one work order")) return False return True
def _check_locale(self): if not self._locale_error: return from stoqlib.lib.message import warning warning(self._locale_error[0], str(self._locale_error[1]))
def _on_manager__action_finished(self, manager, action, retval): if isinstance(retval, Exception): warning(_('An error happened when executing "%s"') % (action.label, ), str(retval)) self._update_ui()
def _abort(self, msg=None, title=None): if msg: warning(msg) raise SystemExit
def validate_step(self): if (self.wizard.product_type == Product.TYPE_GRID and not GridGroup.has_group(self.wizard.store)): warning(_("You need to register an attribute group first")) return False return True
def _has_open_coupon(self): self._validate_printer() if self._printer.has_open_coupon(): warning(_("The ECF has an open coupon. It will be canceled now.")) self._printer.cancel()
def _close_till(self, till, previous_day): log.info('ECFCouponPrinter.close_till(%r, %r)' % (till, previous_day)) # XXX: this is so ugly, but the printer stops responding # if its printing something. We should wait a little bit... # This only happens if closing the till from the current day. if not previous_day: time.sleep(4) # Callsite catches DeviceError self._validate_printer() printer = self._printer.get_printer() if (sysparam.get_bool('ENABLE_DOCUMENT_ON_INVOICE') and not (printer.user_number and printer.register_date and printer.register_cro)): response = warning( short=_(u"You need to set some details about your ECF " "if you want to save the paulista invoice file. " "Go to the admin application and fill the " "required information for the ECF."), buttons=((_(u"Cancel Close Till"), Gtk.ResponseType.CANCEL), )) return False retval = True while True: try: self._printer.close_till(previous_day=previous_day) except CouponOpenError: self._printer.cancel() retval = False except DriverError: response = warning( short=_(u"It's not possible to emit a reduce Z for the " "configured printer.\nWould you like to ignore " "this error and continue?"), buttons=((_(u"Cancel"), Gtk.ResponseType.CANCEL), (_(u"Ignore"), Gtk.ResponseType.YES), (_(u"Try Again"), Gtk.ResponseType.NONE))) if response == Gtk.ResponseType.NONE: continue elif response == Gtk.ResponseType.CANCEL: retval = False break if self._needs_cat52(printer): day = datetime.date.today() if previous_day: # XXX: Make sure this is tested day = till.opening_date dir = sysparam.get_string('CAT52_DEST_DIR') dir = os.path.expanduser(dir) if not os.path.exists(dir): os.mkdir(dir) generator = StoqlibCATGenerator(self.default_store, day, printer) generator.write(dir) self._reset_last_doc() return retval
def new_activate(self): if not self.NewReceiving.get_sensitive(): warning(_("You cannot receive a purchase with an open inventory.")) return self._receive_purchase()
def _on_toolbar__new(self, toolbar): if not self.store.find(GridGroup, is_active=True).any(): warning(_("You need an active grid group.")) else: self.run()
def validate_confirm(self): if self.store.find(GridOption, attribute=self.model).is_empty(): warning(_("You need to add at least one option")) return False return True
def confirm(self): if len(self.notes.read()) < self.min_length: warning(_("The note must have at least %s characters.") % self.min_length) return BaseEditor.confirm(self)
def validate_confirm(self): if self._user.get_associated_branches().count() <= 0: warning(_(u'User must be associated to at least one branch.')) return False return True