Пример #1
0
    def test_container_simple_move(self):
        container = Container(__name__ = 'container', __path__ = '/container/')
        content = Content(title='Content')

        ptah.cms.Session.add(container)
        ptah.cms.Session.add(content)
        ptah.cms.Session.flush()

        container['content'] = content

        content_uri = content.__uri__
        container_uri = container.__uri__
        transaction.commit()

        container = ptah.resolve(container_uri)
        content = ptah.resolve(content_uri)

        container['moved'] = content

        self.assertEqual(content.__name__, 'moved')
        self.assertEqual(content.__path__, '/container/moved/')
        self.assertEqual(content.__parent__, container)
        self.assertEqual(content.__parent_uri__, container.__uri__)
        transaction.commit()

        container = ptah.resolve(container_uri)
        self.assertEqual(container.keys(), ['moved'])
        self.assertEqual(container['moved'].__uri__, content_uri)
Пример #2
0
    def test_container_delete(self):
        container = Container(__name__ = 'container', __path__ = '/container/')
        content = Content(title='Content')

        ptah.cms.Session.add(container)
        ptah.cms.Session.add(content)
        ptah.cms.Session.flush()

        container['content'] = content

        content_uri = content.__uri__
        container_uri = container.__uri__
        transaction.commit()

        container = ptah.resolve(container_uri)
        del container['content']
        self.assertEqual(container.keys(), [])
        self.assertEqual(container.values(), [])

        transaction.commit()

        self.assertTrue(ptah.resolve(content_uri) is None)

        container = ptah.resolve(container_uri)
        self.assertEqual(container.keys(), [])
        self.assertRaises(KeyError, container.__delitem__, 'content')
        self.assertRaises(KeyError, container.__delitem__, Content())
Пример #3
0
def generateThumbnail(theme, width=210):
    blob = ptah.resolve(theme.preview)
    if not blob:
        return

    data = StringIO(blob.read())
    image = PIL.Image.open(data)

    if image.mode == '1':
        image = image.convert('L')
    elif image.mode == 'P':
        image = image.convert('RGBA')

    # get width, height
    orig_size = image.size

    scale = float(width)/orig_size[0]
    height = int(round(orig_size[1] * scale))

    #convert image
    pilfilter = PIL.Image.NEAREST
    pilfilter = PIL.Image.ANTIALIAS

    image.thumbnail((width, height), pilfilter)

    newfile = StringIO()
    image.save(newfile, 'jpeg', quality=88)

    blob = ptah.resolve(theme.thumbnail)
    if blob is None:
        blob = ptah.cms.blob_storage.create(theme)
        theme.thumbnail = blob.__uri__

    blob.write(newfile.getvalue())
    blob.updateMetadata(mimetype = 'image/jpeg')
Пример #4
0
    def test_container_getitem(self):
        container = Container(__name__="container", __path__="/container/")
        content1 = Content(title="Content1")
        content2 = Content(title="Content2")

        container["content1"] = content1
        container["content2"] = content2

        self.assertEqual(container["content1"].__uri__, content1.__uri__)
        self.assertEqual(container["content2"].__uri__, content2.__uri__)
        self.assertEqual(container.get("content1").__uri__, content1.__uri__)
        self.assertEqual(container.get("content2").__uri__, content2.__uri__)

        ptah.cms.Session.add(container)
        ptah.cms.Session.add(content1)
        ptah.cms.Session.add(content2)
        ptah.cms.Session.flush()

        c_u = container.__uri__
        c1_u = content1.__uri__
        c2_u = content2.__uri__
        transaction.commit()

        container = ptah.resolve(c_u)
        self.assertEqual(container["content1"].__uri__, c1_u)
        self.assertEqual(container["content2"].__uri__, c2_u)
        transaction.commit()

        container = ptah.resolve(c_u)
        self.assertEqual(container.get("content1").__uri__, c1_u)
        self.assertEqual(container.get("content2").__uri__, c2_u)
Пример #5
0
    def test_container_insert_subtree(self):
        container = Container(__name__="container", __path__="/container/")
        folder = Container(title="Folder")
        content = Content(title="Content")

        ptah.cms.Session.add(container)
        ptah.cms.Session.add(folder)
        ptah.cms.Session.add(content)

        folder["content"] = content
        container["folder"] = folder

        content_uri = content.__uri__
        folder_uri = folder.__uri__
        container_uri = container.__uri__
        transaction.commit()

        container = ptah.resolve(container_uri)
        content = ptah.resolve(content_uri)
        folder = ptah.resolve(folder_uri)

        self.assertEqual(container.keys(), ["folder"])
        self.assertEqual(folder.keys(), ["content"])
        self.assertEqual(folder.__path__, "/container/folder/")
        self.assertEqual(content.__path__, "/container/folder/content/")
        transaction.commit()
