예제 #1
0
    def post(self, concept_id=None):
        if not concept_id and not Concept.valid_id(concept_id):
            raise HttpErrorException.bad_request('invalid concept id')

        concept = Concept.get_by_id(concept_id)
        if not concept:
            raise HttpErrorException.bad_request('invalid concept id')
        if not self.json_request.get('document_id') and not Document.valid_id(
                self.json_request.get('document_id')):
            raise HttpErrorException.bad_request('invalid document id')

        document = Document.get_by_id(self.json_request.get('document_id'))
        if not document:
            raise HttpErrorException.bad_request('invalid document  id')
        if not document.has_permission_set_crawlcontext(self.user):
            raise HttpErrorException.forbidden()

        if document.presentation_document is None:
            raise HttpErrorException.bad_request('document has not summary')

        presentation_document = document.presentation_document.get()
        if document.presentation_document is None:
            raise HttpErrorException.bad_request('document has not summary')

        project = document.project.get()
        if not isinstance(self.json_request.get('crawl'), bool):
            raise HttpErrorException.bad_request('invalid crawl')

        temp = self.json_request.get('temp', None)
        if temp is None:
            raise HttpErrorException.bad_request('no temp giving')

        crawlcontexts = ndb.get_multi(concept.presentation_crawlcontext)
        if temp:
            for crawl in crawlcontexts:
                if crawl.document == presentation_document.key:
                    concept.presentation_crawlcontext.remove(crawl.key)
                    concept.put()
                    crawl.key.delete()
                    break

        else:
            for crawl in crawlcontexts:
                if crawl.document == presentation_document.key:
                    crawl.crawl = self.json_request.get('crawl')
                    crawl.put()
                    break
            else:
                crawl = PresentationCrawlContext(
                    key=PresentationCrawlContext.create_key(),
                    project=project.key,
                    document=presentation_document.key,
                    crawl=self.json_request.get('crawl'))
                crawl.put()

                concept.presentation_crawlcontext.append(crawl.key)
                concept.put()

        project.pw_modified_ts = datetime.datetime.now()
        project.put()
예제 #2
0
    def delete(self, document_id=None):
        if not document_id and not Document.valid_id(document_id):
            raise HttpErrorException.bad_request('invalid document id')

        self.document = Document.get_by_id(document_id)
        if not self.document:
            raise HttpErrorException.bad_request('invalid document id')
        if not self.document.has_permission_write(self.user):
            raise HttpErrorException.forbidden()
        if self.document.is_distilled_document():
            raise HttpErrorException.bad_request(
                'can not delete distilled document')

        trans = Transaction(action='doc_del',
                            user=self.user.key,
                            artifact=self.document.key,
                            project=self.document.project)
        trans.put()

        self.get_channel_token()
        channel_tokens = ChannelToken.get_by_project_key(
            self.document.project, self.user_channel_token)
        channel_tokens = ChannelToken.remove_unauthorized_users(
            channel_tokens, [self.document])

        message = {
            'user': self.get_user_channel_data(),
            'transaction': trans.to_dict(self.user)
        }

        ChannelToken.broadcast_message(channel_tokens, message)

        self._delete_document()

        project = self.document.project.get()
        project.modified_ts = datetime.datetime.now()
        project.pw_modified_ts = datetime.datetime.now()
        project.put()
