Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
from trytond.report import Report
from trytond.tools import exec_command_pipe
from trytond.backend import TableHandler
import expr
import base64
class Workflow(ModelSQL, ModelView):
"Workflow"
_name = "workflow"
_table = "wkf"
_description = __doc__
name = fields.Char('Name', required=True, translate=True)
model = fields.Char('Resource Model', required=True, select=1)
on_create = fields.Boolean('On Create', select=2)
activities = fields.One2Many('workflow.activity', 'workflow',
'Activities')
def __init__(self):
super(Workflow, self).__init__()
self._error_messages.update({
'no_workflow_defined': 'No workflow defined!',
})
def init(self, cursor, module_name):
super(Workflow, self).init(cursor, module_name)
table = TableHandler(cursor, self, module_name)
# Migration from 1.2 rename osv into model
if table.column_exist('osv'):
cursor.execute('UPDATE "' + self._table + '" ' \
'SET model = osv')
WorkflowTransition()
class WorkflowInstance(ModelSQL, ModelView):
"Workflow instance"
_table = "wkf_instance"
_name = "workflow.instance"
_rec_name = 'res_type'
_description = __doc__
workflow = fields.Many2One('workflow', 'Workflow', ondelete="RESTRICT",
select=1)
uid = fields.Integer('User ID')
res_id = fields.Integer('Resource ID', required=True, select=1)
res_type = fields.Char('Resource Model', required=True, select=1)
state = fields.Char('State', required=True, select=1)
overflows = fields.One2Many('workflow.workitem', 'subflow',
'Overflow')
transitions = fields.Many2Many('workflow.transition-workflow.instance',
'inst_id', 'trans_id')
workitems = fields.One2Many('workflow.workitem', 'instance', 'Workitems')
def __init__(self):
super(WorkflowInstance, self).__init__()
self._error_messages.update({
'no_instance_defined': 'No workflow instance defined!',
})
for i in ('create', 'write', 'delete', 'copy'):
del self._rpc[i]
#TODO add a constraint to have only one active instance by resource
def init(self, cursor, module_name):
super(WorkflowInstance, self).init(cursor, module_name)
@wraps(func)
def wrapper(cls, modules):
modules = [m for m in modules if m.state == state]
return func(cls, modules)
return wrapper
return filter
class Module(ModelSQL, ModelView):
"Module"
__name__ = "ir.module"
name = fields.Char("Name", readonly=True, required=True)
version = fields.Function(fields.Char('Version'), 'get_version')
dependencies = fields.One2Many('ir.module.dependency',
'module', 'Dependencies', readonly=True)
parents = fields.Function(fields.One2Many('ir.module', None, 'Parents'),
'get_parents')
childs = fields.Function(fields.One2Many('ir.module', None, 'Childs'),
'get_childs')
state = fields.Selection([
('not activated', 'Not Activated'),
('activated', 'Activated'),
('to upgrade', 'To be upgraded'),
('to remove', 'To be removed'),
('to activate', 'To be activated'),
], string='State', readonly=True)
@classmethod
def __setup__(cls):
super(Module, cls).__setup__()
table = cls.__table__()
cls._sql_constraints = [
'Participants', states={'invisible': Eval('type') != 'task'},
depends=['type']
)
#: Tags for tasks.
tags = fields.Many2Many(
'project.work-project.work.tag', 'task', 'tag',
'Tags', depends=['type'],
states={
'invisible': Eval('type') != 'task',
'readonly': Eval('type') != 'task',
}
)
all_participants = fields.Function(
fields.One2Many(
'nereid.user', None,
'All Participants', depends=['company']
), 'get_all_participants'
)
assigned_to = fields.Many2One(
'nereid.user', 'Assigned to', depends=['all_participants'],
domain=[('id', 'in', Eval('all_participants'))],
states={
'invisible': Eval('type') != 'task',
'readonly': Eval('type') != 'task',
}
)
progress_state = fields.Selection(
PROGRESS_STATES, 'Progress State',
depends=['state', 'type'], select=True,
pass
class RuleGroup(ModelSQL, ModelView):
"Rule group"
__name__ = 'ir.rule.group'
name = fields.Char(
"Name", select=True, translate=True, required=True,
help="Displayed to users when access error is raised for this rule.")
model = fields.Many2One('ir.model', 'Model', select=True,
required=True, ondelete='CASCADE')
global_p = fields.Boolean('Global', select=True,
help="Make the rule global \nso every users must follow this rule.")
default_p = fields.Boolean('Default', select=True,
help="Add this rule to all users by default.")
rules = fields.One2Many('ir.rule', 'rule_group', 'Tests',
help="The rule is satisfied if at least one test is True.")
groups = fields.Many2Many('ir.rule.group-res.group',
'rule_group', 'group', 'Groups')
perm_read = fields.Boolean('Read Access')
perm_write = fields.Boolean('Write Access')
perm_create = fields.Boolean('Create Access')
perm_delete = fields.Boolean('Delete Access')
@classmethod
def __setup__(cls):
super(RuleGroup, cls).__setup__()
cls._order.insert(0, ('model', 'ASC'))
cls._order.insert(1, ('global_p', 'ASC'))
cls._order.insert(2, ('default_p', 'ASC'))
t = cls.__table__()
('key', '=', key),
])
if not shares:
return None
for share in shares:
if cls.match(share, command, path):
return share.user.id
return None
class Attachment(ModelSQL, ModelView):
__name__ = 'ir.attachment'
path = fields.Function(fields.Char('Path'), 'get_path')
url = fields.Function(fields.Char('URL'), 'get_url')
shares = fields.Function(fields.One2Many('webdav.share', None, 'Shares',
domain=[
('path', '=', Eval('path')),
],
depends=['path']), 'get_shares', 'set_shares')
@classmethod
def __setup__(cls):
super(Attachment, cls).__setup__()
cls._error_messages.update({
'collection_attachment_name': ('You can not create an '
'attachment named "%(attachment)s" in collection '
'"%(collection)s" because there is already a collection '
'with that name.')
})
@classmethod
args = args[2:]
super(ActionReport, cls).write(reports, values, *args)
class ActionActWindow(ActionMixin, ModelSQL, ModelView):
"Action act window"
__name__ = 'ir.action.act_window'
domain = fields.Char('Domain Value')
context = fields.Char('Context Value')
order = fields.Char('Order Value')
res_model = fields.Char('Model')
context_model = fields.Char('Context Model')
context_domain = fields.Char(
"Context Domain",
help="Part of the domain that will be evaluated on each refresh.")
act_window_views = fields.One2Many('ir.action.act_window.view',
'act_window', 'Views')
views = fields.Function(fields.Binary('Views'), 'get_views')
act_window_domains = fields.One2Many('ir.action.act_window.domain',
'act_window', 'Domains')
domains = fields.Function(fields.Binary('Domains'), 'get_domains')
limit = fields.Integer('Limit', help='Default limit for the list view.')
action = fields.Many2One('ir.action', 'Action', required=True,
ondelete='CASCADE')
search_value = fields.Char('Search Criteria',
help='Default search criteria for the list view.')
pyson_domain = fields.Function(fields.Char('PySON Domain'), 'get_pyson')
pyson_context = fields.Function(fields.Char('PySON Context'),
'get_pyson')
pyson_order = fields.Function(fields.Char('PySON Order'), 'get_pyson')
pyson_search_value = fields.Function(fields.Char(
'PySON Search Criteria'), 'get_pyson')
ref = field.model_name.replace('.','_')
else:
ref = self.pool.get(field.model_name)._table
table.add_fk(field_name, ref, field.ondelete)
table.index_action(
field_name, action=field.select and 'add' or 'remove')
required = field.required
if isinstance(field, (fields.Integer, fields.Float,
fields.Boolean)):
required = True
table.not_null_action(
field_name, action=required and 'add' or 'remove')
elif not isinstance(field, (fields.One2Many, fields.Function,
fields.Many2Many)):
raise Exception('Unknow field type !')
for field_name, field in self._columns.iteritems():
if isinstance(field, fields.Many2One) \
and field.model_name == self._name \
and field.left and field.right:
self._rebuild_tree(cursor, 0, field_name, False, 0)
for ident, constraint, msg in self._sql_constraints:
table.add_constraint(ident, constraint)
if self._history:
self._update_history_table(cursor)
cursor.execute('SELECT id FROM "' + self._table + '"')
if cursor.rowcount:
for sub_ids in grouped_slice(menu_ids):
test_ids.append(list(map(int, Menu.search([
('id', 'in', sub_ids),
]))))
menu_ids = set(chain(*test_ids))
for group_id, ids in res.items():
res[group_id] = tuple(id_ for id_ in ids if id_ in menu_ids)
return res
class Group(DeactivableMixin, ModelSQL, ModelView):
"Group"
__name__ = "res.group"
name = fields.Char('Name', required=True, select=True, translate=True)
users = fields.Many2Many('res.user-res.group', 'group', 'user', 'Users')
model_access = fields.One2Many('ir.model.access', 'group',
'Access Model')
field_access = fields.One2Many('ir.model.field.access', 'group',
'Access Field')
buttons = fields.Many2Many(
'ir.model.button-res.group', 'group', 'button', "Buttons")
rule_groups = fields.Many2Many('ir.rule.group-res.group',
'group', 'rule_group', 'Rules',
domain=[('global_p', '!=', True), ('default_p', '!=', True)])
menu_access = MenuMany2Many('ir.ui.menu-res.group',
'group', 'menu', 'Access Menu')
@classmethod
def __setup__(cls):
super(Group, cls).__setup__()
table = cls.__table__()
cls._sql_constraints += [
__all__ = ['NereidUser']
__metaclass__ = PoolMeta
class NereidUser:
"""
Add employee
"""
__name__ = "nereid.user"
#: Allow the nereid user to be connected to an internal employee. This
#: indicates that the user is an employee and not a regular participant
employee = fields.Many2One('company.employee', 'Employee', select=True)
member_of_projects = fields.One2Many(
"project.work.member", "user", "Member of Projects"
)
def serialize(self, purpose=None):
'''
Serialize NereidUser and return a dictonary.
'''
result = super(NereidUser, self).serialize(purpose)
result['image'] = {
'url': self.get_profile_picture(size=20),
}
result['email'] = self.email
result['employee'] = self.employee and self.employee.id or None
result['permissions'] = [p.value for p in self.permissions]
return result