Пример #6
0
    def test_container_simple_move(self):
        container = Container(__name__="container", __path__="/container/")
        content = Content(title="Content")

        ptah.cms.Session.add(container)
        ptah.cms.Session.add(content)
        ptah.cms.Session.flush()

        container["content"] = content

        content_uri = content.__uri__
        container_uri = container.__uri__
        transaction.commit()

        container = ptah.resolve(container_uri)
        content = ptah.resolve(content_uri)

        container["moved"] = content

        self.assertEqual(content.__name__, "moved")
        self.assertEqual(content.__path__, "/container/moved/")
        self.assertEqual(content.__parent__, container)
        self.assertEqual(content.__parent_uri__, container.__uri__)
        transaction.commit()

        container = ptah.resolve(container_uri)
        self.assertEqual(container.keys(), ["moved"])
        self.assertEqual(container["moved"].__uri__, content_uri)
Пример #7
0
    def test_container_insert_subtree(self):
        container = Container(__name__ = 'container', __path__ = '/container/')
        folder = Container(title='Folder')
        content = Content(title='Content')

        ptah.cms.Session.add(container)
        ptah.cms.Session.add(folder)
        ptah.cms.Session.add(content)

        folder['content'] = content
        container['folder'] = folder

        content_uri = content.__uri__
        folder_uri = folder.__uri__
        container_uri = container.__uri__
        transaction.commit()

        container = ptah.resolve(container_uri)
        content = ptah.resolve(content_uri)
        folder = ptah.resolve(folder_uri)

        self.assertEqual(container.keys(), ['folder'])
        self.assertEqual(folder.keys(), ['content'])
        self.assertEqual(folder.__path__, '/container/folder/')
        self.assertEqual(content.__path__, '/container/folder/content/')
        transaction.commit()
Пример #8
0
    def test_container_simple_move(self):
        container = self.Container(__name__='container',
                                   __path__='/container/')
        content = self.Content(title='Content')

        ptah.cms.Session.add(container)
        ptah.cms.Session.add(content)
        ptah.cms.Session.flush()

        container['content'] = content

        content_uri = content.__uri__
        container_uri = container.__uri__
        transaction.commit()

        container = ptah.resolve(container_uri)
        content = ptah.resolve(content_uri)

        container['moved'] = content

        self.assertEqual(content.__name__, 'moved')
        self.assertEqual(content.__path__, '/container/moved/')
        self.assertEqual(content.__parent__, container)
        self.assertEqual(content.__parent_uri__, container.__uri__)
        transaction.commit()

        container = ptah.resolve(container_uri)
        self.assertEqual(container.keys(), ['moved'])
        self.assertEqual(container['moved'].__uri__, content_uri)
Пример #9
0
    def test_container_delete_recursive(self):
        container = self.Container(__name__='container',
                                   __path__='/container/')
        folder = self.Container(title='Folder')
        content = self.Content(title='Content')

        ptah.cms.Session.add(container)
        ptah.cms.Session.add(folder)
        ptah.cms.Session.add(content)
        ptah.cms.Session.flush()

        container['folder'] = folder
        folder['content'] = content

        content_uri = content.__uri__
        container_uri = container.__uri__
        folder_uri = folder.__uri__
        transaction.commit()

        container = ptah.resolve(container_uri)
        del container['folder']
        transaction.commit()

        self.assertTrue(ptah.resolve(content_uri) is None)
        self.assertTrue(ptah.resolve(folder_uri) is None)
Пример #10
0
    def test_container_getitem(self):
        container = Container(__name__ = 'container', __path__ = '/container/')
        content1 = Content(title='Content1')
        content2 = Content(title='Content2')

        container['content1'] = content1
        container['content2'] = content2

        self.assertEqual(container['content1'].__uri__, content1.__uri__)
        self.assertEqual(container['content2'].__uri__, content2.__uri__)
        self.assertEqual(container.get('content1').__uri__, content1.__uri__)
        self.assertEqual(container.get('content2').__uri__, content2.__uri__)

        ptah.cms.Session.add(container)
        ptah.cms.Session.add(content1)
        ptah.cms.Session.add(content2)
        ptah.cms.Session.flush()

        c_u = container.__uri__
        c1_u = content1.__uri__
        c2_u = content2.__uri__
        transaction.commit()

        container = ptah.resolve(c_u)
        self.assertEqual(container['content1'].__uri__, c1_u)
        self.assertEqual(container['content2'].__uri__, c2_u)
        transaction.commit()

        container = ptah.resolve(c_u)
        self.assertEqual(container.get('content1').__uri__, c1_u)
        self.assertEqual(container.get('content2').__uri__, c2_u)