예제 #3
0
    def put(self, phrasing_id=None):
        self.get_analytic_session()

        phrasing_text = self.json_request.get('text')
        if not phrasing_text:
            raise HttpErrorException.bad_request('invalid phrasing text')
        if not self.json_request.get('concept') and not Concept.valid_id(
                self.json_request.get('concept')):
            raise HttpErrorException.bad_request('invalid concept id')

        concept = Concept.get_by_id(self.json_request.get('concept'))
        if not concept:
            raise HttpErrorException.bad_request('invalid concept id')
        if not self.json_request.get('document') and not Document.valid_id(
                self.json_request.get('document')):
            raise HttpErrorException.bad_request('invalid document id')

        document = Document.get_by_id(self.json_request.get('document'))
        if not document:
            raise HttpErrorException.bad_request('invalid document id')

        sum_doc = None
        if self.json_request.get('summary', False):
            if not document.summary_document:
                HttpErrorException.bad_request(
                    'no document does not have summary')
            sum_doc = document.summary_document.get()
            if not sum_doc:
                HttpErrorException.bad_request(
                    'no document does not have summary')

        pres_doc = None
        if self.json_request.get('presentation', False):
            if not document.presentation_document:
                HttpErrorException.bad_request(
                    'no document does not have presentation')
            pres_doc = document.presentation_document.get()
            if not pres_doc:
                HttpErrorException.bad_request(
                    'no document does not have presentation')

        phr_perm = Permission(permissions=Permission.init_perm_struct(
            Phrasing.operations_list),
                              key=Permission.create_key(),
                              project=document.project)

        phrasing = Phrasing(key=Phrasing.create_key(),
                            text=phrasing_text,
                            concept=concept.key,
                            owner=[self.user.key],
                            permissions=phr_perm.key,
                            project=document.project)

        phr_perm.artifact = phrasing.key
        concept.phrasings.append(phrasing.key)

        sel_phr = None
        if (document.is_distilled_document()
                and document.project == concept.project and sum_doc is None
                and pres_doc is None):
            concept.distilled_phrasing = phrasing.key
        else:
            if sum_doc is not None:
                if concept.has_summary_selected_phrasing(document=sum_doc):
                    sel_phr = concept.get_summary_selected_phrasing(sum_doc)
                    sel_phr.phrasing = phrasing.key
                else:
                    sel_phr = SummarySelectedPhrasing(
                        key=SummarySelectedPhrasing.create_key(),
                        project=concept.project,
                        document=sum_doc.key,
                        phrasing=phrasing.key)
                    concept.summary_selected_phrasings.append(sel_phr.key)

            elif pres_doc is not None:
                if concept.has_presentation_selected_phrasing(
                        document=pres_doc):
                    sel_phr = concept.get_presentation_selected_phrasing(
                        pres_doc)
                    sel_phr.phrasing = phrasing.key
                else:
                    sel_phr = PresentationSelectedPhrasing(
                        key=PresentationSelectedPhrasing.create_key(),
                        project=concept.project,
                        document=pres_doc.key,
                        phrasing=phrasing.key)
                    concept.presentation_selected_phrasings.append(sel_phr.key)

            else:
                if concept.has_selected_phrasing(document=document):
                    sel_phr = concept.get_selected_phrasing(document=document)
                    sel_phr.phrasing = phrasing.key
                else:
                    sel_phr = SelectedPhrasing(
                        key=SelectedPhrasing.create_key(),
                        document=document.key,
                        phrasing=phrasing.key,
                        project=document.project)
                    concept.selected_phrasings.append(sel_phr.key)
            sel_phr.put()

        phrasing.originating_document = document.key

        project = phrasing.project.get()
        project.pw_modified_ts = datetime.datetime.now()

        ndb.put_multi([phr_perm, phrasing, concept, project])

        index = self.user.get_put_index()
        phrasing.index(index, concept=concept)

        concept.record_analytic('con_phr_new', self.analytic_session)
        self.write_json_response({
            'phrasing':
            phrasing.to_dict(self.user),
            'selected_phrasing':
            sel_phr.to_dict() if sel_phr else None
        })

        action_data = {
            'concept': concept.key.id(),
            'document': document.key.id(),
            'phrasing': phrasing.to_dict(self.user)
        }

        trans = Transaction(action='phr_new',
                            user=self.user.key,
                            artifact=phrasing.key,
                            project=project.key,
                            action_data=action_data)
        trans.put()

        self.get_channel_token()
        channel_tokens = ChannelToken.get_by_project_key(
            project.key, self.user_channel_token)
        channel_tokens = ChannelToken.remove_unauthorized_users(
            channel_tokens, [concept, phrasing, document])
        message = {
            'user': self.get_user_channel_data(),
            'transaction': trans.to_dict(self.user)
        }
        ChannelToken.broadcast_message(channel_tokens, message)
