Beispiel #1
0
    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__()
Beispiel #2
0
 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')
Beispiel #6
0
 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__()
Beispiel #7
0
    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')
Beispiel #8
0
 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
Beispiel #9
0
    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
Beispiel #10
0
    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
Beispiel #11
0
    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')
Beispiel #12
0
    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
Beispiel #14
0
 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')
Beispiel #15
0
 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'
Beispiel #16
0
 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'
Beispiel #17
0
 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()
Beispiel #18
0
 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>'
Beispiel #19
0
 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()
Beispiel #20
0
 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)
Beispiel #21
0
    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)
Beispiel #22
0
    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)
Beispiel #23
0
 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)
Beispiel #24
0
 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')    
Beispiel #25
0
    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()
Beispiel #26
0
    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()
Beispiel #27
0
 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')
Beispiel #28
0
    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')
Beispiel #29
0
 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>'