Пример #11
0
def generateThumbnail(theme, width=210):
    blob = ptah.resolve(theme.preview)
    if not blob:
        return

    data = StringIO(blob.read())
    image = PIL.Image.open(data)

    if image.mode == '1':
        image = image.convert('L')
    elif image.mode == 'P':
        image = image.convert('RGBA')

    # get width, height
    orig_size = image.size

    scale = float(width) / orig_size[0]
    height = int(round(orig_size[1] * scale))

    #convert image
    pilfilter = PIL.Image.NEAREST
    pilfilter = PIL.Image.ANTIALIAS

    image.thumbnail((width, height), pilfilter)

    newfile = StringIO()
    image.save(newfile, 'jpeg', quality=88)

    blob = ptah.resolve(theme.thumbnail)
    if blob is None:
        blob = ptah.cms.blob_storage.create(theme)
        theme.thumbnail = blob.__uri__

    blob.write(newfile.getvalue())
    blob.updateMetadata(mimetype='image/jpeg')
Пример #12
0
    def test_container_delete(self):
        container = self.Container(__name__='container',
                                   __path__='/container/')
        content = self.Content(title='Content')

        ptah.cms.Session.add(container)
        ptah.cms.Session.add(content)
        ptah.cms.Session.flush()

        container['content'] = content

        content_uri = content.__uri__
        container_uri = container.__uri__
        transaction.commit()

        container = ptah.resolve(container_uri)
        del container['content']
        self.assertEqual(container.keys(), [])
        self.assertEqual(container.values(), [])

        transaction.commit()

        self.assertTrue(ptah.resolve(content_uri) is None)

        container = ptah.resolve(container_uri)
        self.assertEqual(container.keys(), [])
        self.assertRaises(KeyError, container.__delitem__, 'content')
        self.assertRaises(KeyError, container.__delitem__, Content())
Пример #13
0
    def test_container_insert_subtree(self):
        container = self.Container(__name__='container',
                                   __path__='/container/')
        folder = self.Container(title='Folder')
        content = self.Content(title='Content')

        ptah.cms.Session.add(container)
        ptah.cms.Session.add(folder)
        ptah.cms.Session.add(content)

        folder['content'] = content
        container['folder'] = folder

        content_uri = content.__uri__
        folder_uri = folder.__uri__
        container_uri = container.__uri__
        transaction.commit()

        container = ptah.resolve(container_uri)
        content = ptah.resolve(content_uri)
        folder = ptah.resolve(folder_uri)

        self.assertEqual(container.keys(), ['folder'])
        self.assertEqual(folder.keys(), ['content'])
        self.assertEqual(folder.__path__, '/container/folder/')
        self.assertEqual(content.__path__, '/container/folder/content/')
        transaction.commit()
Пример #14
0
    def test_container_getitem(self):
        container = self.Container(__name__='container',
                                   __path__='/container/')
        content1 = self.Content(title='Content1')
        content2 = self.Content(title='Content2')

        container['content1'] = content1
        container['content2'] = content2

        self.assertEqual(container['content1'].__uri__, content1.__uri__)
        self.assertEqual(container['content2'].__uri__, content2.__uri__)
        self.assertEqual(container.get('content1').__uri__, content1.__uri__)
        self.assertEqual(container.get('content2').__uri__, content2.__uri__)

        ptah.cms.Session.add(container)
        ptah.cms.Session.add(content1)
        ptah.cms.Session.add(content2)
        ptah.cms.Session.flush()

        c_u = container.__uri__
        c1_u = content1.__uri__
        c2_u = content2.__uri__
        transaction.commit()

        container = ptah.resolve(c_u)
        self.assertEqual(container['content1'].__uri__, c1_u)
        self.assertEqual(container['content2'].__uri__, c2_u)
        transaction.commit()

        container = ptah.resolve(c_u)
        self.assertEqual(container.get('content1').__uri__, c1_u)
        self.assertEqual(container.get('content2').__uri__, c2_u)
Пример #15
0
    def __call__(self):
        self.tinfo = ptah.resolve(self.params['turi'])

        with ptah.sa_session() as sa:
            self.session = sa
            self.context = ptah.resolve(self.params['uri'])
            return super(EditRecord, self).__call__()
Пример #16
0
    def test_superuser_resolver(self):
        import ptah
        from ptah.authentication import SUPERUSER

        self._init_ptah()

        user = ptah.resolve(ptah.SUPERUSER_URI)
        self.assertIs(user, SUPERUSER)
        self.assertIsNone(ptah.resolve("ptah+auth:unknown"))
Пример #17
0
    def test_superuser_resolver(self):
        import ptah
        from ptah.authentication import SUPERUSER
        self.init_ptah()

        user = ptah.resolve(ptah.SUPERUSER_URI)
        self.assertIs(user, SUPERUSER)
        self.assertIsNone(ptah.resolve('ptah-auth:unknown'))
        self.assertEqual(repr(user), '<ptah Superuser>')
Пример #18
0
    def test_blob_write(self):
        import ptah, ptah.cms

        blob_uri = ptah.cms.blobStorage.add(StringIO("blob data")).__uri__
        blob = ptah.resolve(blob_uri)
        blob.write("new data")
        transaction.commit()

        blob = ptah.resolve(blob_uri)
        self.assertEqual(blob.read(), "new data")
