class User(ptah.get_base()):
__tablename__ = 'rackptahbles_users'
pid = sqla.Column(sqla.Integer, primary_key=True)
uri = sqla.Column(sqla.Unicode, unique=True, info={'uri': True})
name = sqla.Column(sqla.Unicode)
login = sqla.Column(sqla.Unicode, unique=True)
email = sqla.Column(sqla.Unicode, unique=True)
password = sqla.Column(sqla.Unicode)
_uri_gen = ptah.UriFactory('custom-user')
def __init__(self, name, login, email, password=u''):
super(User, self).__init__()
self.name = name
self.login = login
self.email = email
self.password = ptah.pwd_tool.encode(password)
self.uri = self._uri_gen()
@classmethod
def get_byuri(cls, uri):
return ptah.get_session().query(User).filter(User.uri==uri).first()
@classmethod
def get_bylogin(cls, login):
return ptah.get_session().query(User).filter(User.login==login).first()
def Type(name, title=None, fieldset=None, **kw):
""" Declare new type. This function has to be called within a content
class declaration.
.. code-block:: python
class MyContent(ptahcms.Content):
__type__ = Type('My content')
"""
info = config.DirectiveInfo(allowed_scope=('class', ))
kw['title'] = name.capitalize() if title is None else title
fs = ContentSchema if fieldset is None else fieldset
typeinfo = TypeInformation(None, name, fieldset=fs, **kw)
f_locals = sys._getframe(1).f_locals
if '__mapper_args__' not in f_locals:
f_locals['__mapper_args__'] = {
'polymorphic_identity': typeinfo.__uri__
}
if '__id__' not in f_locals and '__tablename__' in f_locals:
f_locals['__id__'] = sqla.Column(
'id',
sqla.Integer,
sqla.ForeignKey('ptahcms_contents.id'),
primary_key=True)
if '__uri_factory__' not in f_locals:
schema = 'type-{0}'.format(name)
typeinfo.schema = schema
f_locals['__uri_factory__'] = ptah.UriFactory(schema)
def resolve_content(uri):
return typeinfo.cls.__uri_sql_get__.first(uri=uri)
resolve_content.__doc__ = 'CMS Content resolver for %s type' % name
ptah.resolver(schema, 2)(resolve_content)
# config actino and introspection info
discr = (TYPES_DIR_ID, name)
intr = config.Introspectable(TYPES_DIR_ID, discr, name, TYPES_DIR_ID)
intr['name'] = name
intr['type'] = typeinfo
intr['codeinfo'] = info.codeinfo
info.attach(ClassAction(register_type_impl, (typeinfo, name, fieldset),
kw,
discriminator=discr,
introspectables=(intr, )),
depth=2)
return typeinfo
def test_uri_uri_generator(self):
import ptah
uri = ptah.UriFactory('test')
u1 = uri()
u2 = uri()
self.assertTrue(u1.startswith('test:'))
self.assertTrue(u2.startswith('test:'))
self.assertTrue(u1 != u2)
class Blob(Node):
""" simple blob implementation """
__tablename__ = 'ptahcms_blobs'
__mapper_args__ = {'polymorphic_identity': 'blob-sql'}
__uri_factory__ = ptah.UriFactory('blob-sql')
__id__ = sqla.Column('id',
sqla.Integer,
sqla.ForeignKey('ptahcms_nodes.id'),
primary_key=True)
mimetype = sqla.Column(sqla.String(128), default=text_type(''))
filename = sqla.Column(sqla.String(255), default=text_type(''))
size = sqla.Column(sqla.Integer, default=0)
data = sqla.orm.deferred(sqla.Column(sqla.LargeBinary))
def read(self):
return self.data
def write(self, data):
self.data = data
self.size = len(data)
def updateMetadata(self, mimetype=None, filename=None, **md):
if mimetype is not None:
self.mimetype = mimetype
if filename is not None:
self.filename = filename
def info(self):
info = super(Blob, self).info()
info['size'] = self.size
info['mimetype'] = self.mimetype
info['filename'] = self.filename
return info
class MyContent(ptahcms.Node):
__name__ = ''
__mapper_args__ = {'polymorphic_identity': 'mycontent'}
__uri_factory__ = ptah.UriFactory('test')
class Container(ptah.cms.Container):
__type__ = ptah.cms.Type('container', 'Test Container')
__uri_factory__ = ptah.UriFactory('cms-container')
class Content(ptah.cms.Content):
__type__ = ptah.cms.Type('content', 'Test Content')
__uri_factory__ = ptah.UriFactory('cms-content')
class MyContent(ptahcms.Node):
__uri_factory__ = ptah.UriFactory('test')
class MyContent(ptahcms.Content):
__mapper_args__ = {'polymorphic_identity': 'mycontent'}
__uri_factory__ = ptah.UriFactory('mycontent')
class Test(ptah.cms.Content):
__uri_factory__ = ptah.UriFactory('test')
@ptah.cms.action(permission=ptah.NO_PERMISSION_REQUIRED)
def update(self, *args, **data): # pragma: no cover
pass
