Exemple #1
0
 def __setitem__(self,
                 name: str,
                 principal: Union[Principal, dict]) -> None:
     name = name
     if isinstance(principal, dict):
         principal = self.factory(**principal)
     DBSession.add(principal)
Exemple #2
0
def view_review(context, request):  
    jquery.need()    
    contextbody = jinja2.Markup(context.body)

    user = get_user(request)  

    if request.POST :
    
        if user is None:
            request.session.flash(u"请先登陆..","info")
            came_from = request.url
            return HTTPFound("/login?came_from=%s" % came_from)        
        
        if 'submit' in request.POST:

            
            comment_content = request.params.get("review-comment-input")
            
            comment = Comment()
            comment.type = comment.TYPE_MEETUP_REVIEW
            comment.user_id = user.id
            comment.document_id = context.id 
            
            # ACTION!!!: There is a SQL injection risk here! should be prevented
            comment.content =  comment_content
            DBSession.add( comment)
            DBSession.flush()
            

        
    return  wrap_user2(request, 
                {'context':context, 
                'contextbody': contextbody,
                'comments_count': len(context.comments)                
                })       
Exemple #3
0
 def test_unique_constraint(self):
     # Try to add two children with the same name to the root node:
     session = DBSession()
     root = get_root()
     session.add(Node(name=u'child1', parent=root))
     session.add(Node(name=u'child1', parent=root))
     self.assertRaises(IntegrityError, session.flush)
Exemple #4
0
    def create(self, content, filename=None, content_type=None):
        """Saves a new file and returns the file id

        :param content: can either be ``bytes``, another ``file object``
                        or a :class:`cgi.FieldStorage`. When ``filename`` and
                        ``content_type``  parameters are not provided they are
                        deducted from the content itself.

        :param filename: filename for this file
        :type filename: string

        :param content_type: Mimetype of this file
        :type content_type: string

        :return: the unique ``file_id`` associated to this file
        :rtype: string
        """
        new_file_id = str(uuid.uuid1())
        content, filename, content_type = self.fileinfo(
            content, filename, content_type)
        if hasattr(content, 'read'):
            content = content.read()

        fstore = DBStoredFile(data=content,
                              file_id=new_file_id,
                              filename=filename,
                              content_type=content_type,
                              )
        DBSession.add(fstore)
        return new_file_id
Exemple #5
0
def test_resume2():
    stu = DBSession.query(MbaUser).filter_by(email='*****@*****.**').first()
    resume1 = Resume(title=u'resume1', user=stu)
    start_date = datetime.strptime('2003-1-1','%Y-%m-%d').date()
    finish_date = datetime.strptime('2008-1-1','%Y-%m-%d').date()
    edu = Education(
            school_name = u'电子科技大学',
            start_date=start_date,
            finish_date=finish_date,
            major=u'通信工程',
            degree = 1)
    resume1.educations.append(edu)

    job = Job(
            industy = u'美丽的台湾公司',
            industy_type = 1,
            industy_scale = 1,
            duty = u'软件工程师',
            start_date = start_date,
            finish_date = finish_date,
            )
    resume1.jobs.append(job)

    DBSession.add(resume1)
    DBSession.flush()
Exemple #6
0
    def save_success(self, appstruct):
        appstruct.pop('csrf_token', None)
        DBSession.add( self.add(**appstruct) )

        self.request.session.flash(self.success_message, 'success')
        location = self.success_url
        return HTTPFound(location=location)
