def test_state_change_is_synced_to_globalindex(self):
self.login(self.dossier_responsible)
change_task_workflow_state(
self.subtask, 'task-transition-resolved-tested-and-closed')
self.assertEqual('task-state-tested-and-closed',
self.subtask.get_sql_object().review_state)
def test_adds_corresponding_answer(self):
self.login(self.dossier_responsible)
change_task_workflow_state(
self.subtask, 'task-transition-resolved-tested-and-closed')
self.assertEqual('task-transition-resolved-tested-and-closed',
IResponseContainer(self.subtask)[-1].transition)
def test_changes_workflow_state(self):
self.login(self.dossier_responsible)
change_task_workflow_state(
self.subtask, 'task-transition-resolved-tested-and-closed')
self.assertEqual('task-state-tested-and-closed',
api.content.get_state(self.subtask))
def render(self):
if self.is_already_done():
# Set correct content type for text response
self.request.response.setHeader("Content-type", "text/plain")
return 'OK'
mtool = getToolByName(self.context, 'portal_membership')
member = mtool.getAuthenticatedMember()
if not member.checkPermission('Add portal content', self.context):
raise Unauthorized()
successor_oguid = self.request.get('successor_oguid')
transition = self.request.get('transition')
response_text = self.request.get('response_text')
if transition:
change_task_workflow_state(self.context,
transition,
text=response_text,
successor_oguid=successor_oguid)
IYearfolderStorer(self.context).store_in_yearfolder()
# Set correct content type for text response
self.request.response.setHeader("Content-type", "tex/plain")
return 'OK'
def test_adds_corresponding_answer(self):
self.login(self.dossier_responsible)
change_task_workflow_state(
self.subtask, 'task-transition-resolved-tested-and-closed')
self.assertEqual('task-transition-resolved-tested-and-closed',
IResponseContainer(self.subtask)[-1].transition)
def render(self):
if self.is_already_done():
# Set correct content type for text response
self.request.response.setHeader("Content-type", "text/plain")
return 'OK'
mtool = getToolByName(self.context, 'portal_membership')
member = mtool.getAuthenticatedMember()
if not member.checkPermission('Add portal content', self.context):
raise Unauthorized()
successor_oguid = self.request.get('successor_oguid')
transition = self.request.get('transition')
response_text = self.request.get('response_text')
if transition:
change_task_workflow_state(self.context,
transition,
text=response_text,
successor_oguid=successor_oguid)
IYearfolderStorer(self.context).store_in_yearfolder()
# Set correct content type for text response
self.request.response.setHeader("Content-type", "tex/plain")
return 'OK'
def test_changes_workflow_state(self):
self.login(self.dossier_responsible)
change_task_workflow_state(
self.subtask, 'task-transition-resolved-tested-and-closed')
self.assertEqual('task-state-tested-and-closed',
api.content.get_state(self.subtask))
def __call__(self):
text = self.request.get('text')
if self.is_already_done():
return ok_response(self.request)
change_task_workflow_state(self.context, self.transition, text=text)
return ok_response(self.request)
def __call__(self):
text = self.request.get('text')
if self.is_already_done():
return ok_response(self.request)
change_task_workflow_state(self.context, self.transition, text=text)
return ok_response(self.request)
def test_state_change_is_synced_to_globalindex(self):
self.login(self.dossier_responsible)
change_task_workflow_state(
self.subtask, 'task-transition-resolved-tested-and-closed')
self.assertEqual('task-state-tested-and-closed',
self.subtask.get_sql_object().review_state)
def assign_forwarding_to_dossier(
context, forwarding_oguid, dossier, response_text):
forwarding = Task.query.by_oguid(forwarding_oguid)
forwarding_obj = context.unrestrictedTraverse(
forwarding.physical_path.encode('utf-8'))
# we need all task field values from the forwarding
fielddata = {}
for fieldname in ITask.names():
value = ITask.get(fieldname).get(forwarding_obj)
fielddata[fieldname] = value
# Reset issuer to the current inbox
fielddata['issuer'] = get_current_org_unit().inbox().id()
# Predefine the task_type to avoid tasks with an invalid task_type
fielddata['task_type'] = FORWARDING_SUCCESSOR_TYPE
# lets create a new task - the successor task
task = createContentInContainer(
dossier, 'opengever.task.task', **fielddata)
successor_tc_task = ISuccessorTaskController(task)
# Add issuer and responsible to the watchers of the newly created task
center = notification_center()
center.add_task_responsible(task, task.responsible)
center.add_task_issuer(task, task.issuer)
# copy documents and map the intids
intids_mapping = _copy_documents_from_forwarding(forwarding_obj, task)
# copy the responses
response_transporter = IResponseTransporter(task)
response_transporter.get_responses(
get_current_admin_unit().id(),
'/'.join(forwarding_obj.getPhysicalPath()),
intids_mapping=intids_mapping)
# close and store the forwarding in yearfolder
change_task_workflow_state(
forwarding_obj,
'forwarding-transition-assign-to-dossier',
text=response_text,
successor_oguid=successor_tc_task.get_oguid())
IYearfolderStorer(forwarding_obj).store_in_yearfolder()
# successor
successor_tc_task.set_predecessor(forwarding_oguid)
return task
def render(self):
data = self.request.get('data', None)
assert data is not None, 'Bad request: no delivery data found'
data = json.loads(data)
if self.is_already_delivered(data):
# Set correct content type for text response
self.request.response.setHeader("Content-type", "tex/plain")
return 'OK'
mtool = getToolByName(self.context, 'portal_membership')
member = mtool.getAuthenticatedMember()
if not member.checkPermission('Add portal content', self.context):
raise Unauthorized()
# Set the "X-CREATING-SUCCESSOR" flag for preventing the event
# handler from creating additional responses per added document.
self.request.set('X-CREATING-SUCCESSOR', True)
# Create the delivered documents:
transporter = getUtility(ITransporter)
documents = []
message = _(u'version_message_resolved_task',
default=u'Document copied from task (task resolved)')
if data.get('transition'
) == 'task-transition-in-progress-tested-and-closed':
message = _(u'version_message_closed_task',
default=u'Document copied from task (task closed)')
with CustomInitialVersionMessage(message, self.context.REQUEST):
for item in encode_after_json(data['documents']):
doc = transporter._create_object(self.context, item)
# append `RE:` prefix to the document title
doc.title = '%s: %s' % (translate(
_(u'answer_prefix', default=u'RE'),
context=self.context.REQUEST), doc.title)
documents.append(doc)
notify(ObjectAddedEvent(doc))
# Change workflow state of predecessor task:
util.change_task_workflow_state(self.context,
data['transition'],
text=data['text'],
added_object=documents)
# Set correct content type for text response
self.request.response.setHeader("Content-type", "tex/plain")
return 'OK'
def render(self):
task = self.get_task()
text = self.get_text()
transition = 'task-transition-open-tested-and-closed'
change_task_workflow_state(task, transition, text=text)
redirect_url = self.request.get('redirect_url', None)
if redirect_url is None:
redirect_url = task.absolute_url()
return self.request.RESPONSE.redirect(redirect_url)
def render(self):
task = self.get_task()
text = self.get_text()
transition = 'task-transition-open-tested-and-closed'
change_task_workflow_state(task, transition, text=text)
redirect_url = self.request.get('redirect_url', None)
if redirect_url is None:
redirect_url = task.absolute_url()
return self.request.RESPONSE.redirect(redirect_url)
def assign_forwarding_to_dossier(context, forwarding_oguid, dossier,
response_text):
forwarding = Task.query.by_oguid(forwarding_oguid)
forwarding_obj = context.unrestrictedTraverse(
forwarding.physical_path.encode('utf-8'))
# we need all task field values from the forwarding
fielddata = {}
for fieldname in ITask.names():
value = ITask.get(fieldname).get(forwarding_obj)
fielddata[fieldname] = value
# Reset issuer to the current inbox
fielddata['issuer'] = get_current_org_unit().inbox().id()
# Predefine the task_type to avoid tasks with an invalid task_type
fielddata['task_type'] = FORWARDING_SUCCESSOR_TYPE
# lets create a new task - the successor task
task = createContentInContainer(dossier, 'opengever.task.task',
**fielddata)
successor_tc_task = ISuccessorTaskController(task)
# Add issuer and responsible to the watchers of the newly created task
center = notification_center()
center.add_task_responsible(task, task.responsible)
center.add_task_issuer(task, task.issuer)
# copy documents and map the intids
intids_mapping = _copy_documents_from_forwarding(forwarding_obj, task)
# copy the responses
response_transporter = IResponseTransporter(task)
response_transporter.get_responses(get_current_admin_unit().id(),
'/'.join(
forwarding_obj.getPhysicalPath()),
intids_mapping=intids_mapping)
# close and store the forwarding in yearfolder
change_task_workflow_state(forwarding_obj,
'forwarding-transition-assign-to-dossier',
text=response_text,
successor_oguid=successor_tc_task.get_oguid())
IYearfolderStorer(forwarding_obj).store_in_yearfolder()
# successor
successor_tc_task.set_predecessor(forwarding_oguid)
return task
def __call__(self):
data = self.request.get('data', None)
assert data is not None, 'Bad request: no delivery data found'
data = json.loads(data)
if self.is_already_delivered(data):
return ok_response()
mtool = getToolByName(self.context, 'portal_membership')
member = mtool.getAuthenticatedMember()
if not member.checkPermission('Add portal content', self.context):
raise Unauthorized()
# Set the "X-CREATING-SUCCESSOR" flag for preventing the event
# handler from creating additional responses per added document.
self.request.set('X-CREATING-SUCCESSOR', True)
# Create the delivered documents:
transporter = Transporter()
documents = []
message = _(
u'version_message_resolved_task',
default=u'Document copied from task (task resolved)')
if data.get(
'transition') == 'task-transition-in-progress-tested-and-closed':
message = _(
u'version_message_closed_task',
default=u'Document copied from task (task closed)')
for item in data['documents']:
doc = transporter.create(item, self.context)
Versioner(doc).set_custom_initial_version_comment(message)
# append `RE:` prefix to the document title
doc.title = '%s: %s' % (
translate(
_(u'answer_prefix', default=u'RE'),
context=self.context.REQUEST),
doc.title)
documents.append(doc)
notify(ObjectAddedEvent(doc))
# Change workflow state of predecessor task:
util.change_task_workflow_state(
self.context, data['transition'], text=data['text'],
added_object=documents)
return ok_response()
def render(self):
data = self.request.get('data', None)
assert data is not None, 'Bad request: no delivery data found'
data = json.loads(data)
if self.is_already_delivered(data):
return ok_response()
mtool = getToolByName(self.context, 'portal_membership')
member = mtool.getAuthenticatedMember()
if not member.checkPermission('Add portal content', self.context):
raise Unauthorized()
# Set the "X-CREATING-SUCCESSOR" flag for preventing the event
# handler from creating additional responses per added document.
self.request.set('X-CREATING-SUCCESSOR', True)
# Create the delivered documents:
transporter = Transporter()
documents = []
message = _(
u'version_message_resolved_task',
default=u'Document copied from task (task resolved)')
if data.get(
'transition') == 'task-transition-in-progress-tested-and-closed':
message = _(
u'version_message_closed_task',
default=u'Document copied from task (task closed)')
with CustomInitialVersionMessage(message, self.context.REQUEST):
for item in data['documents']:
doc = transporter.create(item, self.context)
# append `RE:` prefix to the document title
doc.title = '%s: %s' % (
translate(
_(u'answer_prefix', default=u'RE'),
context=self.context.REQUEST),
doc.title)
documents.append(doc)
notify(ObjectAddedEvent(doc))
# Change workflow state of predecessor task:
util.change_task_workflow_state(
self.context, data['transition'], text=data['text'],
added_object=documents)
return ok_response()
def handle_close(self, action):
data, errors = self.extractData()
if not errors:
# close and store the forwarding in yearfolder
change_task_workflow_state(self.context,
'forwarding-transition-close',
text=data.get('text'))
IYearfolderStorer(self.context).store_in_yearfolder()
return self.request.RESPONSE.redirect('.')
def handle_close(self, action):
data, errors = self.extractData()
if not errors:
# close and store the forwarding in yearfolder
change_task_workflow_state(
self.context,
'forwarding-transition-close',
text=data.get('text'))
IYearfolderStorer(self.context).store_in_yearfolder()
return self.request.RESPONSE.redirect('.')
def render(self):
data = self.request.get("data", None)
assert data is not None, "Bad request: no delivery data found"
data = json.loads(data)
if self.is_already_delivered(data):
# Set correct content type for text response
self.request.response.setHeader("Content-type", "tex/plain")
return "OK"
mtool = getToolByName(self.context, "portal_membership")
member = mtool.getAuthenticatedMember()
if not member.checkPermission("Add portal content", self.context):
raise Unauthorized()
# Set the "X-CREATING-SUCCESSOR" flag for preventing the event
# handler from creating additional responses per added document.
self.request.set("X-CREATING-SUCCESSOR", True)
# Create the delivered documents:
transporter = getUtility(ITransporter)
documents = []
message = _(u"version_message_resolved_task", default=u"Document copied from task (task resolved)")
if data.get("transition") == "task-transition-in-progress-tested-and-closed":
message = _(u"version_message_closed_task", default=u"Document copied from task (task closed)")
with CustomInitialVersionMessage(message, self.context.REQUEST):
for item in encode_after_json(data["documents"]):
doc = transporter._create_object(self.context, item)
# append `RE:` prefix to the document title
doc.title = "%s: %s" % (
translate(_(u"answer_prefix", default=u"RE"), context=self.context.REQUEST),
doc.title,
)
documents.append(doc)
notify(ObjectAddedEvent(doc))
# Change workflow state of predecessor task:
util.change_task_workflow_state(self.context, data["transition"], text=data["text"], added_object=documents)
# Set correct content type for text response
self.request.response.setHeader("Content-type", "tex/plain")
return "OK"
def accept_task_with_response(task, response_text, successor_oguid=None):
transition = ACCEPT_TASK_TRANSITION
response = change_task_workflow_state(task,
transition,
text=response_text,
successor_oguid=successor_oguid)
return response
def accept_task_with_response(task, response_text, successor_oguid=None):
transition = ACCEPT_TASK_TRANSITION
response = change_task_workflow_state(task,
transition,
text=response_text,
successor_oguid=successor_oguid)
return response
def assign_forwarding_to_dossier(
context, forwarding_oguid, dossier, response_text):
forwarding = getUtility(ITaskQuery).get_task_by_oguid(forwarding_oguid)
forwarding_obj = context.unrestrictedTraverse(
forwarding.physical_path.encode('utf-8'))
# we need all task field values from the forwarding
fielddata = {}
for fieldname in ITask.names():
value = ITask.get(fieldname).get(forwarding_obj)
fielddata[fieldname] = value
# lets create a new task - the successor task
task = createContentInContainer(
dossier, 'opengever.task.task', **fielddata)
successor_tc_task = ISuccessorTaskController(task)
# copy documents and map the intids
intids_mapping = _copy_documents_from_forwarding(forwarding_obj, task)
# copy the responses
response_transporter = IResponseTransporter(task)
response_transporter.get_responses(
get_client_id(),
'/'.join(forwarding_obj.getPhysicalPath()),
intids_mapping=intids_mapping)
# close and store the forwarding in yearfolder
change_task_workflow_state(
forwarding_obj,
'forwarding-transition-assign-to-dossier',
text=response_text,
successor_oguid=successor_tc_task.get_oguid())
inbox = aq_parent(aq_inner(forwarding_obj))
yearfolder = _get_yearfolder(inbox)
clipboard = inbox.manage_cutObjects((forwarding_obj.getId(),))
yearfolder.manage_pasteObjects(clipboard)
# successor
successor_tc_task.set_predecessor(forwarding_oguid)
return task
def assign_forwarding_to_dossier(context, forwarding_oguid, dossier,
response_text):
forwarding = getUtility(ITaskQuery).get_task_by_oguid(forwarding_oguid)
forwarding_obj = context.unrestrictedTraverse(
forwarding.physical_path.encode('utf-8'))
# we need all task field values from the forwarding
fielddata = {}
for fieldname in ITask.names():
value = ITask.get(fieldname).get(forwarding_obj)
fielddata[fieldname] = value
# lets create a new task - the successor task
task = createContentInContainer(dossier, 'opengever.task.task',
**fielddata)
successor_tc_task = ISuccessorTaskController(task)
# copy documents and map the intids
intids_mapping = _copy_documents_from_forwarding(forwarding_obj, task)
# copy the responses
response_transporter = IResponseTransporter(task)
response_transporter.get_responses(get_client_id(),
'/'.join(
forwarding_obj.getPhysicalPath()),
intids_mapping=intids_mapping)
# close and store the forwarding in yearfolder
change_task_workflow_state(forwarding_obj,
'forwarding-transition-assign-to-dossier',
text=response_text,
successor_oguid=successor_tc_task.get_oguid())
inbox = aq_parent(aq_inner(forwarding_obj))
yearfolder = _get_yearfolder(inbox)
clipboard = inbox.manage_cutObjects((forwarding_obj.getId(), ))
yearfolder.manage_pasteObjects(clipboard)
# successor
successor_tc_task.set_predecessor(forwarding_oguid)
return task
def handle_save(self, action):
data, errors = self.extractData()
if not errors:
# Syncing the workflow change is done during document delivery
# (see deliver_documents_and_complete_task) therefore we skip
# the workflow syncing.
util.change_task_workflow_state(self.context,
data['transition'],
disable_sync=True,
text=data['text'])
response = IResponseContainer(self.context).list()[-1]
self.deliver_documents_and_complete_task(data, response)
msg = _(u'The documents were delivered to the issuer and the '
u'tasks were completed.')
IStatusMessage(self.request).addStatusMessage(msg, 'info')
url = self.context.absolute_url()
return self.request.RESPONSE.redirect(url)
def handle_save(self, action):
data, errors = self.extractData()
if not errors:
response = util.change_task_workflow_state(self.context, data["transition"], text=data["text"])
self.deliver_documents_and_complete_task(data, response)
msg = _(u"The documents were delivered to the issuer and the " u"tasks were completed.")
IStatusMessage(self.request).addStatusMessage(msg, "info")
url = self.context.absolute_url()
return self.request.RESPONSE.redirect(url)
def __call__(self):
if self.is_already_done():
return ok_response()
mtool = getToolByName(self.context, 'portal_membership')
member = mtool.getAuthenticatedMember()
if not member.checkPermission('Add portal content', self.context):
raise Unauthorized()
successor_oguid = self.request.get('successor_oguid')
transition = self.request.get('transition')
response_text = self.request.get('response_text')
if transition:
change_task_workflow_state(self.context,
transition,
text=response_text,
successor_oguid=successor_oguid)
IYearfolderStorer(self.context).store_in_yearfolder()
return ok_response()
def __call__(self):
if self.is_already_done():
return ok_response()
mtool = getToolByName(self.context, 'portal_membership')
member = mtool.getAuthenticatedMember()
if not member.checkPermission('Add portal content', self.context):
raise Unauthorized()
successor_oguid = self.request.get('successor_oguid')
transition = self.request.get('transition')
response_text = self.request.get('response_text')
if transition:
change_task_workflow_state(self.context,
transition,
text=response_text,
successor_oguid=successor_oguid)
IYearfolderStorer(self.context).store_in_yearfolder()
return ok_response()
def handle_save(self, action):
data, errors = self.extractData()
if not errors:
response = util.change_task_workflow_state(self.context,
data['transition'],
text=data['text'])
self.deliver_documents_and_complete_task(data, response)
msg = _(u'The documents were delivered to the issuer and the '
u'tasks were completed.')
IStatusMessage(self.request).addStatusMessage(msg, 'info')
url = self.context.absolute_url()
return self.request.RESPONSE.redirect(url)
def close_task(self, text):
change_task_workflow_state(
self.context, 'task-transition-open-tested-and-closed', text=text)
def accept_forwarding_with_successor(
context, predecessor_oguid, response_text, dossier=None):
# the predessecor (the forwarding on the remote client)
predecessor = getUtility(ITaskQuery).get_task_by_oguid(predecessor_oguid)
# get the inbox
cat = getToolByName(context, 'portal_catalog')
inboxes = cat(portal_type="opengever.inbox.inbox")
if len(inboxes) == 0:
raise Unauthorized()
else:
inbox = inboxes[0].getObject()
# transport the remote forwarding to the inbox or actual yearfolder
transporter = getUtility(ITransporter)
if dossier:
yearfolder = _get_yearfolder(inbox, )
successor_forwarding = transporter.transport_from(
yearfolder, predecessor.client_id, predecessor.physical_path)
else:
successor_forwarding = transporter.transport_from(
inbox, predecessor.client_id, predecessor.physical_path)
# Replace the issuer with the current inbox
successor_forwarding.issuer = u'inbox:%s' % get_client_id()
# Set the "X-CREATING-SUCCESSOR" flag for preventing the event handler
# from creating additional responses per added document.
successor_forwarding.REQUEST.set('X-CREATING-SUCCESSOR', True)
successor_tc = ISuccessorTaskController(successor_forwarding)
# copy documents and map the intids
doc_transporter = getUtility(ITaskDocumentsTransporter)
with CustomInitialVersionMessage(
_(u'version_message_accept_forwarding',
default=u'Document copied from forwarding (forwarding accepted)'),
context.REQUEST):
intids_mapping = doc_transporter.copy_documents_from_remote_task(
predecessor, successor_forwarding)
# copy the responses
response_transporter = IResponseTransporter(successor_forwarding)
response_transporter.get_responses(predecessor.client_id,
predecessor.physical_path,
intids_mapping=intids_mapping)
# if a dossier is given means that a successor task must
# be created in a new or a existing dossier
if dossier:
# we need all task field values from the forwarding
fielddata = {}
for fieldname in ITask.names():
value = ITask.get(fieldname).get(successor_forwarding)
fielddata[fieldname] = value
# lets create a new task - the successor task
task = createContentInContainer(
dossier, 'opengever.task.task', **fielddata)
# copy documents and map the intids
intids_mapping = _copy_documents_from_forwarding(
successor_forwarding, task)
# copy the responses
response_transporter = IResponseTransporter(task)
response_transporter.get_responses(
get_client_id(),
'/'.join(successor_forwarding.getPhysicalPath()),
intids_mapping=intids_mapping)
# successor
successor_tc_task = ISuccessorTaskController(task)
transaction.savepoint()
# Close the predessecor forwarding
response_text = response_text or ''
request_data = {'response_text': response_text.encode('utf-8'),
'successor_oguid': successor_tc.get_oguid(),
'transition': 'forwarding-transition-accept'}
response = remote_request(predecessor.client_id,
'@@store_forwarding_in_yearfolder',
path=predecessor.physical_path,
data=request_data)
if response.read().strip() != 'OK':
raise Exception('Adding the response and changing the '
'workflow state on the predecessor forwarding '
'failed.')
if dossier:
# when a successor task exists, we close also the successor forwarding
change_task_workflow_state(
successor_forwarding,
'forwarding-transition-accept',
text=response_text,
successor_oguid=successor_tc_task.get_oguid())
# create the succssor relations
successor_tc.set_predecessor(predecessor_oguid)
if dossier:
successor_tc_task.set_predecessor(successor_tc.get_oguid())
return task
return successor_forwarding
def close_task(self, text):
change_task_workflow_state(self.context,
'task-transition-open-tested-and-closed',
text=text)
def accept_forwarding_with_successor(context,
predecessor_oguid,
response_text,
dossier=None):
# the predessecor (the forwarding on the remote client)
predecessor = Task.query.by_oguid(predecessor_oguid)
# transport the remote forwarding to the inbox or actual yearfolder
transporter = Transporter()
inbox = get_current_inbox(context)
if dossier:
yearfolder = get_current_yearfolder(inbox=inbox)
successor_forwarding = transporter.transport_from(
yearfolder, predecessor.admin_unit_id, predecessor.physical_path)
else:
successor_forwarding = transporter.transport_from(
inbox, predecessor.admin_unit_id, predecessor.physical_path)
# Replace the issuer with the current inbox
successor_forwarding.issuer = get_current_org_unit().inbox().id()
# Set the "X-CREATING-SUCCESSOR" flag for preventing the event handler
# from creating additional responses per added document.
successor_forwarding.REQUEST.set('X-CREATING-SUCCESSOR', True)
successor_tc = ISuccessorTaskController(successor_forwarding)
# copy documents and map the intids
doc_transporter = getUtility(ITaskDocumentsTransporter)
comment = _(
u'version_message_accept_forwarding',
default=u'Document copied from forwarding (forwarding accepted)')
intids_mapping = doc_transporter.copy_documents_from_remote_task(
predecessor, successor_forwarding, comment=comment)
# copy the responses
response_transporter = IResponseTransporter(successor_forwarding)
response_transporter.get_responses(predecessor.admin_unit_id,
predecessor.physical_path,
intids_mapping=intids_mapping)
# Remove current responsible from predecessor and add issuer
# and responsible to successor's watcher.
center = notification_center()
center.remove_task_responsible(Oguid.parse(predecessor_oguid),
successor_forwarding.responsible)
center.add_task_responsible(successor_forwarding,
successor_forwarding.responsible)
center.add_task_issuer(successor_forwarding, successor_forwarding.issuer)
# if a dossier is given means that a successor task must
# be created in a new or a existing dossier
if dossier:
# we need all task field values from the forwarding
fielddata = {}
for fieldname in ITask.names():
value = ITask.get(fieldname).get(successor_forwarding)
fielddata[fieldname] = value
# Predefine the task_type to avoid tasks with an invalid task_type
fielddata['task_type'] = FORWARDING_SUCCESSOR_TYPE
# lets create a new task - the successor task
task = createContentInContainer(dossier, 'opengever.task.task',
**fielddata)
# copy documents and map the intids
intids_mapping = _copy_documents_from_forwarding(
successor_forwarding, task)
# copy the responses
response_transporter = IResponseTransporter(task)
response_transporter.get_responses(
get_current_admin_unit().id(),
'/'.join(successor_forwarding.getPhysicalPath()),
intids_mapping=intids_mapping)
# successor
successor_tc_task = ISuccessorTaskController(task)
transaction.savepoint()
# Close the predessecor forwarding
response_text = response_text or ''
request_data = {
'response_text': response_text.encode('utf-8'),
'successor_oguid': successor_tc.get_oguid(),
'transition': 'forwarding-transition-accept'
}
response = dispatch_request(predecessor.admin_unit_id,
'@@store_forwarding_in_yearfolder',
path=predecessor.physical_path,
data=request_data)
response_body = response.read()
if response_body.strip() != 'OK':
raise TaskRemoteRequestError(
'Adding the response and changing the workflow state on the '
'predecessor forwarding failed.')
if dossier:
# Update watchers for created successor forwarding and task
center = notification_center()
center.remove_task_responsible(successor_forwarding, task.responsible)
center.add_task_responsible(task, task.responsible)
# When a successor task exists, we close also the successor forwarding
change_task_workflow_state(
successor_forwarding,
'forwarding-transition-accept',
text=response_text,
successor_oguid=successor_tc_task.get_oguid())
# create the succssor relations
successor_tc.set_predecessor(predecessor_oguid)
if dossier:
successor_tc_task.set_predecessor(successor_tc.get_oguid())
return task
return successor_forwarding
def accept_forwarding_with_successor(context,
predecessor_oguid,
response_text,
dossier=None):
# the predessecor (the forwarding on the remote client)
predecessor = getUtility(ITaskQuery).get_task_by_oguid(predecessor_oguid)
# get the inbox
cat = getToolByName(context, 'portal_catalog')
inboxes = cat(portal_type="opengever.inbox.inbox")
if len(inboxes) == 0:
raise Unauthorized()
else:
inbox = inboxes[0].getObject()
# transport the remote forwarding to the inbox or actual yearfolder
transporter = getUtility(ITransporter)
if dossier:
yearfolder = _get_yearfolder(inbox, )
successor_forwarding = transporter.transport_from(
yearfolder, predecessor.client_id, predecessor.physical_path)
else:
successor_forwarding = transporter.transport_from(
inbox, predecessor.client_id, predecessor.physical_path)
# Replace the issuer with the current inbox
successor_forwarding.issuer = u'inbox:%s' % get_client_id()
# Set the "X-CREATING-SUCCESSOR" flag for preventing the event handler
# from creating additional responses per added document.
successor_forwarding.REQUEST.set('X-CREATING-SUCCESSOR', True)
successor_tc = ISuccessorTaskController(successor_forwarding)
# copy documents and map the intids
doc_transporter = getUtility(ITaskDocumentsTransporter)
with CustomInitialVersionMessage(
_(u'version_message_accept_forwarding',
default=u'Document copied from forwarding (forwarding accepted)'
), context.REQUEST):
intids_mapping = doc_transporter.copy_documents_from_remote_task(
predecessor, successor_forwarding)
# copy the responses
response_transporter = IResponseTransporter(successor_forwarding)
response_transporter.get_responses(predecessor.client_id,
predecessor.physical_path,
intids_mapping=intids_mapping)
# if a dossier is given means that a successor task must
# be created in a new or a existing dossier
if dossier:
# we need all task field values from the forwarding
fielddata = {}
for fieldname in ITask.names():
value = ITask.get(fieldname).get(successor_forwarding)
fielddata[fieldname] = value
# lets create a new task - the successor task
task = createContentInContainer(dossier, 'opengever.task.task',
**fielddata)
# copy documents and map the intids
intids_mapping = _copy_documents_from_forwarding(
successor_forwarding, task)
# copy the responses
response_transporter = IResponseTransporter(task)
response_transporter.get_responses(
get_client_id(),
'/'.join(successor_forwarding.getPhysicalPath()),
intids_mapping=intids_mapping)
# successor
successor_tc_task = ISuccessorTaskController(task)
transaction.savepoint()
# Close the predessecor forwarding
response_text = response_text or ''
request_data = {
'response_text': response_text.encode('utf-8'),
'successor_oguid': successor_tc.get_oguid(),
'transition': 'forwarding-transition-accept'
}
response = remote_request(predecessor.client_id,
'@@store_forwarding_in_yearfolder',
path=predecessor.physical_path,
data=request_data)
if response.read().strip() != 'OK':
raise Exception('Adding the response and changing the '
'workflow state on the predecessor forwarding '
'failed.')
if dossier:
# when a successor task exists, we close also the successor forwarding
change_task_workflow_state(
successor_forwarding,
'forwarding-transition-accept',
text=response_text,
successor_oguid=successor_tc_task.get_oguid())
# create the succssor relations
successor_tc.set_predecessor(predecessor_oguid)
if dossier:
successor_tc_task.set_predecessor(successor_tc.get_oguid())
return task
return successor_forwarding
def accept_forwarding_with_successor(
context, predecessor_oguid, response_text, dossier=None):
# the predessecor (the forwarding on the remote client)
predecessor = Task.query.by_oguid(predecessor_oguid)
# Set the "X-CREATING-SUCCESSOR" flag for preventing the event handler
# from creating additional responses per added document.
context.REQUEST.set('X-CREATING-SUCCESSOR', True)
# transport the remote forwarding to the inbox or actual yearfolder
transporter = Transporter()
inbox = get_current_inbox(context)
if dossier:
yearfolder = get_current_yearfolder(inbox=inbox)
successor_forwarding = transporter.transport_from(
yearfolder, predecessor.admin_unit_id, predecessor.physical_path)
else:
successor_forwarding = transporter.transport_from(
inbox, predecessor.admin_unit_id, predecessor.physical_path)
# Replace the issuer with the current inbox
successor_forwarding.issuer = get_current_org_unit().inbox().id()
successor_tc = ISuccessorTaskController(successor_forwarding)
# copy documents and map the intids
doc_transporter = getUtility(ITaskDocumentsTransporter)
comment = _(
u'version_message_accept_forwarding',
default=u'Document copied from forwarding (forwarding accepted)')
intids_mapping = doc_transporter.copy_documents_from_remote_task(
predecessor, successor_forwarding, comment=comment)
# copy the responses
response_transporter = IResponseTransporter(successor_forwarding)
response_transporter.get_responses(predecessor.admin_unit_id,
predecessor.physical_path,
intids_mapping=intids_mapping)
# Remove current responsible from predecessor and add issuer
# and responsible to successor's watcher.
center = notification_center()
center.remove_task_responsible(Oguid.parse(predecessor_oguid),
successor_forwarding.responsible)
center.add_task_responsible(successor_forwarding,
successor_forwarding.responsible)
center.add_task_issuer(successor_forwarding, successor_forwarding.issuer)
# if a dossier is given means that a successor task must
# be created in a new or a existing dossier
if dossier:
# we need all task field values from the forwarding
fielddata = {}
for fieldname in ITask.names():
value = ITask.get(fieldname).get(successor_forwarding)
fielddata[fieldname] = value
# Predefine the task_type to avoid tasks with an invalid task_type
fielddata['task_type'] = FORWARDING_SUCCESSOR_TYPE
# lets create a new task - the successor task
task = createContentInContainer(
dossier, 'opengever.task.task', **fielddata)
# copy documents and map the intids
intids_mapping = _copy_documents_from_forwarding(
successor_forwarding, task)
# copy the responses
response_transporter = IResponseTransporter(task)
response_transporter.get_responses(
get_current_admin_unit().id(),
'/'.join(successor_forwarding.getPhysicalPath()),
intids_mapping=intids_mapping)
# successor
successor_tc_task = ISuccessorTaskController(task)
transaction.savepoint()
# Close the predessecor forwarding
response_text = response_text or ''
request_data = {'response_text': response_text.encode('utf-8'),
'successor_oguid': successor_tc.get_oguid(),
'transition': 'forwarding-transition-accept'}
response = dispatch_request(predecessor.admin_unit_id,
'@@store_forwarding_in_yearfolder',
path=predecessor.physical_path,
data=request_data)
response_body = response.read()
if response_body.strip() != 'OK':
raise TaskRemoteRequestError(
'Adding the response and changing the workflow state on the '
'predecessor forwarding failed.')
if dossier:
# Update watchers for created successor forwarding and task
center = notification_center()
center.remove_task_responsible(successor_forwarding, task.responsible)
center.add_task_responsible(task, task.responsible)
# When a successor task exists, we close also the successor forwarding
change_task_workflow_state(
successor_forwarding,
'forwarding-transition-accept',
text=response_text,
successor_oguid=successor_tc_task.get_oguid())
# create the succssor relations
successor_tc.set_predecessor(predecessor_oguid)
if dossier:
successor_tc_task.set_predecessor(successor_tc.get_oguid())
return task
return successor_forwarding