Пример #19
0
    def test_blob_write(self):
        import ptahcms

        blob_uri = ptahcms.blob_storage.add(
            BytesIO(bytes_('blob data', 'utf-8'))).__uri__
        blob = ptah.resolve(blob_uri)
        blob.write(bytes_('new data', 'utf-8'))
        transaction.commit()

        blob = ptah.resolve(blob_uri)
        self.assertEqual(blob.read(), bytes_('new data', 'utf-8'))
Пример #20
0
    def test_blob_write(self):
        import ptah

        blob_uri = ptah.cms.blob_storage.add(
            BytesIO(bytes_('blob data','utf-8'))).__uri__
        blob = ptah.resolve(blob_uri)
        blob.write(bytes_('new data','utf-8'))
        transaction.commit()

        blob = ptah.resolve(blob_uri)
        self.assertEqual(blob.read(), bytes_('new data','utf-8'))
Пример #21
0
def get_user_type(registry=None):
    cfg = ptah.get_settings(CFG_ID_CROWD, registry)
    tp = cfg['type']
    if not tp.startswith('type:'):
        tp = 'type:{0}'.format(tp)

    return ptah.resolve(tp)
Пример #22
0
    def __init__(self, context, request):
        self.tinfo = context.__type__
        self.roles = [r for r in ptah.get_roles().values() if not r.system]
        self.local_roles = local_roles = context.__local_roles__
        self.local_principals = [ptah.resolve(principalUri)
                               for principalUri in self.local_roles]

        for p in list(ptah.search_principals('')):
            p = ptah.resolve(p.__uri__)
            if hasattr(p, 'properties'):
                if p.properties.get('roles') and p not in self.local_principals:
                    self.local_principals.append(p)

        self.principals = sorted(self.local_principals, key=lambda p: str(p))

        super(ShareForm, self).__init__(context, request)
Пример #23
0
    def test_container_keys_with_local(self):
        container = self.Container(__name__='container',
                                   __path__='/container/')
        content = self.Content(title='Content')
        container['content'] = content

        ptah.cms.Session.add(container)
        ptah.cms.Session.add(content)
        ptah.cms.Session.flush()

        content_uri = content.__uri__
        container_uri = container.__uri__
        transaction.commit()

        container = ptah.resolve(container_uri)

        c2 = Content(title='Content2')
        container['content2'] = c2

        self.assertEqual(container.keys(), ['content', 'content2'])
        self.assertEqual([c.__uri__ for c in container.values()],
                         [content_uri, c2.__uri__])

        del container['content']

        self.assertEqual(container.keys(), ['content2'])
        self.assertEqual([c.__uri__ for c in container.values()], [c2.__uri__])
Пример #24
0
    def test_uri_resolver(self):
        import ptah
        import sqlalchemy as sqla

        @ptah.type('mycontent', 'MyContent')
        class MyContentSql(ptah.get_base()):
            __tablename__ = 'tinfo_sql_test7'

            id = sqla.Column(sqla.Integer, primary_key=True)
            test = sqla.Column(sqla.Unicode)

        self.init_ptah()

        id = None
        uri = None

        with ptah.sa_session() as sa:
            item = MyContentSql(test='title')
            sa.add(item)
            sa.flush()

            id = item.id
            uri = item.__uri__

        self.assertEqual(uri, 'mycontent:%s'%id)

        item = ptah.resolve(uri)
        self.assertTrue(item.id == id)
Пример #25
0
    def test_container_keys_with_local(self):
        container = Container(__name__ = 'container', __path__ = '/container/')
        content = Content(title='Content')
        container['content'] = content

        ptah.cms.Session.add(container)
        ptah.cms.Session.add(content)
        ptah.cms.Session.flush()

        content_uri = content.__uri__
        container_uri = container.__uri__
        transaction.commit()

        container = ptah.resolve(container_uri)

        c2 = Content(title='Content2')
        container['content2'] = c2

        self.assertEqual(container.keys(), ['content', 'content2'])
        self.assertEqual([c.__uri__ for c in container.values()],
                         [content_uri, c2.__uri__])

        del container['content']

        self.assertEqual(container.keys(), ['content2'])
        self.assertEqual([c.__uri__ for c in container.values()],
                         [c2.__uri__])
Пример #26
0
def get_user_type(registry=None):
    cfg = ptah.get_settings(CFG_ID_CROWD, registry)
    tp = cfg["type"]
    if not tp.startswith("type:"):
        tp = "type:{0}".format(tp)

    return ptah.resolve(tp)