Exemple #7
0
    def create(
        self,
        content: Union[bytes, FieldStorage],
        filename: Optional[str] = None,
        content_type: Optional[str] = None,
    ) -> str:
        """Saves a new file and returns the file id

        :param content: can either be ``bytes``, another ``file object``
                        or a :class:`cgi.FieldStorage`. When ``filename`` and
                        ``content_type``  parameters are not provided they are
                        deducted from the content itself.

        :param filename: filename for this file
        :type filename: string

        :param content_type: Mimetype of this file
        :type content_type: string

        :return: the unique ``file_id`` associated to this file
        :rtype: string
        """
        new_file_id = str(uuid.uuid1())
        content, filename, content_type = self.fileinfo(content, filename, content_type)
        if hasattr(content, "read"):
            content = content.read()

        fstore = DBStoredFile(
            data=content,
            file_id=new_file_id,
            filename=filename,
            content_type=content_type,
        )
        DBSession.add(fstore)
        return new_file_id
    def create_fruit_category(self, request):
        data = ast.literal_eval(request.body)
        # Assume only one fruit_categories folder.
        fruit_categories_folder = \
                DBSession.query(FruitCategoriesFolder).first()
        name = str(uuid.uuid4())
        fruit_category = FruitCategory(name=name,
                                       title=data['title'],
                                       parent=fruit_categories_folder)
        fruit_category.__acl__ = SITE_ACL
        session = DBSession()
        session.add(fruit_category)

        workflow = get_workflow(fruit_category)
        if workflow:
            session.flush()
            workflow.transition_to_state(fruit_category, None, u'public')
        else:
            print '################ NO WORKFLOW for ', fruit_category.title

        session.flush()
        transaction.commit()

        fruit_category = \
                DBSession.query(FruitCategory).filter_by(name=name).first()

        return {u'id': fruit_category.id,
                u'title': fruit_category.title}
    def create_fruit(self, request):
        data = ast.literal_eval(request.body)
        fruit_category = \
                DBSession.query(FruitCategory).filter_by(
                        id=data['fruit_category']).first()
        name = str(uuid.uuid4())

        fruit = Fruit(parent=fruit_category)
        fruit.__acl__ = SITE_ACL
        session = DBSession()
        session.add(fruit)

        workflow = get_workflow(fruit)
        if workflow:
            session.flush()
            workflow.transition_to_state(fruit, None, u'public')
        else:
            print '################ NO WORKFLOW for ', fruit.title

        session.flush()
        transaction.commit()

        fruit = DBSession.query(Fruit).filter_by(name=name).first()

        return {u'id': fruit.id,
                u'title': fruit.title,
                u'fruit_category': fruit.__parent__.id}
Exemple #10
0
 def test_persistent_settings_add_new(self):
     from kotti.resources import Settings
     session = DBSession()
     [settings] = session.query(Settings).all()
     data = {'foo.bar': u'spam', 'kotti.db_version': u'next'}
     new_settings = settings.copy(data)
     session.add(new_settings)
     self.assertEqual(get_settings()['foo.bar'], u'spam')
     self.assertEqual(get_settings()['kotti.db_version'], u'next')
Exemple #11
0
    def test_unique_constraint(self):
        from kotti import DBSession
        from kotti.resources import get_root
        from kotti.resources import Node

        # Try to add two children with the same name to the root node:
        root = get_root()
        DBSession.add(Node(name=u'child1', parent=root))
        DBSession.add(Node(name=u'child1', parent=root))
        self.assertRaises(IntegrityError, DBSession.flush)
 def __setitem__(self, key, value):
     """See zope.annotation.interfaces.IAnnotations"""
     # import pdb; pdb.set_trace()
     if not isinstance(key, string_types):
         raise TypeError("Only string key is supported")
     if not key in self.obj._annotations:
         anno = Annotation(self.obj.id, key, value)
         self.obj._annotations[key] = anno
         DBSession.add(anno)
     else:
         self.obj._annotations[key].value = value
Exemple #13
0
    def test_persistent_settings_add_new(self):
        from kotti import DBSession
        from kotti import get_settings
        from kotti.resources import Settings

        [settings] = DBSession.query(Settings).all()
        data = {'foo.bar': u'spam', 'kotti.db_version': u'next'}
        new_settings = settings.copy(data)
        DBSession.add(new_settings)
        self.assertEqual(get_settings()['foo.bar'], u'spam')
        self.assertEqual(get_settings()['kotti.db_version'], u'next')
Exemple #14
0
def set_groups(name, context, groups_to_set=()):
    """Set the list of groups for principal with given ``name`` and in
    given ``context``.
    """
    name = unicode(name)
    from kotti.resources import LocalGroup
    DBSession.query(LocalGroup).filter(
        LocalGroup.node_id == context.id).filter(
            LocalGroup.principal_name == name).delete()

    for group_name in groups_to_set:
        DBSession.add(LocalGroup(context, name, unicode(group_name)))
Exemple #15
0
def create_columns_from_dbf(data, context):
    tmp = tempfile.NamedTemporaryFile(suffix='.dbf')
    tmp.file.write(data)
    tmp.file.flush()
    dbt = dbf.Table(tmp.name)
    for fieldname in dbt.field_names:
        fieldinfo = dbt.field_info(fieldname)
        column_type = None
        column_lenght = 0
        if fieldinfo[0] in ['N', 'F', 'B', 'Y']:
            column_type = 'Float'
            if fieldinfo[2] == 0:
                column_type = 'Integer'
        elif fieldinfo[0] in [
                'I',
        ]:
            column_type = 'Integer'
        elif fieldinfo[0] in ['C']:
            column_type = 'String'
            column_lenght = fieldinfo[1]
        elif fieldinfo[0] in ['D']:
            column_type = 'Date'
        elif fieldinfo[0] in ['T']:
            column_type = 'DateTime'
        elif fieldinfo[0] in ['L']:
            column_type = 'Boolean'
        elif fieldinfo[0] in ['P']:
            logger.warn('Picture type not suppported')
        if column_type:
            name = title_to_name(fieldname, blacklist=context.keys())
            if fieldname.endswith('_'):
                destname = fieldname[:-1]
            else:
                destname = fieldname
            if len(destname) < 2:
                destname = destname + '0'
            column = RDBTableColumn(parent=context,
                                    name=name,
                                    title=fieldname,
                                    src_column_name=fieldname,
                                    dest_column_name=destname,
                                    column_type=column_type,
                                    column_lenght=column_lenght,
                                    is_pk=False)
            DBSession.add(column)
        else:
            raise TypeError(u'Unsupported type %s' % fieldinfo[0])
    dbt.close()
    tmp.close()
