def __call__(self):
self.request.response.setHeader('Content-type', 'application/pdf')
self.request.response.setHeader(
'Content-disposition', 'inline;filename="' +
removeSecurityProxy(self.report.report_type) + "_" +
removeSecurityProxy(self.report.start_date).strftime('%Y-%m-%d') +
'.pdf"')
session = Session()
report = session.query(domain.Report).get(self.report.report_id)
d = dict([(f.file_title, f.file_data) for f in report.attached_files])
if "pdf" not in d.keys():
params = {}
params['body_text'] = self.cleanupText()
openofficepath = getUtility(IOpenOfficeConfig).getPath()
renderer = Renderer(self.odt_file,
params,
self.tempFileName,
pythonWithUnoPath=openofficepath)
renderer.run()
f = open(self.tempFileName, 'rb')
doc = f.read()
f.close()
os.remove(self.tempFileName)
attached_file = domain.AttachedFile()
attached_file.file_title = "pdf"
attached_file.file_data = doc
attached_file.language = report.language
report.attached_files.append(attached_file)
notify(ObjectCreatedEvent(attached_file))
session.add(report)
session.commit()
return doc
else:
return d["pdf"].__str__()
def handle_delete(self, action, data):
session = Session()
sitting = session.query(domain.GroupSitting).get(data["ids"])
session.delete(sitting)
session.commit()
self.request.response.setHeader('Content-type', 'text/xml')
return '<data><action type="deleted" sid="'+str(data["ids"])+'" tid="'+str(sitting.sitting_id)+'" /></data>'
def main(argv=None):
"""
run this as a cron job and execute all
time based transitions
"""
db = create_engine('postgres://localhost/bungeni', echo=False)
component.provideUtility( db, IDatabaseEngine, 'bungeni-db' )
model.metadata.bind = db
session = Session()
component.provideAdapter(
bungeni.core.workflows.states.WorkflowState,
(bungeni.core.interfaces.IBungeniContent,))
component.provideAdapter(
bungeni.core.workflows.question.QuestionWorkflowAdapter,
(domain.Question,))
component.provideAdapter(
ore.workflow.workflow.WorkflowInfo,
(domain.Question,))
component.provideHandler(
bungeni.core.workflows.question.workflowTransitionEventDispatcher)
# add autitor for time based transitions
#component.provideAdapter(
# (bungeni.core.interfaces.IAuditable, bungeni.core.interfaces.IQuestion, ),
# (domain.Question, ))
#component.provideAdapter( audit.objectModified,
#(domain.Question, bungeni.core.interfaces.IAuditable, ))
deferAdmissibleQuestions()
session.flush()
session.commit()
def main(argv=None):
"""
run this as a cron job and execute all
time based transitions
"""
db = create_engine('postgres://localhost/bungeni', echo=False)
component.provideUtility(db, IDatabaseEngine, 'bungeni-db')
model.metadata.bind = db
session = Session()
component.provideAdapter(bungeni.core.workflows.states.WorkflowState,
(bungeni.core.interfaces.IBungeniContent, ))
component.provideAdapter(
bungeni.core.workflows.question.QuestionWorkflowAdapter,
(domain.Question, ))
component.provideAdapter(ore.workflow.workflow.WorkflowInfo,
(domain.Question, ))
component.provideHandler(
bungeni.core.workflows.question.workflowTransitionEventDispatcher)
# add autitor for time based transitions
#component.provideAdapter(
# (bungeni.core.interfaces.IAuditable, bungeni.core.interfaces.IQuestion, ),
# (domain.Question, ))
#component.provideAdapter( audit.objectModified,
#(domain.Question, bungeni.core.interfaces.IAuditable, ))
deferAdmissibleQuestions()
session.flush()
session.commit()
def _updateAnnotation(self):
"""Updates an annotation."""
params = {}
params.update(self.request)
params.update(parse_qsl(self.request['QUERY_STRING']))
annotation = self.getAnnotation(params['id'])
if not annotation or annotation.quote_author != \
self.getAuthenticatedUser():
self.request.response.setStatus('BadRequest')
return
session = Session()
# if params.has_key('link'):
# if params['link'].startswith("http://"):
# annotation.hyper_link = params['link']
# params.pop('link')
# else:
# if annotation.hyper_link:
# annotation.hyper_link = ''
for key in annotations_table.c.keys():
value = params.get(key, None)
if not value:
continue
setattr(annotation, key, value)
session.commit()
self.request.response.setStatus('NoContent')
def __call__(self):
self.request.response.setHeader('Content-type', 'application/pdf')
self.request.response.setHeader('Content-disposition', 'inline;filename="'
+ removeSecurityProxy(self.report.report_type) + "_"
+ removeSecurityProxy(self.report.start_date).strftime('%Y-%m-%d') + '.pdf"')
session = Session()
report = session.query(domain.Report).get(self.report.report_id)
d = dict([(f.file_title, f.file_data) for f in report.attached_files])
if "pdf" not in d.keys():
params = {}
params['body_text'] = self.cleanupText()
openofficepath = getUtility(IOpenOfficeConfig).getPath()
renderer = Renderer(self.odt_file, params, self.tempFileName, pythonWithUnoPath=openofficepath)
renderer.run()
f = open(self.tempFileName, 'rb')
doc = f.read()
f.close()
os.remove(self.tempFileName)
attached_file = domain.AttachedFile()
attached_file.file_title = "pdf"
attached_file.file_data = doc
attached_file.language = report.language
report.attached_files.append(attached_file)
notify(ObjectCreatedEvent(attached_file))
session.add(report)
session.commit()
return doc
else:
return d["pdf"].__str__()
def _updateAnnotation(self):
"""Updates an annotation."""
params = {}
params.update(self.request)
params.update(parse_qsl(self.request['QUERY_STRING']))
annotation = self.getAnnotation(params['id'])
if not annotation or annotation.quote_author != \
self.getAuthenticatedUser():
self.request.response.setStatus('BadRequest')
return
session = Session()
# if params.has_key('link'):
# if params['link'].startswith("http://"):
# annotation.hyper_link = params['link']
# params.pop('link')
# else:
# if annotation.hyper_link:
# annotation.hyper_link = ''
for key in annotations_table.c.keys():
value = params.get(key, None)
if not value:
continue
setattr(annotation, key, value)
session.commit()
self.request.response.setStatus('NoContent')
def handle_insert(self, action, data):
session = Session()
sitting = domain.GroupSitting()
trusted = removeSecurityProxy(ISchedulingContext(self.context))
group = session.query(domain.Group).get(trusted.group_id)
if ("rec_type" not in data.keys()) or (data["rec_type"] == ""):
sitting.start_date = datetime.datetime.strptime(data["start_date"], '%Y-%m-%d %H:%M')
sitting.end_date = datetime.datetime.strptime(data["end_date"], '%Y-%m-%d %H:%M')
sitting.group_id = trusted.group_id
if "language" in data.keys():
sitting.language = data["language"]
if "venue" in data.keys():
sitting.venue_id = data["venue"]
session.add(sitting)
notify(ObjectCreatedEvent(sitting))
session.commit()
self.request.response.setHeader('Content-type', 'text/xml')
return '<data><action type="inserted" sid="'+str(data["ids"])+'" tid="'+str(sitting.sitting_id)+'" /></data>'
else:
try:
recurrence_start_date = datetime.datetime.strptime(data["start_date"], '%Y-%m-%d %H:%M')
recurrence_end_date = datetime.datetime.strptime(data["end_date"], '%Y-%m-%d %H:%M')
except:
print "Date is not in the correct format"
year = timedelta(days=365)
#max end date is one year from now or end_date of the group whichever is sooner
if (group is not None) and (group.end_date is not None):
if (datetime.datetime.now() + year) < group.end_date:
end = datetime.datetime.now() + year
else:
end = group.end_date
if recurrence_end_date > end:
recurrence_end_date = end
else:
if recurrence_end_date > (datetime.datetime.now() + year):
recurrence_end_date = datetime.datetime.now() + year
recurrence_type = data["rec_type"]
length = data["event_length"]
sitting_length = timedelta(seconds=int(length))
dates = self.generate_recurrence_dates(recurrence_start_date, recurrence_end_date, recurrence_type)
output = '<data>'
for date in dates:
sitting = domain.GroupSitting()
sitting.group_id = trusted.group_id
sitting.start_date = date
sitting.end_date = date + sitting_length
sitting.status = None
if "language" in data.keys():
sitting.language = data["language"]
if "venue" in data.keys():
sitting.venue_id = data["venue"]
session.add(sitting)
notify(ObjectCreatedEvent(sitting))
output = output+'<action type="inserted" sid="'+str(data["ids"])+'" tid="'+str(sitting.sitting_id)+'" />'
session.commit()
output = output + '</data>'
self.request.response.setHeader('Content-type', 'text/xml')
return output
def handle_add_save(self, action, data):
"""After succesful creation of translation, redirect to the
view."""
for key in data.keys():
if isinstance(data[key], str):
data[key] = unescape(data[key])
#url = url.absoluteURL(self.context, self.request)
#language = get_language_by_name(data["language"])["name"]
session = Session()
trusted = removeSecurityProxy(self.context)
mapper = rdb.orm.object_mapper(trusted)
pk = getattr(trusted, mapper.primary_key[0].name)
current_translation = get_translation_for(self.context, data["language"])
if current_translation:
for translation in current_translation:
session.delete(translation)
for form_field in data.keys():
if form_field == "language":
continue
translation = domain.ObjectTranslation()
translation.object_id = pk
translation.object_type = trusted.__class__.__name__
translation.field_name = form_field
translation.lang = data["language"]
translation.field_text = data[form_field]
session.add(translation)
session.flush()
session.commit()
session.close()
#versions = IVersioned(self.context)
#version = versions.create("'%s' translation added" % language)
# reset workflow state
#version.status = None
#IWorkflowInfo(version).fireTransition("create-translation")
# redefine form context and proceed with edit action
#self.setUpAdapters(version)
#handle_edit_action(self, action, data)
# commit version such that it gets a version id
#transaction.commit()
#if not self._next_url:
# self._next_url = ( \
# '%s/versions/%s' % (url, stringKey(version)) + \
# '?portal_status_message=Translation added')
self._finished_add = True
def handle_add_save(self, action, data):
"""After succesful creation of translation, redirect to the
view."""
for key in data.keys():
if isinstance(data[key], str):
data[key] = unescape(data[key])
#url = url.absoluteURL(self.context, self.request)
#language = get_language_by_name(data["language"])["name"]
session = Session()
trusted = removeSecurityProxy(self.context)
mapper = rdb.orm.object_mapper(trusted)
pk = getattr(trusted, mapper.primary_key[0].name)
current_translation = get_translation_for(self.context, data["language"])
if current_translation:
for translation in current_translation:
session.delete(translation)
for form_field in data.keys():
if form_field == "language":
continue
translation = domain.ObjectTranslation()
translation.object_id = pk
translation.object_type = trusted.__class__.__name__
translation.field_name = form_field
translation.lang = data["language"]
translation.field_text = data[form_field]
session.add(translation)
session.flush()
session.commit()
session.close()
#versions = IVersioned(self.context)
#version = versions.create("'%s' translation added" % language)
# reset workflow state
#version.status = None
#IWorkflowInfo(version).fireTransition("create-translation")
# redefine form context and proceed with edit action
#self.setUpAdapters(version)
#handle_edit_action(self, action, data)
# commit version such that it gets a version id
#transaction.commit()
#if not self._next_url:
# self._next_url = ( \
# '%s/versions/%s' % (url, stringKey(version)) + \
# '?portal_status_message=Translation added')
self._finished_add = True
def handle_generate_takes(self, action, data):
session = Session()
trusted = removeSecurityProxy(self.context)
takes = session.query(
domain.Take).filter(domain.Take.sitting_id == trusted.sitting_id)
for t in takes:
session.delete(t)
#import pdb; pdb.set_trace()
sitting = trusted
current_start_time = sitting.start_date
sitting_duration = sitting.end_date - sitting.start_date
take_duration = timedelta(minutes=int(data["duration"]))
assigned_reporters = get_assigned_staff(self.context, "Reporter")
assigned_readers = get_assigned_staff(self.context, "Reader")
assigned_editors = get_assigned_staff(self.context, "Editor")
c_reporter = 0
c_reader = 0
c_editor = 0
while sitting_duration > timedelta(minutes=0):
take = domain.Take()
take.sitting_id = sitting.sitting_id
if (sitting_duration - take_duration) > timedelta(minutes=0):
sitting_duration = sitting_duration - take_duration
take.start_date = current_start_time
take.end_date = take.start_date + take_duration
current_start_time = take.end_date
else:
take.start_date = current_start_time
take.end_date = take.start_date + sitting_duration
sitting_duration = timedelta(minutes=0)
if c_reporter > len(assigned_reporters) - 1:
c_reporter = 0
take.reporter_id = assigned_reporters[c_reporter]
else:
take.reporter_id = assigned_reporters[c_reporter]
c_reporter = c_reporter + 1
if c_reader > len(assigned_readers) - 1:
c_reader = 0
take.reader_id = assigned_readers[c_reader]
else:
take.reader_id = assigned_readers[c_reader]
c_reader = c_reader + 1
if c_editor > len(assigned_editors) - 1:
c_editor = 0
take.editor_id = assigned_editors[c_editor]
else:
take.editor_id = assigned_editors[c_editor]
c_editor = c_editor + 1
session.add(take)
session.commit()
self.request.response.redirect('./takes')
def _createAnnotation(self):
"""Create an annotation from the POST request."""
session = Session()
# TODO: do something useful with 'access'. Plone already
# enforces security based on ownership, so access is 'private'
# by default. 'public' access could mean sharing the annotation
# with the 'Anonymous' role, though a more restrictive
# implementation such as 'Member' or 'MemberOfParliament'
# probably makes more sense.
params = {
'url': '',
'block-range': '',
'xpath-range': '',
'note': '',
'access': '',
'action': '',
'quote': '',
'quote_title': '',
'quote_author': '',
'link': '',
}
# TODO: Don't treat query string and body parameters as equivalent.
# Query string parameters should identify the resources, while
# parameters in the body should specify the action to take.
params.update(self.request)
params.update(parse_qsl(self.request['QUERY_STRING']))
sequenceRange = SequenceRange(params['sequence-range'])
xpathRange = XPathRange(params['xpath-range'])
params['start_block'] = sequenceRange.start.getPaddedPathStr()
params['start_xpath'] = xpathRange.start.getPathStr()
params['start_word'] = xpathRange.start.words
params['start_char'] = xpathRange.start.chars
params['end_block'] = sequenceRange.end.getPaddedPathStr()
params['end_xpath'] = xpathRange.end.getPathStr()
params['end_word'] = xpathRange.end.words
params['end_char'] = xpathRange.end.chars
del params['sequence-range']
del params['xpath-range']
params['quote_author'] = self.getAuthenticatedUser()
annotation = AnnotationMaster()
for key in annotations_table.c.keys():
value = params.get(key, None)
if value == None:
continue
setattr(annotation, key, value)
session.save(annotation)
session.commit()
unique_id = str(annotation.id)
self.request.response.setStatus('Created')
self.request.response.setHeader('location', unique_id)
return unique_id
def _createAnnotation(self):
"""Create an annotation from the POST request."""
session = Session()
# TODO: do something useful with 'access'. Plone already
# enforces security based on ownership, so access is 'private'
# by default. 'public' access could mean sharing the annotation
# with the 'Anonymous' role, though a more restrictive
# implementation such as 'Member' or 'MemberOfParliament'
# probably makes more sense.
params = {
'url': '',
'block-range': '',
'xpath-range': '',
'note': '',
'access': '',
'action': '',
'quote': '',
'quote_title': '',
'quote_author': '',
'link': '',
}
# TODO: Don't treat query string and body parameters as equivalent.
# Query string parameters should identify the resources, while
# parameters in the body should specify the action to take.
params.update(self.request)
params.update(parse_qsl(self.request['QUERY_STRING']))
sequenceRange = SequenceRange(params['sequence-range'])
xpathRange = XPathRange(params['xpath-range'])
params['start_block'] = sequenceRange.start.getPaddedPathStr()
params['start_xpath'] = xpathRange.start.getPathStr()
params['start_word'] = xpathRange.start.words
params['start_char'] = xpathRange.start.chars
params['end_block'] = sequenceRange.end.getPaddedPathStr()
params['end_xpath'] = xpathRange.end.getPathStr()
params['end_word'] = xpathRange.end.words
params['end_char'] = xpathRange.end.chars
del params['sequence-range']
del params['xpath-range']
params['quote_author'] = self.getAuthenticatedUser()
annotation = AnnotationMaster()
for key in annotations_table.c.keys():
value = params.get(key, None)
if value == None:
continue
setattr(annotation, key, value)
session.save(annotation)
session.commit()
unique_id = str(annotation.id)
self.request.response.setStatus('Created')
self.request.response.setHeader('location', unique_id)
return unique_id
def handle_generate_takes(self, action, data):
session = Session()
trusted = removeSecurityProxy(self.context)
takes = session.query(domain.Take).filter(
domain.Take.sitting_id == trusted.sitting_id)
for t in takes:
session.delete(t)
#import pdb; pdb.set_trace()
sitting = trusted
current_start_time = sitting.start_date
sitting_duration = sitting.end_date - sitting.start_date
take_duration = timedelta(minutes=int(data["duration"]))
assigned_reporters = get_assigned_staff(self.context, "Reporter")
assigned_readers = get_assigned_staff(self.context, "Reader")
assigned_editors = get_assigned_staff(self.context, "Editor")
c_reporter = 0
c_reader = 0
c_editor = 0
while sitting_duration > timedelta(minutes=0):
take = domain.Take()
take.sitting_id = sitting.sitting_id
if (sitting_duration - take_duration) > timedelta(minutes=0):
sitting_duration = sitting_duration - take_duration
take.start_date = current_start_time
take.end_date = take.start_date + take_duration
current_start_time = take.end_date
else:
take.start_date = current_start_time
take.end_date = take.start_date + sitting_duration
sitting_duration = timedelta(minutes=0)
if c_reporter > len(assigned_reporters)-1:
c_reporter = 0
take.reporter_id = assigned_reporters[c_reporter]
else:
take.reporter_id = assigned_reporters[c_reporter]
c_reporter = c_reporter + 1
if c_reader > len(assigned_readers)-1:
c_reader = 0
take.reader_id = assigned_readers[c_reader]
else:
take.reader_id = assigned_readers[c_reader]
c_reader = c_reader + 1
if c_editor > len(assigned_editors)-1:
c_editor = 0
take.editor_id = assigned_editors[c_editor]
else:
take.editor_id = assigned_editors[c_editor]
c_editor = c_editor + 1
session.add(take)
session.commit()
self.request.response.redirect('./takes')
def handle_save(self, action, data):
session = Session()
transcript = domain.Transcript()
transcript.start_date = data['start_time']
transcript.end_date = data['end_time']
transcript.text = data['speech']
transcript.person = data['person']
transcript.sitting_id = self.context.sitting_id
session.add(transcript)
session.commit()
return 'Save'
def handle_save(self, action, data):
session = Session()
transcript = domain.Transcript()
transcript.start_date = data['start_time']
transcript.end_date = data['end_time']
transcript.text = data['speech']
transcript.person = data['person']
transcript.sitting_id = self.context.sitting_id
session.add(transcript)
session.commit()
return 'Save'
def __call__(self):
obj = self.request.form['obj[]']
'''container = self.context
schedulings = container.item_schedule
for s in schedulings:
print "s=>", s, s.planned_order
for order, id_number in enumerate(obj):
print "asdfasdf", order, id_number'''
session = Session()
for i in range(0,len(obj)):
sch = session.query(domain.ItemSchedule).get(obj[i])
setattr(sch, 'planned_order', i+1)
session.commit()
def handle_update(self, action, data):
session = Session()
sitting = domain.GroupSitting()
sitting = session.query(domain.GroupSitting).get(data["ids"])
sitting.start_date = data["start_date"]
sitting.end_date = data["end_date"]
if "language" in data.keys():
sitting.language = data["language"]
if "venue" in data.keys():
sitting.venue_id = data["venue"]
session.update(sitting)
session.commit()
self.request.response.setHeader('Content-type', 'text/xml')
return '<data><action type="updated" sid="'+str(data["ids"])+'" tid="'+str(sitting.sitting_id)+'" /></data>'
def __call__(self):
obj = self.request.form['obj[]']
'''container = self.context
schedulings = container.item_schedule
for s in schedulings:
print "s=>", s, s.planned_order
for order, id_number in enumerate(obj):
print "asdfasdf", order, id_number'''
session = Session()
for i in range(0, len(obj)):
sch = session.query(domain.ItemSchedule).get(obj[i])
setattr(sch, 'planned_order', i + 1)
session.commit()
def handle_save(self, action, data):
session = Session()
trusted = removeSecurityProxy(self.context)
sitting = session.query(domain.Sitting).get(trusted.sitting_id)
#import pdb; pdb.set_trace()
if sitting is None:
sitting = domain.Sitting()
sitting.sitting_id = trusted.sitting_id
sitting.media_path = data['media_path']
session.add(sitting)
else:
sitting.media_path = data['media_path']
session.commit()
#import pdb; pdb.set_trace()
self._next_url = absoluteURL(self.context, self.request)+"/transcripts"
self.request.response.redirect(self._next_url)
def handle_save(self, action, data):
report = domain.Report()
session = Session()
report.body_text = data['body_text']
report.start_date = data['start_date']
report.end_date = data['end_date']
report.note = data['note']
report.report_type = data['report_type']
report.short_name = data['report_type']
owner_id = get_db_user_id()
'''!+TODO(Miano, 18/08/2010) The admin user is currently not a db user
thus the line above returns None when the admin publishes a report.
to go around this if it returns None, just query the db for users
and set the owner id to be the first result'''
if owner_id is not None:
report.owner_id = owner_id
else:
query = session.query(domain.User)
results = query.all()
report.owner_id = results[0].user_id
report.language = "en"
report.created_date = datetime.datetime.now()
report.group_id = self.context.group_id
session.add(report)
notify(ObjectCreatedEvent(report))
if "sittings" in data.keys():
try:
ids = data["sittings"].split(",")
for id_number in ids:
sit_id = int(id_number)
sitting = session.query(domain.GroupSitting).get(sit_id)
sr = domain.SittingReport()
sr.report = report
sr.sitting = sitting
session.add(sr)
except:
#if no sittings are present in report or some other error occurs
pass
session.commit()
if IGroupSitting.providedBy(self.context):
back_link = './schedule'
elif ISchedulingContext.providedBy(self.context):
back_link = './'
else:
raise NotImplementedError
self.request.response.redirect(back_link)
def handle_save(self, action, data):
report = domain.Report()
session = Session()
report.body_text = data['body_text']
report.start_date = data['start_date']
report.end_date = data['end_date']
report.note = data['note']
report.report_type = data['report_type']
report.short_name = data['report_type']
owner_id = get_db_user_id()
'''!+TODO(Miano, 18/08/2010) The admin user is currently not a db user
thus the line above returns None when the admin publishes a report.
to go around this if it returns None, just query the db for users
and set the owner id to be the first result'''
if owner_id is not None:
report.owner_id = owner_id
else:
query = session.query(domain.User)
results = query.all()
report.owner_id = results[0].user_id
report.language = "en"
report.created_date = datetime.datetime.now()
report.group_id = self.context.group_id
session.add(report)
notify(ObjectCreatedEvent(report))
if "sittings" in data.keys():
try:
ids = data["sittings"].split(",")
for id_number in ids:
sit_id = int(id_number)
sitting = session.query(domain.GroupSitting).get(sit_id)
sr = domain.SittingReport()
sr.report = report
sr.sitting = sitting
session.add(sr)
except:
#if no sittings are present in report or some other error occurs
pass
session.commit()
if IGroupSitting.providedBy(self.context):
back_link = './schedule'
elif ISchedulingContext.providedBy(self.context):
back_link = './'
else:
raise NotImplementedError
self.request.response.redirect(back_link)
def handle_save(self, action, data):
session = Session()
trusted = removeSecurityProxy(self.context)
sitting = session.query(domain.Sitting).get(trusted.sitting_id)
#import pdb; pdb.set_trace()
if sitting is None:
sitting = domain.Sitting()
sitting.sitting_id = trusted.sitting_id
sitting.media_path = data['media_path']
session.add(sitting)
else:
sitting.media_path = data['media_path']
session.commit()
#import pdb; pdb.set_trace()
self._next_url = absoluteURL(self.context,
self.request) + "/transcripts"
self.request.response.redirect(self._next_url)
def handle_assignment(self, action, data):
session = Session()
session.query(domain.Assignment).filter(domain.Assignment.sitting_id == self.context.sitting_id).delete()
for editor_id in data["editors"]:
assignment = domain.Assignment()
assignment.sitting_id = self.context.sitting_id
assignment.staff_id = editor_id
session.add(assignment)
for reader_id in data["readers"]:
assignment = domain.Assignment()
assignment.sitting_id = self.context.sitting_id
assignment.staff_id = reader_id
session.add(assignment)
for reporter_id in data["reporters"]:
assignment = domain.Assignment()
assignment.sitting_id = self.context.sitting_id
assignment.staff_id = reporter_id
session.add(assignment)
session.commit()
self.request.response.redirect('./transcripts')
def handle_delete(self, action, data):
count = self.delete_subobjects()
container = self.context.__parent__
trusted = removeSecurityProxy(self.context)
session = Session()
session.delete(trusted)
count += 1
try:
session.commit()
except IntegrityError, e:
# this should not happen in production; it's a critical
# error, because the transaction might have failed in the
# second phase of the commit
session.rollback()
logging.critical(e)
self.status = _(u"Could not delete item due to "
"database integrity error")
return self.render()
def handle_delete(self, action, data):
count = self.delete_subobjects()
container = self.context.__parent__
trusted = removeSecurityProxy(self.context)
session = Session()
session.delete(trusted)
count += 1
try:
session.commit()
except IntegrityError, e:
# this should not happen in production; it's a critical
# error, because the transaction might have failed in the
# second phase of the commit
session.rollback()
logging.critical(e)
self.status = _(u"Could not delete item due to "
"database integrity error")
return self.render()
def handle_assignment(self, action, data):
session = Session()
session.query(domain.Assignment).filter(
domain.Assignment.sitting_id == self.context.sitting_id).delete()
for editor_id in data["editors"]:
assignment = domain.Assignment()
assignment.sitting_id = self.context.sitting_id
assignment.staff_id = editor_id
session.add(assignment)
for reader_id in data["readers"]:
assignment = domain.Assignment()
assignment.sitting_id = self.context.sitting_id
assignment.staff_id = reader_id
session.add(assignment)
for reporter_id in data["reporters"]:
assignment = domain.Assignment()
assignment.sitting_id = self.context.sitting_id
assignment.staff_id = reporter_id
session.add(assignment)
session.commit()
self.request.response.redirect('./transcripts')
def _updateAnnotation(self):
"""Updates an annotation."""
params = {}
params.update(self.request)
params.update(parse_qsl(self.request['QUERY_STRING']))
if self.request.environment.has_key('wsgi.input'):
params.update(parse_qsl(self.request.environment['wsgi.input'].read()))
params['modified'] = datetime.now()
annotation = self.getAnnotation(params['id'])
if not annotation:
self.request.response.setStatus('BadRequest')
return
if annotation.quote_authorid != self.getAuthenticatedUserId() and \
not self.isAdmin():
self.request.response.setStatus('BadRequest')
return
session = Session()
# if params.has_key('link'):
# if params['link'].startswith("http://"):
# annotation.hyper_link = params['link']
# params.pop('link')
# else:
# if annotation.hyper_link:
# annotation.hyper_link = ''
for key in annotations_table.c.keys():
value = params.get(key, None)
if not value:
continue
setattr(annotation, key, value)
session.commit()
self.request.response.setStatus('NoContent')
def __call__(self):
ids = self.request.form['ids']
action = self.request.form[ids + "_!nativeeditor_status"]
session = Session()
sitting = domain.GroupSitting()
trusted = removeSecurityProxy(self.context)
sitting.group_id = trusted.group_id
if action == "inserted":
sitting.start_date = self.request.form[ids + "_start_date"]
sitting.end_date = self.request.form[ids + "_end_date"]
sitting.sitting_type_id = self.request.form[ids + "_type"]
sitting.status = None
if ids + "_type" in self.request.form.keys():
sitting.sitting_type_id = self.request.form[ids + "_type"]
if ids + "_language" in self.request.form.keys():
sitting.language = self.request.form[ids + "_language"]
if ids + "_venue" in self.request.form.keys():
sitting.venue_id = self.request.form[ids + "_venue"]
session.add(sitting)
notify(ObjectCreatedEvent(sitting))
session.commit()
elif action == "updated":
sitting = session.query(domain.GroupSitting).get(ids)
sitting.start_date = self.request.form[ids + "_start_date"]
sitting.end_date = self.request.form[ids + "_end_date"]
if ids + "_type" in self.request.form.keys():
sitting.sitting_type_id = self.request.form[ids + "_type"]
if ids + "_language" in self.request.form.keys():
sitting.language = self.request.form[ids + "_language"]
if ids + "_venue" in self.request.form.keys():
sitting.venue_id = self.request.form[ids + "_venue"]
session.update(sitting)
session.commit()
elif action == "deleted":
sitting = session.query(domain.GroupSitting).get(ids)
session.delete(sitting)
session.commit()
self.request.response.setHeader('Content-type', 'text/xml')
return '<data><action type="' + action + '" sid="' + str(
ids) + '" tid="' + str(sitting.sitting_id) + '" /></data>'