Пример #27
0
    def test_container_basics(self):
        container = Container(__name__="container", __path__="/container/")
        content = Content(title="Content")

        ptah.cms.Session.add(container)
        ptah.cms.Session.add(content)
        ptah.cms.Session.flush()

        self.assertEqual(content.__path__, "")

        self.assertRaises(ValueError, container.__setitem__, "content", object())

        self.assertRaises(ValueError, container.__setitem__, "content", container)

        container["content"] = content
        self.assertEqual(content.__name__, "content")
        self.assertEqual(content.__path__, "/container/content/")
        self.assertEqual(content.__parent__, container)
        self.assertEqual(content.__parent_uri__, container.__uri__)

        content_uri = content.__uri__
        container_uri = container.__uri__
        transaction.commit()

        container = ptah.resolve(container_uri)
        self.assertTrue("content" in container)
        self.assertEqual(container.keys(), ["content"])
        self.assertEqual(container["content"].__uri__, content_uri)
        self.assertEqual(container.get("content").__uri__, content_uri)
        self.assertEqual(container.get("unknown"), None)
        self.assertRaises(KeyError, container.__getitem__, "unknown")

        content = container["content"]
        self.assertRaises(KeyError, container.__setitem__, "content", content)
Пример #28
0
    def test_container_keys_with_local(self):
        container = Container(__name__="container", __path__="/container/")
        content = Content(title="Content")
        container["content"] = content

        ptah.cms.Session.add(container)
        ptah.cms.Session.add(content)
        ptah.cms.Session.flush()

        content_uri = content.__uri__
        container_uri = container.__uri__
        transaction.commit()

        container = ptah.resolve(container_uri)

        c2 = Content(title="Content2")
        container["content2"] = c2

        self.assertEqual(container.keys(), ["content", "content2"])
        self.assertEqual([c.__uri__ for c in container.values()], [content_uri, c2.__uri__])

        del container["content"]

        self.assertEqual(container.keys(), ["content2"])
        self.assertEqual([c.__uri__ for c in container.values()], [c2.__uri__])
Пример #29
0
def get_user_type(registry=None):
    cfg = ptah.get_settings(CFG_ID_CROWD, registry)
    tp = cfg['type']
    if not tp.startswith('type:'):
        tp = 'type:{0}'.format(tp)

    return ptah.resolve(tp)
Пример #30
0
    def test_uri_resolver(self):
        import ptah
        import sqlalchemy as sqla

        @ptah.tinfo('mycontent', 'MyContent')
        class MyContentSql(ptah.get_base()):
            __tablename__ = 'tinfo_sql_test7'

            id = sqla.Column(sqla.Integer, primary_key=True)
            test = sqla.Column(sqla.Unicode)

        self.init_ptah()

        id = None
        uri = None

        sa = ptah.get_session()
        item = MyContentSql(test='title')
        sa.add(item)
        sa.flush()

        id = item.id
        uri = item.__uri__

        self.assertEqual(uri, 'mycontent:%s'%id)

        item = ptah.resolve(uri)
        self.assertTrue(item.id == id)
Пример #31
0
    def create(self):
        data, errors = self.extract()

        if errors:
            self.add_error_message(errors)
            return

        # create user
        cfg = ptah.get_settings(ptahcrowd.CFG_ID_CROWD, self.request.registry)
        tp = cfg['type']
        if not tp.startswith('type:'):
            tp = 'type:{0}'.format(tp)

        tinfo = ptah.resolve(tp)

        user = tinfo.create(fullname=data['fullname'],
                            username=data['username'],
                            email=data['email'],
                            validated=data['validated'],
                            suspended=data['suspended'])
        user.password = ptah.pwd_tool.encode(data['password'])

        tinfo.add(user)

        # notify system
        self.request.registry.notify(ptah.events.PrincipalAddedEvent(user))

        self.request.add_message('User has been created.', 'success')
        return HTTPFound(location='.')
Пример #32
0
    def create(self, tname, name=None, **params):
        tinfo = ptah.resolve(tname)
        if tinfo is None:
            raise NotFound('Type information is not found')

        tinfo.check_context(self)

        item = tinfo.create()

        if not name:
            name = item.__uri__

        if '/' in name:
            raise Error("Names cannot contain '/'")

        if name.startswith(' '):
            raise Error("Names cannot starts with ' '")

        if name in self:
            raise Error("Name already in use.")

        self[name] = item

        item.update(**params)

        return item
Пример #33
0
    def test_loadapi_load_with_parents(self):
        content = Content(title='Content')
        container = Container(__name__='container', __path__='/container/')

        c_uri = content.__uri__
        co_uri = container.__uri__
        ptah.cms.Session.add(container)
        ptah.cms.Session.add(content)
        transaction.commit()

        container = ptah.resolve(co_uri)
        container['content'] = ptah.resolve(c_uri)
        transaction.commit()

        content = ptah.cms.load(c_uri)
        self.assertEqual(content.__parent__.__uri__, co_uri)
Пример #34
0
    def test_loadapi_load_with_parents(self):
        content = Content(title='Content')
        container = Container(__name__='container', __path__='/container/')

        c_uri = content.__uri__
        co_uri = container.__uri__
        ptah.cms.Session.add(container)
        ptah.cms.Session.add(content)
        transaction.commit()

        container = ptah.resolve(co_uri)
        container['content'] = ptah.resolve(c_uri)
        transaction.commit()

        content = ptah.cms.load(c_uri)
        self.assertEqual(content.__parent__.__uri__, co_uri)