Exemple #16
0
    def test_node_copy_with_local_groups(self):
        from kotti import DBSession
        from kotti.resources import get_root
        from kotti.resources import Node
        from kotti.resources import LocalGroup

        root = get_root()
        child1 = root['child1'] = Node()
        local_group1 = LocalGroup(child1, u'joe', u'role:admin')
        DBSession.add(local_group1)
        DBSession.flush()

        child2 = root['child2'] = child1.copy()
        DBSession.flush()
        assert child2.local_groups == []
Exemple #17
0
    def test_container_methods(self):
        from kotti import DBSession
        from kotti.resources import get_root
        from kotti.resources import Node

        # Test some of Node's container methods:
        root = get_root()
        self.assertEquals(root.keys(), [])

        child1 = Node(name=u'child1', parent=root)
        DBSession.add(child1)
        self.assertEquals(root.keys(), [u'child1'])
        self.assertEquals(root[u'child1'], child1)

        del root[u'child1']
        self.assertEquals(root.keys(), [])

        # When we delete a parent node, all its child nodes will be
        # released as well:
        root[u'child2'] = Node()
        root[u'child2'][u'subchild'] = Node()
        self.assertEquals(
            DBSession.query(Node).filter(Node.name == u'subchild').count(), 1)
        del root[u'child2']
        self.assertEquals(
            DBSession.query(Node).filter(Node.name == u'subchild').count(), 0)

        # We can pass a tuple as the key to more efficiently reach
        # down to child objects:
        root[u'child3'] = Node()
        subchild33 = Node(name=u'subchild33', parent=root[u'child3'])
        DBSession.add(subchild33)
        del root.__dict__['_children']  # force a different code path
        self.assertTrue(
            root[u'child3', u'subchild33'] is root[u'child3'][u'subchild33'])
        self.assertTrue(
            root[(u'child3', u'subchild33')] is subchild33)
        self.assertTrue(
            root[(u'child3', u'subchild33')] is subchild33)
        self.assertRaises(KeyError, root.__getitem__, (u'child3', u'bad-name'))
        root.children  # force a different code path
        self.assertRaises(KeyError, root.__getitem__, (u'child3', u'bad-name'))
        del root[u'child3']

        # Overwriting an existing Node is an error; first delete manually!
        child4 = Node(name=u'child4', parent=root)
        DBSession.add(child4)
        self.assertEquals(root.keys(), [u'child4'])

        child44 = Node(name=u'child4')
        DBSession.add(child44)
        root[u'child4'] = child44
        self.assertRaises(SQLAlchemyError, DBSession.flush)
Exemple #18
0
    def test_container_methods(self, db_session):
        from kotti import DBSession
        from kotti.resources import get_root
        from kotti.resources import Node

        # Test some of Node's container methods:
        root = get_root()
        assert root.keys() == []

        child1 = Node(name=u'child1', parent=root)
        DBSession.add(child1)
        assert root.keys() == [u'child1']
        assert root[u'child1'] == child1

        del root[u'child1']
        assert root.keys() == []

        # When we delete a parent node, all its child nodes will be
        # released as well:
        root[u'child2'] = Node()
        root[u'child2'][u'subchild'] = Node()
        assert (DBSession.query(Node).filter(
            Node.name == u'subchild').count() == 1)
        del root[u'child2']
        assert (DBSession.query(Node).filter(
            Node.name == u'subchild').count() == 0)

        # We can pass a tuple as the key to more efficiently reach
        # down to child objects:
        root[u'child3'] = Node()
        subchild33 = Node(name=u'subchild33', parent=root[u'child3'])
        DBSession.add(subchild33)
        del root.__dict__['_children']  # force a different code path
        assert root[u'child3', u'subchild33'] is root[u'child3'][u'subchild33']
        assert root[(u'child3', u'subchild33')] is subchild33
        assert root[(u'child3', u'subchild33')] is subchild33
        with raises(KeyError):
            root[u'child3', u'bad-name']
        root.children  # force a different code path
        with raises(KeyError):
            root[u'child3', u'bad-name']
        del root[u'child3']

        # Overwriting an existing Node is an error; first delete manually!
        child4 = Node(name=u'child4', parent=root)
        DBSession.add(child4)
        assert root.keys() == [u'child4']

        child44 = Node(name=u'child4')
        DBSession.add(child44)
        root[u'child4'] = child44
        with raises(SQLAlchemyError):
            DBSession.flush()
