def populate(self, person): from stoqlib.domain.person import (Client, Supplier, Transporter, SalesPerson, Branch) store = get_store_for_field(self) person_type = self.person_type if person_type == Supplier: objects = Supplier.get_active_suppliers(store) self.add_button.set_tooltip_text(_("Add a new supplier")) self.edit_button.set_tooltip_text(_("Edit the selected supplier")) elif person_type == Client: objects = Client.get_active_clients(store) self.add_button.set_tooltip_text(_("Add a new client")) self.edit_button.set_tooltip_text(_("Edit the selected client")) elif person_type == Transporter: objects = Transporter.get_active_transporters(store) self.add_button.set_tooltip_text(_("Add a new transporter")) self.edit_button.set_tooltip_text(_("Edit the selected transporter")) elif person_type == SalesPerson: objects = SalesPerson.get_active_salespersons(store) self.add_button.set_tooltip_text(_("Add a new sales person")) self.edit_button.set_tooltip_text(_("Edit the selected sales person")) elif person_type == Branch: objects = Branch.get_active_branches(store) self.add_button.set_tooltip_text(_("Add a new branch")) self.edit_button.set_tooltip_text(_("Edit the selected branch")) else: raise AssertionError(self.person_type) self.widget.prefill(api.for_person_combo(objects)) if person: assert isinstance(person, person_type) self.widget.select(person)
def _setup_widgets(self): # Salesperson combo salespersons = SalesPerson.get_active_salespersons(self.store) self.salesperson.prefill(salespersons) change_salesperson = sysparam.get_int('ACCEPT_CHANGE_SALESPERSON') if change_salesperson == ChangeSalespersonPolicy.ALLOW: self.salesperson.grab_focus() elif change_salesperson == ChangeSalespersonPolicy.DISALLOW: self.salesperson.set_sensitive(False) elif change_salesperson == ChangeSalespersonPolicy.FORCE_CHOOSE: self.model.salesperson = None self.salesperson.grab_focus() else: raise AssertionError # CFOP combo if sysparam.get_bool('ASK_SALES_CFOP'): cfops = CfopData.get_for_sale(self.store) self.cfop.prefill(api.for_combo(cfops)) else: self.cfop_lbl.hide() self.cfop.hide() self.create_cfop.hide() self._fill_clients_category_combo() self._setup_clients_widget() self._client_credit_set_visible(bool(self.client.read()))
def on_confirm(self): if self._is_default_salesperson_role(): if self.salesperson: if not self.salesperson.is_active: self.salesperson.activate() else: store = self.store self.salesperson = SalesPerson(person=self.person, store=store) elif self.salesperson: if self.salesperson.is_active: self.salesperson.inactivate() old_salary = self.employee.salary self.employee.salary = self.model.salary if (self.model.role is not self.employee.role or old_salary != self.model.salary): self.employee.role = self.model.role if self.current_role_history: self.current_role_history.salary = old_salary self.current_role_history.ended = localnow() self.current_role_history.is_active = False else: # XXX This will prevent problems when you can't update # the connection. self.store.remove(self.model)
def setup_widgets(self): marker('Setting up widgets') # Only quotes have expire date. self.expire_date.hide() self.expire_label.hide() # Hide client category widgets self.client_category_lbl.hide() self.client_category.hide() # if the NF-e plugin is active, the client is mandantory in this # wizard (in this situation, we have only quote sales). if self.model.status == Sale.STATUS_QUOTE: manager = get_plugin_manager() mandatory_client = manager.is_active('nfe') self.client.set_property('mandatory', mandatory_client) marker('Filling sales persons') salespersons = SalesPerson.get_active_salespersons(self.store) self.salesperson.prefill(salespersons) marker('Finished filling sales persons') marker('Read parameter') change_salesperson = sysparam.get_int('ACCEPT_CHANGE_SALESPERSON') if change_salesperson == ChangeSalespersonPolicy.ALLOW: self.salesperson.grab_focus() elif change_salesperson == ChangeSalespersonPolicy.DISALLOW: self.salesperson.set_sensitive(False) elif change_salesperson == ChangeSalespersonPolicy.FORCE_CHOOSE: self.model.salesperson = None self.salesperson.grab_focus() else: raise AssertionError marker('Finished reading parameter') self._setup_clients_widget() self._fill_transporter_combo() self._fill_cost_center_combo() if sysparam.get_bool('ASK_SALES_CFOP'): self._fill_cfop_combo() else: self.cfop_lbl.hide() self.cfop.hide() self.create_cfop.hide() # the maximum number allowed for an invoice is 999999999. self.invoice_number.set_adjustment( gtk.Adjustment(lower=1, upper=999999999, step_incr=1)) if not self.model.invoice_number: new_invoice_number = Invoice.get_next_invoice_number(self.store) self.invoice_model.invoice_number = new_invoice_number else: new_invoice_number = self.model.invoice_number self.invoice_model.invoice_number = new_invoice_number self.invoice_number.set_sensitive(False) self.invoice_model.original_invoice = new_invoice_number marker('Finished setting up widgets')
def create_salesperson_filter(self, label=None): from stoqlib.domain.person import SalesPerson items = SalesPerson.get_active_items(self.store) items.insert(0, (_("Any"), None)) if not label: label = _('Salesperson:') return ComboSearchFilter(label, items)
def ensure_admin_user(administrator_password): log.info("Creating administrator user") default_store = get_default_store() user = get_admin_user(default_store) if user is None: store = new_store() person = Person(name=_(u'Administrator'), store=store) # Dependencies to create an user. role = EmployeeRole(name=_(u'System Administrator'), store=store) Individual(person=person, store=store) employee = Employee(person=person, role=role, store=store) EmployeeRoleHistory(store=store, role=role, employee=employee, is_active=True, salary=currency(800)) # This is usefull when testing a initial database. Admin user actually # must have all the facets. SalesPerson(person=person, store=store) profile = store.find(UserProfile, name=_(u'Administrator')).one() # Backwards compatibility. this profile used to be in english # FIXME: Maybe its safe to assume the first profile in the table is # the admin. if not profile: profile = store.find(UserProfile, name=u'Administrator').one() log.info("Attaching a LoginUser (%s)" % (USER_ADMIN_DEFAULT_NAME, )) LoginUser(person=person, username=USER_ADMIN_DEFAULT_NAME, password=administrator_password, profile=profile, store=store) store.commit(close=True) # Fetch the user again, this time from the right connection user = get_admin_user(default_store) assert user user.set_password(administrator_password) # We can't provide the utility until it's actually in the database log.info('providing utility ICurrentUser') provide_utility(ICurrentUser, user)
def process_one(self, data, fields, store): person = Person( store=store, name=data.name, phone_number=data.phone_number, mobile_number=data.mobile_number) Individual(person=person, store=store, cpf=data.cpf, rg_number=data.rg) role = EmployeeRole(store=store, name=data.role) employee = Employee(person=person, store=store, role=role, salary=int(data.salary), registry_number=data.employee_number) start = self.parse_date(data.start) EmployeeRoleHistory( store=store, role=role, employee=employee, is_active=True, began=start, salary=int(data.salary)) ctloc = CityLocation.get_or_create(store=store, city=data.city, state=data.state, country=data.country) streetnumber = data.streetnumber and int(data.streetnumber) or None Address(is_main_address=True, person=person, city_location=ctloc, store=store, street=data.street, streetnumber=streetnumber, district=data.district) if self.create_users: profile = store.find(UserProfile, name=data.profile).one() LoginUser(person=person, store=store, profile=profile, username=data.username, password=data.password) SalesPerson(person=person, store=store)
def setup_widgets(self): marker('Setting up widgets') # Only quotes have expire date. self.expire_date.hide() self.expire_label.hide() # Hide client category widgets self.client_category_lbl.hide() self.client_category.hide() # if the NF-e plugin is active, the client is mandantory in this # wizard (in this situation, we have only quote sales). if self.model.status == Sale.STATUS_QUOTE: manager = get_plugin_manager() mandatory_client = manager.is_active('nfe') self.client.set_property('mandatory', mandatory_client) marker('Filling sales persons') salespersons = SalesPerson.get_active_salespersons( self.store, api.get_current_branch(self.store)) self.salesperson.prefill(salespersons) marker('Finished filling sales persons') marker('Read parameter') change_salesperson = sysparam.get_int('ACCEPT_CHANGE_SALESPERSON') if change_salesperson == ChangeSalespersonPolicy.ALLOW: self.salesperson.grab_focus() elif change_salesperson == ChangeSalespersonPolicy.DISALLOW: self.salesperson.set_sensitive(False) elif change_salesperson == ChangeSalespersonPolicy.FORCE_CHOOSE: self.model.salesperson = None self.salesperson.grab_focus() else: raise AssertionError marker('Finished reading parameter') self._setup_clients_widget() self._fill_transporter_combo() self._fill_cost_center_combo() if sysparam.get_bool('ASK_SALES_CFOP'): self._fill_cfop_combo() else: self.cfop_lbl.hide() self.cfop.hide() self.create_cfop.hide() marker('Finished setting up widgets')
def _create_examples(self): person = Person(name=u'Jonas', store=self.store) Individual(person=person, store=self.store) role = EmployeeRole(store=self.store, name=u'desenvolvedor') Employee(person=person, store=self.store, role=role) self.salesperson = SalesPerson(person=person, store=self.store) Company(person=person, store=self.store) client = Client(person=person, store=self.store) self.branch = Branch(person=person, store=self.store) group = self.create_payment_group() self.sale = Sale(coupon_id=123, client=client, cfop_id=self.sparam.get_object_id('DEFAULT_SALES_CFOP'), group=group, branch=self.branch, salesperson=self.salesperson, store=self.store) self.storable = self.create_storable()
def on_confirm(self): if self.show_password_fields: self.model.set_password(self.password_slave.model.new_password) # FIXME: # 1) Move this hook into each instance of ProfileSettings # 2) Show some additional information in the user interface, which # are related to the facets the current profile will add profile = self.profile.get_selected() person = self.model.person employee = person.employee if employee is None: Employee(person=person, role=self.role.read(), store=self.store) else: employee.role = self.role.read() # If the user can access POS then he/she can perform sales too can_access_pos = profile.check_app_permission(u"pos") can_access_sales = profile.check_app_permission(u"sales") can_do_sales = can_access_pos or can_access_sales if can_do_sales and not person.salesperson: SalesPerson(person=person, store=self.store)
class EmployeeRoleSlave(BaseEditorSlave): gladefile = "EmployeeRoleSlave" model_type = EmployeeRoleHistory proxy_widgets = ("role", "salary") def __init__(self, store, employee, edit_mode, visual_mode=False): self.employee = employee self.person = employee.person self.salesperson = self.person.salesperson self.is_edit_mode = edit_mode self.current_role_history = self._get_active_role_history() BaseEditorSlave.__init__(self, store, visual_mode=visual_mode) def _setup_entry_completion(self): roles = self.store.find(EmployeeRole) self.role.prefill(api.for_combo(roles)) def _setup_widgets(self): self._setup_entry_completion() def _get_active_role_history(self): if self.is_edit_mode: return self.employee.get_active_role_history() else: return None def _is_default_salesperson_role(self): if sysparam(self.store).DEFAULT_SALESPERSON_ROLE == self.model.role: return True return False def on_confirm(self): if self._is_default_salesperson_role(): if self.salesperson: if not self.salesperson.is_active: self.salesperson.activate() else: store = self.store self.salesperson = SalesPerson(person=self.person, store=store) elif self.salesperson: if self.salesperson.is_active: self.salesperson.inactivate() old_salary = self.employee.salary self.employee.salary = self.model.salary if self.model.role is not self.employee.role or old_salary != self.model.salary: self.employee.role = self.model.role if self.current_role_history: self.current_role_history.salary = old_salary self.current_role_history.ended = datetime.datetime.now() self.current_role_history.is_active = False else: # XXX This will prevent problems when you can't update # the connection. self.model_type.delete(self.model.id, store=self.store) # # BaseEditorSlave Hooks # def create_model(self, store): return EmployeeRoleHistory( store=store, salary=self.employee.salary, role=self.employee.role, employee=self.employee ) def setup_proxies(self): self._setup_widgets() self.proxy = self.add_proxy(self.model, EmployeeRoleSlave.proxy_widgets) self._update_sensitivity() if not self.is_edit_mode: self.salary.set_text("") # # Kiwi handlers # def on_role_editor_button__clicked(self, *args): # This will avoid circular imports from stoqlib.gui.editors.personeditor import EmployeeRoleEditor self.store.savepoint("before_run_editor_employee_role") model = run_dialog(EmployeeRoleEditor, self, self.store, self.model.role) if model: self._setup_entry_completion() self.proxy.update("role") else: self.store.rollback_to_savepoint("before_run_editor_employee_role") def on_salary__validate(self, widget, value): if value <= 0: return ValidationError("Salary must be greater than zero") def after_role__content_changed(self, widget): self._update_sensitivity() def _update_sensitivity(self): editor = True if self.role.get_text(): editor = self.role.is_valid() else: self.model.role = None self.role_editor_button.set_sensitive(editor)
class EmployeeRoleSlave(BaseEditorSlave): gladefile = 'EmployeeRoleSlave' model_type = EmployeeRoleHistory proxy_widgets = ( 'role', 'salary', ) def __init__(self, store, employee, edit_mode, visual_mode=False): self.employee = employee self.person = employee.person self.sales_person = self.person.sales_person self.is_edit_mode = edit_mode self.current_role_history = self._get_active_role_history() BaseEditorSlave.__init__(self, store, visual_mode=visual_mode) def _setup_entry_completion(self): roles = self.store.find(EmployeeRole) self.role.prefill(api.for_combo(roles)) def _setup_widgets(self): self._setup_entry_completion() def _get_active_role_history(self): if self.is_edit_mode: return self.employee.get_active_role_history() else: return None def _is_default_salesperson_role(self): return sysparam.compare_object('DEFAULT_SALESPERSON_ROLE', self.model.role) def on_confirm(self): if self._is_default_salesperson_role(): if self.sales_person: if not self.sales_person.is_active: self.sales_person.activate() else: store = self.store self.sales_person = SalesPerson(person=self.person, store=store) elif self.sales_person: if self.sales_person.is_active: self.sales_person.inactivate() old_salary = self.employee.salary self.employee.salary = self.model.salary if (self.model.role is not self.employee.role or old_salary != self.model.salary): self.employee.role = self.model.role if self.current_role_history: self.current_role_history.salary = old_salary self.current_role_history.ended = localnow() self.current_role_history.is_active = False else: # XXX This will prevent problems when you can't update # the connection. self.store.remove(self.model) # # BaseEditorSlave Hooks # def create_model(self, store): return EmployeeRoleHistory(store=store, salary=self.employee.salary, role=self.employee.role, employee=self.employee) def setup_proxies(self): self._setup_widgets() self.proxy = self.add_proxy(self.model, EmployeeRoleSlave.proxy_widgets) self._update_sensitivity() if not self.is_edit_mode: self.salary.set_text("") # # Kiwi handlers # def on_role_editor_button__clicked(self, *args): # This will avoid circular imports from stoq.lib.gui.editors.personeditor import EmployeeRoleEditor self.store.savepoint('before_run_editor_employee_role') model = run_dialog(EmployeeRoleEditor, self, self.store, self.model.role) if model: self._setup_entry_completion() self.proxy.update('role') else: self.store.rollback_to_savepoint('before_run_editor_employee_role') def on_salary__validate(self, widget, value): if value <= 0: return ValidationError("Salary must be greater than zero") def after_role__content_changed(self, widget): self._update_sensitivity() def _update_sensitivity(self): editor = True if self.role.get_text(): editor = self.role.is_valid() else: self.model.role = None self.role_editor_button.set_sensitive(editor)
def _fill_salesperson_combo(self): salespersons = SalesPerson.get_active_salespersons(self.store) self.salesperson_combo.prefill(api.for_combo(salespersons))
def test_getactive_salespersons(self): count = SalesPerson.get_active_salespersons(self.store).count() salesperson = self.create_sales_person() one_more = salesperson.get_active_salespersons(self.store).count() assert count + 1 == one_more
def create_sales_person(self): from stoqlib.domain.person import SalesPerson employee = self.create_employee() return SalesPerson(person=employee.person, store=self.store)
def _fill_salesperson_combo(self): salespersons = SalesPerson.get_active_salespersons(self.store) self.salesperson_combo.prefill(salespersons)