예제 #4
0
    def post(self, document_id=None):
        self.get_channel_token()
        modify_ts = True

        if not document_id and not Document.valid_id(document_id):
            raise HttpErrorException.bad_request('invalid document id')

        self.document = Document.get_by_id(document_id)
        if not self.document:
            raise HttpErrorException.bad_request('invalid document id')

        self.project = self.document.project.get()
        if not self.document.has_permission_read(self.user):
            raise HttpErrorException.forbidden()

        if self.json_request.get('active_document'):
            modify_ts = False
            self._activate_document()
        else:
            if not self.document.has_permission_write(self.user):
                raise HttpErrorException.forbidden()
            if self.json_request.get('permission'):
                self._add_perm()

            values = {}
            values_changed = False
            if not self.json_request.get(
                    'permission') and self.json_request.get('group_id'):
                self._rm_perm()
            if self.json_request.get('remove_group'):
                self._remove_group()
            if self.json_request.get('title') is not None:
                self._set_title()
                values_changed = True
                values['title'] = self.json_request.get('title', '')
            if self.json_request.get('subtitle') is not None:
                self._set_subtitle()
                values_changed = True
                values['subtitle'] = self.json_request.get('subtitle', '')
            if self.json_request.get('author') is not None:
                self._set_author()
                values_changed = True
                values['author'] = self.json_request.get('author', '')
            if self.json_request.get('date') is not None:
                self._set_date()
                values_changed = True
                values['date'] = self.json_request.get('date', '')
            if self.json_request.get('version') is not None:
                self._set_version()
                values_changed = True
                values['version'] = self.json_request.get('version', '')
            if self.json_request.get('copyright') is not None:
                self._set_copyright()
                values_changed = True
                values['copyright'] = self.json_request.get('copyright', '')
            if self.json_request.get('description') is not None:
                self._set_description()
                values_changed = True
                values['description'] = self.json_request.get(
                    'description', '')

            if values_changed:
                action_data = {'values': values}

                trans = Transaction(action='doc_edit',
                                    user=self.user.key,
                                    artifact=self.document.key,
                                    project=self.document.project,
                                    action_data=action_data)
                trans.put()

                self.get_channel_token()
                channel_tokens = ChannelToken.get_by_project_key(
                    self.document.project, self.user_channel_token)
                channel_tokens = ChannelToken.remove_unauthorized_users(
                    channel_tokens, [self.document])

                message = {
                    'user': self.get_user_channel_data(),
                    'transaction': trans.to_dict(self.user)
                }

                ChannelToken.broadcast_message(channel_tokens, message)

        if modify_ts:
            project = self.document.project.get()
            project.pw_modified_ts = datetime.datetime.now()
            project.put()

        self.document.put()