Пример #35
0
    def create(self):
        data, errors = self.extract()

        if errors:
            self.add_error_message(errors)
            return

        # create user
        cfg = ptah.get_settings(ptahcrowd.CFG_ID_CROWD, self.request.registry)
        tp = cfg['type']
        if not tp.startswith('type:'):
            tp = 'type:{0}'.format(tp)

        tinfo = ptah.resolve(tp)

        user = tinfo.create(
            fullname=data['fullname'], username=data['username'], email=data['email'],
            validated=data['validated'], suspended=data['suspended'])
        user.password = ptah.pwd_tool.encode(data['password'])

        tinfo.add(user)

        # notify system
        self.request.registry.notify(ptah.events.PrincipalAddedEvent(user))

        self.request.add_message('User has been created.', 'success')
        return HTTPFound(location='.')
Пример #36
0
    def create(self):
        data, errors = self.extract()

        if errors:
            self.message(errors, "form-error")
            return

        # create user
        cfg = ptah.get_settings(ptahcrowd.CFG_ID_CROWD, self.request.registry)
        tp = cfg["type"]
        if not tp.startswith("type:"):
            tp = "type:{0}".format(tp)

        tinfo = ptah.resolve(tp)

        user = tinfo.create(
            name=data["name"],
            login=data["login"],
            email=data["login"],
            validated=data["validated"],
            suspended=data["suspended"],
        )
        user.password = ptah.pwd_tool.encode(data["password"])

        tinfo.add(user)

        # notify system
        self.request.registry.notify(ptah.events.PrincipalAddedEvent(user))

        self.message("User has been created.", "success")
        return HTTPFound(location=".")
Пример #37
0
    def modify_handler(self):
        data, errors = self.extract()
        if errors:
            return errors

        with ptah.sa_session() as sa:
            user = ptah.resolve(self.params['__uri__'])

            # update attrs
            user.name = data['name']
            user.login = data['login']
            user.email = data['login']
            if data['password'] is not ptah.form.null:
                user.password = ptah.pwd_tool.encode(data['password'])

            # update props
            user.validated = data['validated']
            user.suspended = data['suspended']

            # add roles and groups info
            props = user.properties
            props['roles'] = data['roles']
            props['groups'] = data['groups']

            info = self.protocol.get_user_data(user)

        # done
        self.close('User properties has been updated.')
        self.protocol.broadcast('updated', info)
Пример #38
0
    def test_app_factory(self):
        import ptah.cms
        self._init_ptah()

        factory = ptah.cms.ApplicationFactory('/test', 'root', 'Root App')

        self.assertTrue(factory.id == 'test')
        self.assertTrue(factory.path == '/test/')
        self.assertTrue(factory.name == 'root')
        self.assertTrue(factory.title == 'Root App')
        self.assertTrue(factory.policy is ptah.cms.ApplicationPolicy)

        self._setRequest(self._makeRequest())

        root = factory(self.request)
        r_uri = root.__uri__

        self.assertTrue(isinstance(root, ptah.cms.ApplicationRoot))
        self.assertTrue(root.title == 'Root App')
        self.assertTrue(root.__name__ == 'root')
        self.assertTrue(root.__root_path__ == '/test/')
        self.assertTrue(root.__resource_url__(None, {}) == '/test/')
        self.assertTrue(self.request.root is root)
        transaction.commit()

        root = factory(self.request)
        self.assertEqual(root.__uri__, r_uri)
        transaction.commit()

        root = ptah.resolve(r_uri)
        self.assertEqual(root.__uri__, r_uri)

        factory = ptah.cms.ApplicationFactory('', 'root', 'Root App')
        self.assertTrue(factory.default_root)
Пример #39
0
    def test_uri_resolver(self):
        import ptah
        import sqlalchemy as sqla

        @ptah.tinfo("mycontent", "MyContent")
        class MyContentSql(ptah.get_base()):
            __tablename__ = "tinfo_sql_test7"

            id = sqla.Column(sqla.Integer, primary_key=True)
            test = sqla.Column(sqla.Unicode)

        self.init_ptah()

        id = None
        uri = None

        sa = ptah.get_session()
        item = MyContentSql(test="title")
        sa.add(item)
        sa.flush()

        id = item.id
        uri = item.__uri__

        self.assertEqual(uri, "mycontent:%s" % id)

        item = ptah.resolve(uri)
        self.assertTrue(item.id == id)
Пример #40
0
    def create(self, tname, name=None, **params):
        tinfo = ptah.resolve(tname)
        if tinfo is None:
            raise NotFound('Type information is not found')

        tinfo.check_context(self)

        item = tinfo.create()

        if not name:
            name = item.__uri__

        if '/' in name:
            raise Error("Names cannot contain '/'")

        if name.startswith(' '):
            raise Error("Names cannot starts with ' '")

        if name in self:
            raise Error("Name already in use.")

        self[name] = item

        item.update(**params)

        return item
