def button_clicked(self, widget):
record = self.screen.current_record
record_id = self.screen.save_current()
attrs = widget.attrs
if record_id:
if not attrs.get('confirm', False) or \
common.sur(attrs['confirm']):
button_type = attrs.get('type', 'object')
context = record.context_get()
if button_type == 'object':
try:
RPCExecute('model', self.screen.model_name,
attrs['name'], [record_id], context=context)
except RPCException:
pass
elif button_type == 'action':
action_id = None
try:
action_id = RPCExecute('model', 'ir.action',
'get_action_id', int(attrs['name']),
context=context)
except RPCException:
pass
if action_id:
Action.execute(action_id, {
'model': self.screen.model_name,
'id': record_id,
'ids': [record_id],
}, context=context)
else:
raise Exception('Unallowed button type')
self.screen.reload(written=True)
else:
self.screen.display()
def response(self, win, response_id):
validate = False
cancel_responses = (gtk.RESPONSE_CANCEL, gtk.RESPONSE_DELETE_EVENT)
self.screen.current_view.set_value()
readonly = self.screen.group.readonly
if (response_id not in cancel_responses
and not readonly
and self.screen.current_record is not None):
validate = self.screen.current_record.validate(
self.screen.current_view.get_fields())
if validate and self.screen.pre_validate:
validate = self.screen.current_record.pre_validate()
if validate and self.save_current:
if not self.screen.save_current():
validate = False
elif validate and self.screen.current_view.view_type == 'form':
view = self.screen.current_view
for widgets in view.widgets.itervalues():
for widget in widgets:
if (hasattr(widget, 'screen')
and widget.screen.pre_validate):
record = widget.screen.current_record
if record:
validate = record.pre_validate()
if not validate:
self.message_info(self.screen.invalid_message(),
gtk.MESSAGE_ERROR)
self.screen.set_cursor()
self.screen.display()
return
self.message_info()
if response_id == gtk.RESPONSE_ACCEPT:
self.new()
return
if (self.screen.current_record
and not readonly
and response_id in cancel_responses):
if (self.screen.current_record.id < 0
or self.save_current):
if (self.save_current
or common.sur(
_('Are you sure you want to delete this record?')
)):
self.screen.group.remove(self.screen.current_record,
remove=True)
elif not self.save_current:
return
elif self.screen.current_record.modified:
self.screen.current_record.cancel()
self.screen.current_record.reload()
self.screen.current_record.signal('record-changed')
result = False
else:
result = response_id not in cancel_responses
self.callback(result)
self.destroy()
def sig_remove(self, widget=None):
if self.screen.current_view.view_type == 'form':
msg = _('Are you sure to remove this record?')
else:
msg = _('Are you sure to remove those records?')
if sur(msg):
if not self.screen.remove(delete=True, force_remove=True):
self.message_info(_('Records not removed!'))
else:
self.message_info(_('Records removed!'), 'green')
def addreplace_predef(self, widget):
iter = self.model2.get_iter_first()
fields = []
while iter:
field_name = self.model2.get_value(iter, 1)
fields.append(field_name)
iter = self.model2.iter_next(iter)
if not fields:
return
selection = self.pref_export.get_selection().get_selected()
if selection is None:
return
model, iter_ = selection
if iter_ is None:
pref_id = None
name = common.ask(_('What is the name of this export?'))
if not name:
return
else:
pref_id = model.get_value(iter_, 0)
name = model.get_value(iter_, 2)
override = common.sur(_("Override '%s' definition?") % name)
if not override:
return
try:
if not pref_id:
pref_id, = RPCExecute(
'model',
'ir.export',
'create', [{
'name':
name,
'resource':
self.model,
'export_fields': [('create', [{
'name': x,
} for x in fields])],
}],
context=self.context)
else:
RPCExecute('model',
'ir.export',
'update', [pref_id],
fields,
context=self.context)
except RPCException:
return
clear_cache('model.%s.view_toolbar_get' % self.model)
if iter_ is None:
self.predef_model.append((pref_id, fields, name))
else:
model.set_value(iter_, 0, pref_id)
model.set_value(iter_, 1, fields)
def sig_remove(self, widget=None):
if not common.MODELACCESS[self.model]['delete']:
return
if self.screen.current_view.view_type == 'form':
msg = _('Are you sure to remove this record?')
else:
msg = _('Are you sure to remove those records?')
if sur(msg):
if not self.screen.remove(delete=True, force_remove=True):
self.message_info(_('Records not removed.'), gtk.MESSAGE_ERROR)
else:
self.message_info(_('Records removed.'), gtk.MESSAGE_INFO)
def sig_remove(self, widget=None):
if not common.MODELACCESS[self.model]['delete']:
return
if self.screen.current_view.view_type == 'form':
msg = _('Are you sure to remove this record?')
else:
msg = _('Are you sure to remove those records?')
if sur(msg):
if not self.screen.remove(delete=True, force_remove=True):
self.message_info(_('Records not removed.'), gtk.MESSAGE_ERROR)
else:
self.message_info(_('Records removed.'), gtk.MESSAGE_INFO)
def get_values(self, treeview, row, column):
treemod = treeview.get_model()
tree_iter = treemod.get_iter(row)
# Get GNU Health Federation ID (column 0)
federation_id = treemod.get_value(tree_iter,0)
#Federation Resource name
resource = self.resource.get_text()
#local model associated to federation resource
model = self.modinfo[resource]
local_vals = self.set_local_data(model,
self.federation_data.json())
local_record = self.check_local_record (federation_id)
if (local_record):
already_exists_msg= \
"A record exists LOCALLY with this ID \n\n" \
"Would you like to update it \n" \
"with the data from the Federation ?"
resp_update = sur (_(already_exists_msg))
# Create the record locally from the information
# retrieved from the Federation
if (resp_update):
local_record = \
self.update_local_record (model, local_record, local_vals)
else:
not_found_locally_msg= \
"The person exists on the Federation" \
" but not locally... \n" \
"Would you like to transfer it ?"
resp_create = sur (_(not_found_locally_msg))
# Create the record locally from the information
# retrieved from the Federation
if (resp_create):
local_record = self.create_local_record (model, local_vals)
def sig_remove(self, widget=None):
if (not common.MODELACCESS[self.model]['delete']
or not self.screen.deletable):
return
if self.screen.current_view.view_type == 'form':
msg = _('Are you sure to remove this record?')
else:
msg = _('Are you sure to remove those records?')
if sur(msg):
if not self.screen.remove(delete=True, force_remove=True):
self.message_info(
_('Records not removed.'), Gtk.MessageType.ERROR)
else:
self.message_info(_('Records removed.'), Gtk.MessageType.INFO)
self.screen.count_tab_domain(True)
def button_clicked(self, widget, path):
if not path:
return True
store = self.treeview.get_model()
record = store.get_value(store.get_iter(path), 0)
state_changes = record.expr_eval(
self.attrs.get('states', {}), check_load=False)
if state_changes.get('invisible') \
or state_changes.get('readonly'):
return True
self.screen.current_record = record
obj_id = self.screen.save_current()
if obj_id:
if not self.attrs.get('confirm', False) or \
common.sur(self.attrs['confirm']):
button_type = self.attrs.get('type', 'object')
ctx = record.context_get()
if button_type == 'object':
try:
RPCExecute('model', self.screen.model_name,
self.attrs['name'], [obj_id], context=ctx)
except RPCException:
pass
elif button_type == 'action':
try:
action_id = RPCExecute('model', 'ir.action',
'get_action_id', int(self.attrs['name']),
context=ctx)
except RPCException:
action_id = None
if action_id:
Action.execute(action_id, {
'model': self.screen.model_name,
'id': obj_id,
'ids': [obj_id],
}, context=ctx)
else:
raise Exception('Unallowed button type')
self.screen.reload(written=True)
else:
self.screen.display()
def addreplace_predef(self, widget):
iter = self.model2.get_iter_root()
fields = []
while iter:
field_name = self.model2.get_value(iter, 1)
fields.append(field_name)
iter = self.model2.iter_next(iter)
if not fields:
return
selection = self.pref_export.get_selection().get_selected()
if selection is None:
return
model, iter_ = selection
if iter_ is None:
pref_id = None
name = common.ask(_("What is the name of this export?"))
if not name:
return
else:
pref_id = model.get_value(iter_, 0)
name = model.get_value(iter_, 2)
override = common.sur(_("Override '%s' definition?") % name)
if not override:
return
try:
new_id, = RPCExecute(
"model",
"ir.export",
"create",
[{"name": name, "resource": self.model, "export_fields": [("create", [{"name": x} for x in fields])]}],
context=self.context,
)
if pref_id:
RPCExecute("model", "ir.export", "delete", [pref_id], context=self.context)
except RPCException:
return
if iter_ is None:
self.predef_model.append((new_id, fields, name))
else:
model.set_value(iter_, 0, new_id)
model.set_value(iter_, 1, fields)
def close_pages(self):
if self.notebook.get_n_pages():
if not common.sur(
_('The following action requires to close all tabs.\n'
'Do you want to continue?')):
return False
res = True
while res:
wid = self.get_page()
if wid:
if not wid.sig_close():
return False
res = self._win_del()
else:
res = False
if self.menu_screen:
self.menu_screen.save_tree_state()
if self.menu.get_visible():
CONFIG['menu.pane'] = self.pane.get_position()
return True
def button(self, button):
'Execute button on the current record'
if button.get('confirm', False) and not sur(button['confirm']):
return
record = self.current_record
if not record.save(force_reload=False):
return
context = record.context_get()
try:
action_id = RPCExecute('model', self.model_name, button['name'],
[record.id], context=context)
except RPCException:
action_id = None
if action_id:
Action.execute(action_id, {
'model': self.model_name,
'id': record.id,
'ids': [record.id],
}, context=context)
self.reload([record.id], written=True)
def button(self, button):
'Execute button on the selected records'
self.current_view.set_value()
fields = self.current_view.get_fields()
for record in self.selected_records:
domain = record.expr_eval(
button.get('states', {})).get('pre_validate', [])
if not record.validate(fields, pre_validate=domain):
self.display(set_cursor=True)
if domain:
# Reset valid state with normal domain
record.validate(fields)
return
if button.get('confirm', False) and not sur(button['confirm']):
return
if button.get('type', 'class') == 'class':
if not self.current_record.save(force_reload=False):
return
if button.get('type', 'class') == 'class':
self._button_class(button)
else:
self._button_instance(button)
def button(self, button):
'Execute button on the current record'
if button.get('confirm', False) and not sur(button['confirm']):
return
record = self.current_record
if not record.save(force_reload=False):
return
context = record.context_get()
try:
action_id = RPCExecute('model',
self.model_name,
button['name'], [record.id],
context=context)
except RPCException:
action_id = None
if action_id:
Action.execute(action_id, {
'model': self.model_name,
'id': record.id,
'ids': [record.id],
},
context=context)
self.reload([record.id], written=True)
def button(self, button):
'Execute button on the selected records'
self.current_view.set_value()
fields = self.current_view.get_fields()
for record in self.selected_records:
domain = record.expr_eval(
button.get('states', {})).get('pre_validate', [])
if not record.validate(fields, pre_validate=domain):
warning(self.invalid_message(record), _('Pre-validation'))
self.display(set_cursor=True)
if domain:
# Reset valid state with normal domain
record.validate(fields)
return
if button.get('confirm', False) and not sur(button['confirm']):
return
if button.get('type', 'class') == 'class':
if not self.current_record.save(force_reload=False):
return
if button.get('type', 'class') == 'class':
self._button_class(button)
else:
self._button_instance(button)
