def load_user(self, user):
try:
dict_user = self.load("users", user.id)
JavaDictMapper.update_object(user, dict_user)
return user
except NotFound:
raise UserNotFound()
def list(self):
dict_result = super(GroupQuery, self).list()
group_list = []
for dict_group in dict_result:
group = Group(dict_group["id"])
JavaDictMapper.update_object(group, dict_group)
group_list.append(group)
return group_list
def list(self):
dict_result = super(UserQuery, self).list()
user_list = []
for dict_user in dict_result:
user = User(dict_user["id"])
JavaDictMapper.update_object(user, dict_user)
user_list.append(user)
return user_list
def _parse(self, camel_case_data):
JavaDictMapper.update_object(self, camel_case_data)
if hasattr(self, "create_time"):
self.create_time = iso8601.parse_date(self.create_time)
if hasattr(self, "due_date"):
self.due_date = iso8601.parse_date(self.due_date)
self.execution = self._get_id(self.execution)
if hasattr(self, "parent_task"):
self.parent_task = self._get_id(self.parent_task)
if hasattr(self, "process_instance"):
self.process_instance = self._get_id(self.process_instance)
if hasattr(self, "task_variables"):
self.task_variables = Variables(self.task_variables)
if hasattr(self, "process_variables"):
self.process_variables = Variables(self.process_variables)
def create_user(self, user):
try:
dict_user = JavaDictMapper.get_dict(user)
self.create(dict_user, "users")
user._activiti_version = user.__dict__
except MissingID:
raise UserMissingID()
def update_group(self, group):
try:
dict_group = JavaDictMapper.get_dict(group)
self.update(dict_group, "groups", group.id)
except NotFound:
raise GroupNotFound()
except UpdatedSimultaneous:
raise GroupUpdatedSimultaneous()
def update_user(self, user):
dict_user = JavaDictMapper.get_dict(user)
try:
self.update(dict_user, "users", user.id)
except NotFound:
raise UserNotFound()
except UpdatedSimultaneous:
raise UserUpdatedSimultaneous()
def is_syncronized(self):
return self._activiti_version == JavaDictMapper.get_dict(self)
def create_group(self, group):
try:
dict_group = JavaDictMapper.get_dict(group)
self.create(dict_group, "groups")
except MissingID:
raise GroupMissingID()
def load_group(self, group):
try:
dict_group = self.load("groups", group.id)
JavaDictMapper.update_object(group, dict_group)
except NotFound:
raise GroupNotFound()
