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>'