Пример #41
0
    def __init__(self, context, request):
        self.tinfo = context.__type__
        self.roles = [r for r in ptah.get_roles().values() if not r.system]
        self.local_roles = local_roles = context.__local_roles__
        self.local_principals = [
            ptah.resolve(principalUri) for principalUri in self.local_roles
        ]

        for p in list(ptah.search_principals('')):
            p = ptah.resolve(p.__uri__)
            if hasattr(p, 'properties'):
                if p.properties.get(
                        'roles') and p not in self.local_principals:
                    self.local_principals.append(p)

        self.principals = sorted(self.local_principals, key=lambda p: str(p))

        super(ShareForm, self).__init__(context, request)
Пример #42
0
    def test_container_move_self_recursevly(self):
        container = Container(__name__="container", __path__="/container/")
        folder = Container(title="Folder")

        ptah.cms.Session.add(container)
        ptah.cms.Session.add(folder)
        ptah.cms.Session.flush()

        container["folder"] = folder

        folder_uri = folder.__uri__
        container_uri = container.__uri__
        transaction.commit()

        container = ptah.resolve(container_uri)
        folder = ptah.resolve(folder_uri)

        self.assertRaises(TypeError, folder.__setitem__, "subfolder", container)
Пример #43
0
    def data(self):
        """ Download data. """
        blob = ptah.resolve(self.blobref)
        if blob is None:
            raise cms.NotFound()

        return {'mimetype': blob.mimetype,
                'filename': blob.filename,
                'data': blob.read()}
Пример #44
0
    def test_uri_registration(self):
        import ptah

        def resolver1(uri):
            return 'Resolved1'
        def resolver2(uri):
            return 'Resolved2'

        ptah.register_uri_resolver('test1', resolver1)
        ptah.register_uri_resolver('test2', resolver2)
        self._init_ptah()

        self.assertEqual(ptah.resolve('test1:uri'), 'Resolved1')
        self.assertEqual(ptah.resolve('test2:uri'), 'Resolved2')

        self.assertEqual(ptah.resolve(None), None)
        self.assertEqual(ptah.resolve('unknown'), None)
        self.assertEqual(ptah.resolve('unknown:uri'), None)
Пример #45
0
def thumbnailImage(context, request):
    blob = ptah.resolve(context.thumbnail)
    if blob is None:
        return HTTPNotFound()

    response = request.response
    response.content_type = blob.mimetype.encode('utf-8')
    response.body = blob.read()
    return response
Пример #46
0
    def data(self):
        """ Download data. """
        blob = ptah.resolve(self.blobref)
        if blob is None:
            raise cms.NotFound()

        return {'mimetype': blob.mimetype,
                'filename': blob.filename,
                'data': blob.read()}
Пример #47
0
    def test_uri_registration_decorator(self):
        import ptah

        @ptah.resolver('test1')
        def resolver1(uri):
            return 'Resolved1'

        @ptah.resolver('test2')
        def resolver2(uri):
            return 'Resolved2'

        self.init_ptah()

        self.assertEqual(ptah.resolve('test1:uri'), 'Resolved1')
        self.assertEqual(ptah.resolve('test2:uri'), 'Resolved2')

        self.assertEqual(ptah.resolve(None), None)
        self.assertEqual(ptah.resolve('unknown'), None)
        self.assertEqual(ptah.resolve('unknown:uri'), None)
Пример #48
0
    def test_uri_registration(self):
        import ptah

        def resolver1(uri):
            return 'Resolved1'

        def resolver2(uri):
            return 'Resolved2'

        ptah.register_uri_resolver('test1', resolver1)
        ptah.register_uri_resolver('test2', resolver2)

        self.init_ptah()

        self.assertEqual(ptah.resolve('test1:uri'), 'Resolved1')
        self.assertEqual(ptah.resolve('test2:uri'), 'Resolved2')

        self.assertEqual(ptah.resolve(None), None)
        self.assertEqual(ptah.resolve('unknown'), None)
        self.assertEqual(ptah.resolve('unknown:uri'), None)
Пример #49
0
    def update(self):
        self.user = ptah.resolve(self.context.userid)
        self.manage_url = get_manage_url(self.request)

        mod = self.request.context
        while not isinstance(mod, PtahModule):
            mod = getattr(mod, '__parent__', None)
            if mod is None:  # pragma: no cover
                break

        self.module = mod
Пример #50
0
    def test_container_move_self_recursevly(self):
        container = self.Container(__name__='container',
                                   __path__='/container/')
        folder = self.Container(title='Folder')

        ptah.cms.Session.add(container)
        ptah.cms.Session.add(folder)
        ptah.cms.Session.flush()

        container['folder'] = folder

        folder_uri = folder.__uri__
        container_uri = container.__uri__
        transaction.commit()

        container = ptah.resolve(container_uri)
        folder = ptah.resolve(folder_uri)

        self.assertRaises(TypeError, folder.__setitem__, 'subfolder',
                          container)
