def initialize_sql(engine, drop_all=False):
DBSession.registry.clear()
DBSession.configure(bind=engine)
metadata.bind = engine
if drop_all or os.environ.get('KOTTI_TEST_DB_STRING'):
metadata.reflect()
metadata.drop_all(engine)
# Allow users of Kotti to cherry pick the tables that they want to use:
settings = get_current_registry().settings
tables = settings['kotti.use_tables'].strip() or None
if tables:
tables = [metadata.tables[name] for name in tables.split()]
if engine.dialect.name == 'mysql': # pragma: no cover
from sqlalchemy.dialects.mysql.base import LONGBLOB
File.__table__.c.data.type = LONGBLOB()
# Allow migrations to set the 'head' stamp in case the database is
# initialized freshly:
if not engine.table_names():
stamp_heads()
metadata.create_all(engine, tables=tables)
if os.environ.get('KOTTI_DISABLE_POPULATORS', '0') not in ('1', 'y'):
for populate in get_settings()['kotti.populators']:
populate()
commit()
return DBSession
class File(Node):
"""
A file model
"""
__tablename__ = 'file'
__table_args__ = default_table_args
__mapper_args__ = {'polymorphic_identity': 'file'}
id = Column(Integer, ForeignKey('node.id'), primary_key=True)
description = Column(String(100), default="")
data = deferred(Column(LONGBLOB()))
mimetype = Column(String(100))
size = Column(Integer)
def getvalue(self):
"""
Method making our file object compatible with the common file rendering
utility
"""
return self.data
@property
def label(self):
"""
Simple shortcut for getting a label for this file
"""
return self.description or self.name
@property
def data_obj(self):
res = StringIO()
res.write(self.data)
return res
class ConfigFiles(DBBASE):
"""
A file model
"""
__tablename__ = 'config_files'
__table_args__ = default_table_args
id = Column(Integer, primary_key=True)
key = Column(String(100), unique=True)
name = Column(String(100))
data = deferred(Column(LONGBLOB()))
mimetype = Column(String(100))
size = Column(Integer)
def getvalue(self):
"""
Method making our file object compatible with the common file rendering
utility
"""
return self.data
@property
def label(self):
"""
Simple shortcut for getting a label for this file
"""
return self.name
@classmethod
def get(cls, key):
"""
Override the default get method to get by key and not by id
"""
return cls.query().filter(cls.key == key).first()
@classmethod
def set(cls, key, appstruct):
"""
Set a file for the given key, if the key isn't field yet, add a new
instance
"""
instance = cls.get(key)
if instance is None:
instance = cls(key=key)
for attr_name, attr_value in appstruct.items():
setattr(instance, attr_name, attr_value)
if instance.id is not None:
DBSESSION().merge(instance)
else:
DBSESSION().add(instance)
def adjust_for_engine(conn, branch):
# adjust for engine type
if conn.engine.dialect.name == 'mysql': # pragma: no cover
from sqlalchemy.dialects.mysql.base import LONGBLOB
DBStoredFile.__table__.c.data.type = LONGBLOB()
# sqlite's Unicode columns return a buffer which can't be encoded by
# a json encoder. We have to convert to a unicode string so that the value
# can be saved corectly by
# :class:`depot.fields.sqlalchemy.upload.UploadedFile`
def patched_processed_result_value(self, value, dialect):
if not value:
return None
return self._upload_type.decode(unicode(value))
if conn.engine.dialect.name == 'sqlite': # pragma: no cover
from depot.fields.sqlalchemy import UploadedFileField
UploadedFileField.process_result_value = patched_processed_result_value