Exemple #19
0
    def save_answers(self, request, questions, answers, username=None):
        browser_data = {
            "host": request.host,
            "client_ip": request.client_addr,
            "user_agent": request.user_agent,
        }

        if self.collect_user_info:
            if not username and not request.user:
                request.session.flash(
                    _("Please login or provide your username to continue."),
                    "warning")
                return False
            survey = UserSurvey.query.filter(
                UserSurvey.survey_id == self.id,
                UserSurvey.username == (username
                                        or request.user.name)).first()
            if survey:
                request.session.flash(_("You have already done this survey."),
                                      "warning")
                return False
            survey = UserSurvey(
                browser_data=browser_data,
                survey_id=self.id,
                id=uuid_factory(),
                username=(username or request.user.name),
            )
        else:
            survey = UserSurvey(browser_data=browser_data,
                                survey_id=self.id,
                                id=uuid_factory())
        if survey.save_answers(questions, answers):
            DBSession.add(survey)
            request.session.flash(
                _(u'Thank you for completing ${title}.',
                  mapping=dict(title=self.title)), 'success')
            return survey
        else:
            request.session.flash(
                _((u'Something went wrong, pleace check'
                   ' if all required fields are field out.')), 'danger')
            return False
Exemple #20
0
def populate():
    """
    Create the root node (:class:`~kotti.resources.Document`) and the 'about'
    subnode in the nodes tree if there are no nodes yet.
    """
    lrm = LocalizerRequestMixin()
    lrm.registry = get_current_registry()
    lrm.locale_name = get_settings()['pyramid.default_locale_name']
    localizer = lrm.localizer

    if DBSession.query(Node.id).count() == 0:
        localized_root_attrs = dict([(k, localizer.translate(v))
                                     for k, v in _ROOT_ATTRS.iteritems()])
        root = Document(**localized_root_attrs)
        root.__acl__ = SITE_ACL
        DBSession.add(root)
        localized_about_attrs = dict([(k, localizer.translate(v))
                                      for k, v in _ABOUT_ATTRS.iteritems()])
        root['about'] = Document(**localized_about_attrs)
        DBSession.flush()

    populate_users()
Exemple #21
0
def extract_from_archive(data, context):
    tmp = tempfile.NamedTemporaryFile()
    tmp.file.write(data)
    tmp.file.flush()
    if tarfile.is_tarfile(tmp.name):
        tmptf = tarfile.open(tmp.name)
        for ti in tmptf.getmembers():
            if ti.isfile() and ti.size > 0:
                tf = tmptf.extractfile(ti)
                import ipdb
                ipdb.set_trace()
                tf.close()
        tmptf.close()
    elif zipfile.is_zipfile(tmp.name):
        tmpzip = zipfile.ZipFile(tmp.file)
        extensions = []
        for zi in tmpzip.infolist():
            tz = tmpzip.open(zi)
            extensions.append(zi.filename[-4:])
            #mimetypes.guess_type(filename, strict=False)
            if zi.filename.endswith('.dbf'):
                create_columns_from_dbf(tz.read(), context)
            tz.close()
        if (('.dbf' in extensions) and ('.shp' in extensions)
                and ('.shx' in extensions)):
            if SPATIAL:
                nfo = extract_geometry_info(data)
                column = RDBTableColumn(
                    parent=context,
                    name='geometry',
                    title='Geometry',
                    src_column_name=None,
                    dest_column_name=nfo['name'],
                    column_type=nfo['geometry'],
                    column_lenght=2,  #XXX dimensions 2 or 3
                    is_pk=False)
                DBSession.add(column)
        tmpzip.close()
    tmp.close()
Exemple #22
0
 def __setitem__(self, name, principal):
     name = unicode(name)
     if isinstance(principal, dict):
         principal = self.factory(**principal)
     DBSession.add(principal)
Exemple #23
0
 def __setitem__(self, name: str, principal: Union[Principal, dict]) -> None:
     name = name
     if isinstance(principal, dict):
         principal = self.factory(**principal)
     DBSession.add(principal)