예제 #5
0
    def post(self, concept_id=None):
        if not concept_id and not Concept.valid_id(concept_id):
            raise HttpErrorException.bad_request('invalid concept id')

        concept = Concept.get_by_id(concept_id)
        if not concept:
            raise HttpErrorException.bad_request('invalid concept id')
        if not self.json_request.get('document_id') and not Document.valid_id(
                self.json_request.get('document_id')):
            raise HttpErrorException.bad_request('invalid document id')

        document = Document.get_by_id(self.json_request.get('document_id'))
        if not document:
            raise HttpErrorException.bad_request('invalid document  id')
        if not document.has_permission_set_crawlcontext(self.user):
            raise HttpErrorException.forbidden()

        project = document.project.get()
        if not isinstance(self.json_request.get('crawl'), bool):
            raise HttpErrorException.bad_request('invalid crawl')

        crawlcontexts = ndb.get_multi(concept.crawlcontext)
        for crawl in crawlcontexts:
            if crawl.document == document.key:
                crawl.crawl = self.json_request.get('crawl')
                crawl.put()
                crawlcontext = crawl
                break
        else:
            crawl = CrawlContext(key=CrawlContext.create_key(),
                                 project=project.key,
                                 document=document.key,
                                 crawl=self.json_request.get('crawl'))
            crawl.put()
            concept.crawlcontext.append(crawl.key)
            concept.put()
            crawlcontext = crawl

        project.pw_modified_ts = datetime.datetime.now()
        project.put()

        self.get_analytic_session()
        if crawl.crawl:
            concept.record_analytic('con_cc_t', self.analytic_session)
        else:
            concept.record_analytic('con_cc_f', self.analytic_session)

        action = 'con_hid'
        if self.json_request.get('crawl'):
            action = 'con_shw'

        action_data = {
            'concept': concept.key.id(),
            'document': document.key.id()
        }

        trans = Transaction(action=action,
                            user=self.user.key,
                            artifact=crawlcontext.key,
                            project=project.key,
                            document=document,
                            action_data=action_data)
        trans.put()

        self.get_channel_token()
        channel_tokens = ChannelToken.get_by_project_key(
            project.key, self.user_channel_token)
        channel_tokens = ChannelToken.remove_unauthorized_users(
            channel_tokens, [concept, document])
        message = {
            'user': self.get_user_channel_data(),
            'transaction': trans.to_dict(self.user)
        }
        ChannelToken.broadcast_message(channel_tokens, message)
예제 #6
0
    def _add_attribute(self):
        r_attr = self.json_request.get('add_attribute')
        if not r_attr:
            raise ValueError('no attribute given')
        if not isinstance(r_attr, basestring):
            raise ValueError('attributes must be a string')

        if not self.json_request.get('document'):
            raise ValueError('no document id given')
        if not Document.valid_id(self.json_request.get('document')):
            raise HttpErrorException.bad_request('invalid document id')

        doc = Document.get_by_id(self.json_request.get('document'))
        if not doc.has_permission_write(self.user):
            raise HttpErrorException.forbidden()
        if not doc:
            raise ValueError('invalid document id given')

        attr = self.project.get_attr(doc.key)
        if attr:
            if r_attr == 'h' and 'noh' in attr.attributes:
                attr.attributes.remove('noh')
            if r_attr == 'noh' and 'h' in attr.attributes:
                attr.attributes.remove('h')
            if r_attr == 'ol' and 'nol' in attr.attributes:
                attr.attributes.remove('nol')
            if r_attr == 'ol' and 'ul' in attr.attributes:
                attr.attributes.remove('ul')
            if r_attr == 'ul' and 'nol' in attr.attributes:
                attr.attributes.remove('nol')
            if r_attr == 'il' and 'ol' in attr.attributes:
                attr.attributes.remove('ol')
            if r_attr == 'nol' and 'ol' in attr.attributes:
                attr.attributes.remove('ol')
            if r_attr == 'nol' and 'ul' in attr.attributes:
                attr.attributes.remove('ul')

            if r_attr not in attr.attributes:
                attr.attributes.append(r_attr)
            attr.put()
        else:
            attr = [r_attr] if r_attr != 'attr' else []
            attr = Attributes(project=self.project.project,
                              document=doc.key,
                              attributes=attr)
            attr.put()
            self.project.attributes.append(attr.key)

        action_data = {'attribute': r_attr, 'document': doc.key.id()}

        trans = Transaction(action='pro_attr_add',
                            user=self.user.key,
                            artifact=self.project.key,
                            project=self.project.key,
                            action_data=action_data)
        trans.put()

        channel_tokens = ChannelToken.get_by_project_key(
            self.project.key, self.user_channel_token)
        channel_tokens = ChannelToken.remove_unauthorized_users(
            channel_tokens, [self.project, doc])
        message = {
            'user': self.get_user_channel_data(),
            'transaction': trans.to_dict(self.user)
        }
        ChannelToken.broadcast_message(channel_tokens, message)