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 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 _fill_salesperson_combo(self):
salespersons = SalesPerson.get_active_salespersons(self.store)
self.salesperson_combo.prefill(salespersons)