Пример #51
0
    def tinfo(self):
        tname = self.request.params.get('tname', None)
        if not tname:
            raise HTTPNotFound()
        tinfo = ptah.resolve('type:%s' % tname)

        if not tinfo:
            raise HTTPNotFound()
        if not tinfo in self.context.__type__.list_types(self.context):
            raise HTTPForbidden()

        return tinfo
Пример #52
0
    def test_uri_resolver_pyramid(self):
        import ptah

        def resolver1(uri):
            return 'Resolved-pyramid'

        config = testing.setUp()
        config.include('ptah')
        config.ptah_uri_resolver('test1', resolver1)
        config.commit()

        self.assertEqual(ptah.resolve('test1:uri'), 'Resolved-pyramid')
Пример #53
0
    def test_blob_resolver(self):
        import ptah

        blob = ptah.cms.blob_storage.add(BytesIO(bytes_('blob data', 'utf-8')))

        blob_uri = blob.__uri__
        transaction.commit()

        blob = ptah.resolve(blob_uri)

        self.assertEqual(blob.__uri__, blob_uri)
        self.assertEqual(blob.read(), bytes_('blob data', 'utf-8'))
Пример #54
0
def logout(request):
    """Logout action"""
    uid = ptah.auth_service.get_userid()

    if uid is not None:
        ptah.auth_service.set_userid(None)
        request.registry.notify(ptah.events.LoggedOutEvent(ptah.resolve(uid)))

        request.add_message(const.LOGOUT_SUCCESSFUL, 'info')
        headers = security.forget(request)
        return HTTPFound(headers=headers, location=request.application_url)
    else:
        return HTTPFound(location=request.application_url)
Пример #55
0
    def test_tinfo_type_resolver(self):
        import ptah

        @ptah.tinfo('mycontent2', 'MyContent')
        class MyContent(object):
            pass

        self.init_ptah()

        tinfo_uri = MyContent.__type__.__uri__

        self.assertEqual(tinfo_uri, 'type:mycontent2')
        self.assertIs(ptah.resolve(tinfo_uri), MyContent.__type__)
Пример #56
0
    def test_container_simple_rename_subtree(self):
        container = self.Container(__name__='container',
                                   __path__='/container/')
        folder1 = self.Container(title='Folder1')
        folder2 = self.Container(title='Folder2')
        content = self.Content(title='Content')

        ptah.cms.Session.add(container)
        ptah.cms.Session.add(folder1)
        ptah.cms.Session.add(folder2)
        ptah.cms.Session.add(content)
        ptah.cms.Session.flush()

        container['folder1'] = folder1
        folder1['folder2'] = folder2
        folder2['content'] = content

        content_uri = content.__uri__
        container_uri = container.__uri__
        folder1_uri = folder1.__uri__
        folder2_uri = folder2.__uri__
        transaction.commit()

        container = ptah.resolve(container_uri)

        container['new-folder'] = container['folder1']
        transaction.commit()

        folder1 = ptah.resolve(folder1_uri)
        folder2 = ptah.resolve(folder2_uri)
        content = ptah.resolve(content_uri)
        container = ptah.resolve(container_uri)

        self.assertEqual(container.keys(), ['new-folder'])
        self.assertEqual(folder1.__path__, '/container/new-folder/')
        self.assertEqual(folder2.__path__, '/container/new-folder/folder2/')
        self.assertEqual(content.__path__,
                         '/container/new-folder/folder2/content/')
Пример #57
0
def crowd_user_roles(context, uid, registry):
    """ crowd roles provider

    return user default roles and user group roles"""
    roles = set()

    props = getattr(ptah.resolve(uid), 'properties', None)
    if props is not None:
        roles.update(props.get('roles',()))

        for grp in props.get('groups',()):
            roles.update(ptah.get_local_roles(grp, context))

    return roles
Пример #58
0
def themeFileDownload(context, request):
    blob = ptah.resolve(context.data)
    if not blob:
        return ' '

    response = request.response
    response.content_type = blob.mimetype.encode('utf-8')
    if blob.filename:
        response.headerlist = {
            'Content-Disposition':
            'filename="%s"' % blob.filename.encode('utf-8')
        }
    response.body = blob.read()
    return response
Пример #59
0
    def test_tinfo_type_resolver(self):
        import ptah, ptah.cms

        global MyContent

        class MyContent(ptah.cms.Content):
            __type__ = ptah.cms.Type('mycontent2', 'MyContent')

        self.init_ptah()

        tinfo_uri = MyContent.__type__.__uri__

        self.assertEqual(tinfo_uri, 'cms-type:mycontent2')
        self.assertIs(ptah.resolve(tinfo_uri), MyContent.__type__)