def __init__(self, timeout):
global visit_class
visit_class_path = config.get("visit.saprovider.model", "turbogears.visit.savisit.TG_Visit")
visit_class = load_class(visit_class_path)
if visit_class is None:
msg = "No visit class found for %s" % visit_class_path
msg += ", did you run setup.py develop?"
log.error(msg)
get_engine()
if visit_class is TG_Visit:
mapper(visit_class, visits_table)
# base-class' __init__ triggers self.create_model, so mappers need to
# be initialized before.
super(SqlAlchemyVisitManager, self).__init__(timeout)
def __init__(self, timeout):
global visit_class
visit_class_path = config.get("visit.saprovider.model",
"turbogears.visit.savisit.TG_Visit")
visit_class = load_class(visit_class_path)
if visit_class is None:
msg = 'No visit class found for %s' % visit_class_path
msg += ', did you run setup.py develop?'
log.error(msg)
get_engine()
if visit_class is TG_Visit:
mapper(visit_class, visits_table)
# base-class' __init__ triggers self.create_model, so mappers need to
# be initialized before.
super(SqlAlchemyVisitManager, self).__init__(timeout)
def create_tables():
"""Create tables filled with test data."""
occupations_table = Table('occupations', metadata,
Column('id', Integer, primary_key=True),
Column('name', String(20)))
users_table = Table('users', metadata,
Column('id', Integer, primary_key=True),
Column('name', String(20)),
Column('occupation_id', Integer, ForeignKey("occupations.id")))
addresses_table = Table('addresses', metadata,
Column('id', Integer, primary_key=True),
Column('user_id', Integer, ForeignKey("users.id")),
Column('street', String(50)),
Column('city', String(40)))
mapper(Occupation, occupations_table)
mapper(User, users_table, properties={
'occupation' : relation(Occupation, lazy=False),
'addresses': relation(Address, backref='user', lazy=False)})
mapper(Address, addresses_table)
try:
metadata.create_all()
except Exception, error:
# workaround for a problem with PySqlite < 2.6 and SQLAlchemy < 0.5
if 'Cannot operate on a closed cursor' in str(error):
metadata.create_all(checkfirst=False)
else:
raise
def _get_cls(self):
return self._cls
pass
cls = property(_get_cls, _set_cls)
class FileSystem(object):
pass
mapper(
Host,
hosts,
properties=dict(
_devices=relation(HostLink, cascade="all,delete-orphan", backref=backref("host"), lazy=None),
devices=relation(HostLink, cascade="all,delete-orphan"),
fas_account=relation(FasLink, uselist=False),
file_systems=relation(FileSystem, backref="host"),
),
)
mapper(
ComputerLogicalDevice,
computer_logical_devices,
properties={
"_host_links": relation(HostLink, cascade="all,delete-orphan", backref=backref("device"), lazy=None),
"host_links": relation(HostLink, cascade="all,delete-orphan"),
},
)
mapper(HostLink, host_links)
ForeignKey('people.id'),
unique=True))
class Show(object):
@classmethod
def by_name(cls, name):
return cls.query.filter_by(name=name).one()
pass
mapper(Show, shows_table,
properties= \
dict(group=relation(Groups, uselist=False, backref='show'),
owner=relation(People, backref='shows'),
user_signups=relation(People,
backref=backref('show', uselist=False),
secondary=user_signups_table)))
class ShowPlugin(controllers.Controller):
capabilities = ['show_plugin']
def __init__(self):
'''Create a Show Controller.'''
self.path = ''
help = Help()
@expose(template="fas.templates.error")
self.hardware = hardware
class Ykval(object):
def __init__(self, active, created, modified, yk_publicname, yk_counter, yk_use, yk_low, yk_high, nonce, notes):
self.active = active
self.created = created
self.modified = modified
self.yk_publicname = yk_publicname
self.yk_counter = yk_counter
self.yk_use = yk_use
self.yk_low = yk_low
self.yk_high = yk_high
self.nonce = nonce
self.notes = notes
mapper(Ykksm, ykksm_table)
mapper(Ykval, ykval_table)
import subprocess
admin_group = config.get('admingroup', 'accounts')
system_group = config.get('systemgroup', 'fas-system')
thirdparty_group = config.get('thirdpartygroup', 'thirdparty')
client_id = '1'
class YubikeySave(validators.Schema):
targetname = KnownUser
yubikey_enabled = validators.OneOf(['0', '1'], not_empty=True)
yubikey_prefix = validators.String(min=12, max=12, not_empty=True)
def get_configs(configs_list):
This is used to make Branch keys for the dictionary mapping of pkg listings
into packages.
'''
return pkg_listing.collection.simple_name
#
# Mappers
#
mapper(
Package,
PackageTable,
properties={
# listings is here for compatibility. Will be removed in 0.4.x
'listings':
relation(PackageListing),
'listings2':
relation(PackageListing,
backref=backref('package'),
collection_class=mapped_collection(collection_alias))
})
mapper(PackageListing,
PackageListingTable,
properties={
'people':
relation(PersonPackageListing),
'people2':
relation(PersonPackageListing,
backref=backref('packagelisting'),
collection_class=attribute_mapped_collection('username')),
return 'PackageListingStatus(%r)' % self.statuscodeid
class PackageAclStatus(BaseStatus):
''' Subset of status codes that apply to Person and Group Package Acls.
Table -- PackageAclStatusCode
'''
# pylint: disable-msg=R0902, R0903
def __repr__(self):
return 'PackageAclStatus(%r)' % self.statuscodeid
#
# Mappers
#
mapper(StatusTranslation, StatusTranslationTable)
mapper(CollectionStatus, CollectionStatusTable, properties={
'collections': relation(Collection, backref=backref('status')),
'collectionPackages': relation(CollectionPackage,
backref=backref('status')),
'translations': relation(StatusTranslation,
order_by=StatusTranslationTable.c.language,
primaryjoin=StatusTranslationTable.c.statuscodeid \
== CollectionStatusTable.c.statuscodeid,
foreign_keys=[StatusTranslationTable.c.statuscodeid]),
'locale': relation(StatusTranslation,
primaryjoin=StatusTranslationTable.c.statuscodeid \
== CollectionStatusTable.c.statuscodeid,
foreign_keys=[StatusTranslationTable.c.statuscodeid],
collection_class=attribute_mapped_collection('language'),
backref=backref('cstatuscode',
class Ykval(object):
def __init__(self, active, created, modified, yk_publicname, yk_counter,
yk_use, yk_low, yk_high, nonce, notes):
self.active = active
self.created = created
self.modified = modified
self.yk_publicname = yk_publicname
self.yk_counter = yk_counter
self.yk_use = yk_use
self.yk_low = yk_low
self.yk_high = yk_high
self.nonce = nonce
self.notes = notes
mapper(Ykksm, ykksm_table)
mapper(Ykval, ykval_table)
import subprocess
admin_group = config.get('admingroup', 'accounts')
system_group = config.get('systemgroup', 'fas-system')
thirdparty_group = config.get('thirdpartygroup', 'thirdparty')
client_id = '1'
class YubikeySave(validators.Schema):
targetname = KnownUser
yubikey_enabled = validators.OneOf(['0', '1'], not_empty=True)
yubikey_prefix = validators.String(min=12, max=12, not_empty=True)
primary_key=True,
autoincrement=True),
Column('major', Integer),
Column('minor', Integer),
Column('point', Integer),
Column('branch', String(64),
default='main'),
Column('name', String(255)),
Column('date_applied', DateTime))
class SchemaChange(object):
def __init__(self, **keys):
if keys:
self.major = keys['major']
self.minor = keys['minor']
self.point = keys['point']
self.branch = keys['branch']
self.name = keys['name']
self.date_applied = datetime.today()
def __str__(self):
return str(self.__dict__)
__repr__ = __str__
pass
mapper(SchemaChange, schema_changes,
order_by=[schema_changes.c.major
,schema_changes.c.minor
,schema_changes.c.point])
as used
'''
used = cls.query.filter_by(nonce=nonce).first()
if used is not None:
# This nonce was already used
return False
captcha = CaptchaNonce()
captcha.nonce = nonce
return True
#
# set up mappers between tables and classes
#
mapper(Session, SessionTable)
mapper(CaptchaNonce, CaptchaNonceTable)
#
# mappers for filtering roles
#
mapper(ApprovedRoles,
ApprovedRolesSelect,
properties={
'group': relation(Groups, backref='approved_roles', lazy=False)
})
mapper(UnApprovedRoles,
UnApprovedRolesSelect,
properties={
'group': relation(Groups, backref='unapproved_roles', lazy=False)
})
hopefully have localizations in pkgdb.
Table -- Languages
'''
def __init__(self, name, shortname):
super(Language, self).__init__()
self.name = name
self.shortname = shortname
def __repr__(self):
return 'Language(%r, %r)' % (self.name, self.shortname)
@classmethod
def find(cls, language):
'''Returns a shortname after searching for both short and longname.
:arg name: a short or long Language name
'''
#pylint:disable-msg=E1101
return session.query(Language).filter(
or_(Language.name == language,
Language.shortname == language)).one()
#pylint:enable-msg=E1101
#
# Mappers
#
mapper(Language, LanguagesTable)
self.statuscode = statuscode
def __repr__(self):
return 'GroupPackageListingAcl(%r, %r, grouppackagelistingid=%r)' % (
self.acl, self.statuscode, self.grouppackagelistingid)
#
# Mappers
#
mapper(PersonPackageListing,
PersonPackageListingTable,
properties={
'acls':
relation(PersonPackageListingAcl),
'acls2':
relation(PersonPackageListingAcl,
backref=backref('personpackagelisting'),
collection_class=attribute_mapped_collection('acl'))
})
mapper(GroupPackageListing,
GroupPackageListingTable,
properties={
'acls':
relation(GroupPackageListingAcl),
'acls2':
relation(GroupPackageListingAcl,
backref=backref('grouppackagelisting'),
collection_class=attribute_mapped_collection('acl'))
})
mapper(PersonPackageListingAcl, PersonPackageListingAclTable)
# IMPORTANT
# We *do* allow tracks to exist without an associated album or artist. Is that a good idea? I dunno...
# Here we set up a trigger to call Track.delete_related_files()
class DeleteFileMapperExtension(MapperExtension):
def after_delete(self, mapper, connection, instance):
instance._delete_related_files()
mapper(
Track,
track,
extension=DeleteFileMapperExtension(),
properties={
'artists': relation(Artist, secondary=artist_track, lazy=True),
'albums': relation(
Album, secondary=album_track, lazy=True
), #this causes all sorts of headaches, cascade='delete-orphan'),
})
mapper(
Artist,
artist,
properties={
'albums':
relation(Album, secondary=album_artist),
'tracks':
relation(Track,
secondary=artist_track,
order_by=Track.title,
class FileSystem(object):
pass
class BatchJob(object):
def __init__(self, data, hw_uuid, added):
self.data = data
self.hw_uuid = hw_uuid
self.added = added
self.arrival = text('NOW()')
mapper(Host, hosts,
properties=dict(_devices=relation(HostLink,
cascade="all,delete-orphan",
backref=backref('host'),
lazy=None),
devices=relation(HostLink, cascade='all,delete-orphan'),
fas_account=relation(FasLink, uselist=False),
file_systems=relation(FileSystem,
backref='host')))
mapper(HostArchive, hosts_archive)
mapper(ComputerLogicalDevice,
computer_logical_devices,
properties = {"_host_links": relation(HostLink,
cascade="all,delete-orphan",
backref=backref('device'),
lazy=None),
"host_links": relation(HostLink,
cascade="all,delete-orphan")})
"""
return self._password
password = property(_get_password, _set_password)
class Permission(object):
"""
A relationship that determines what each Group can do
"""
pass
# set up mappers between identity tables and classes
mapper(Visit, visits_table)
mapper(VisitIdentity, visit_identity_table,
properties=dict(users=relation(User, backref='visit_identity')))
mapper(User, users_table,
properties=dict(_password=users_table.c.password))
mapper(Group, groups_table,
properties=dict(users=relation(User,
secondary=user_group_table, backref='groups')))
mapper(Permission, permissions_table,
properties=dict(groups=relation(Group,
secondary=group_permission_table, backref='permissions')))
:arg pkg_listing: PackageListing to find the Collection for.
:returns: Collection Alias. This is either the branchname or a combination
of the collection name and version.
This is used to make Branch keys for the dictionary mapping of pkg listings
into packages.
'''
return pkg_listing.collection.simple_name
#
# Mappers
#
mapper(Package, PackageTable, properties={
# listings is here for compatibility. Will be removed in 0.4.x
'listings': relation(PackageListing),
'listings2': relation(PackageListing,
backref=backref('package'),
collection_class=mapped_collection(collection_alias))
})
mapper(PackageListing, PackageListingTable, properties={
'people': relation(PersonPackageListing),
'people2': relation(PersonPackageListing, backref=backref('packagelisting'),
collection_class = attribute_mapped_collection('username')),
'groups': relation(GroupPackageListing),
'groups2': relation(GroupPackageListing, backref=backref('packagelisting'),
collection_class = attribute_mapped_collection('groupname')),
})
#
# Mappers
#
mapper(
Collection,
CollectionJoin,
polymorphic_on=CollectionJoin.c.kind,
polymorphic_identity='c',
with_polymorphic='*',
properties={
# listings is deprecated. It will go away in 0.4.x
'listings':
relation(PackageListing),
# listings2 is slower than listings. It has a front-end cost to
# load the data into the dict. However, if we're using listings
# to search for multiple packages, this will likely be faster.
# Have to look at how it's being used in production and decide
# what to do.
'listings2':
relation(PackageListing,
backref=backref('collection'),
collection_class=attribute_mapped_collection('packagename')),
'repos':
relation(Repo, backref=backref('collection'))
})
mapper(Branch,
BranchTable,
inherits=Collection,
inherit_condition=CollectionJoin.c.id == BranchTable.c.collectionid,
polymorphic_identity='b')
class Order(object):
"""
A Facebook order.
"""
def destroy(self):
session.delete(self)
########################################################################
# Set up mappers between identity tables and classes.
mapper(Visit, visit_table)
mapper(VisitIdentity, visit_identity_table,
properties={
'users': relation(User, backref='visit_identity'),
})
# TODO: user.cities property
mapper(User, user_table,
properties={
'_password': user_table.c.password,
'cities': relation(City),
'orders': relation(Order),
})
mapper(City, city_table,
'schema_changes', metadata,
Column('id', Integer, primary_key=True, autoincrement=True),
Column('major', Integer), Column('minor', Integer),
Column('point', Integer), Column('branch', String(64), default='main'),
Column('name', String(255)), Column('date_applied', DateTime))
class SchemaChange(object):
def __init__(self, **keys):
if keys:
self.major = keys['major']
self.minor = keys['minor']
self.point = keys['point']
self.branch = keys['branch']
self.name = keys['name']
self.date_applied = datetime.today()
def __str__(self):
return str(self.__dict__)
__repr__ = __str__
pass
mapper(SchemaChange,
schema_changes,
order_by=[
schema_changes.c.major, schema_changes.c.minor,
schema_changes.c.point
])
pass
class BatchJob(object):
def __init__(self, data, hw_uuid, added):
self.data = data
self.hw_uuid = hw_uuid
self.added = added
self.arrival = text('NOW()')
mapper(Host,
hosts,
properties=dict(_devices=relation(HostLink,
cascade="all,delete-orphan",
backref=backref('host'),
lazy=None),
devices=relation(HostLink, cascade='all,delete-orphan'),
fas_account=relation(FasLink, uselist=False),
file_systems=relation(FileSystem, backref='host')))
mapper(HostArchive, hosts_archive)
mapper(ComputerLogicalDevice,
computer_logical_devices,
properties={
"_host_links":
relation(HostLink,
cascade="all,delete-orphan",
backref=backref('device'),
lazy=None),
# We cascade deletes from Album to AlbumSim and Artist to ArtistSim
# but we currently do not cascade deletes from Artist to Track nor Artist to Album...
# We do cascade from Album to Track but
# IMPORTANT
# We *do* allow tracks to exist without an associated album or artist. Is that a good idea? I dunno...
# Here we set up a trigger to call Track.delete_related_files()
class DeleteFileMapperExtension(MapperExtension) :
def after_delete(self,mapper,connection,instance) :
instance._delete_related_files()
mapper(Track,track, extension=DeleteFileMapperExtension(),
properties={
'artists':relation(Artist,secondary=artist_track,lazy=True),
'albums':relation(Album,secondary=album_track,lazy=True), #this causes all sorts of headaches, cascade='delete-orphan'),
}
)
mapper(Artist,artist,
properties={'albums':relation(Album,secondary=album_artist),
'tracks':relation(Track,secondary=artist_track, order_by=Track.title, cascade='all,delete'), #removed delete-orphan
}
)
mapper(ArtistTrack,artist_track)
mapper(Album,album,
properties={'artists':relation(Artist,secondary=album_artist),
'tracks':relation(Track,secondary=album_track,order_by=Track.tracknum, cascade='all,delete'), #removed delete-orphan
'recommend':relation(Mbalbum_recommend, backref='album',cascade='all,delete,delete-orphan'),
'status':relation(AlbumStatus,backref='album',cascade='all,delete,delete-orphan')
def setup_module():
global fresh_metadata, users_table, test_table, Person, Address, Test
config.update({"sqlalchemy.dburi": "sqlite:///:memory:"})
if os.path.exists('freshtest.db'):
os.unlink('freshtest.db')
get_engine()
fresh_metadata = MetaData()
# :memory: can't be used in multiple threads
fresh_metadata.bind = 'sqlite:///freshtest.db'
metadata.bind.echo = True
fresh_metadata.bind.echo = True
users_table = Table("users", metadata,
Column("user_id", Integer, primary_key=True),
Column("user_name", String(40)),
Column("password", String(10)))
mapper(User, users_table)
if ActiveMapper:
class Person(ActiveMapper):
class mapping:
id = column(Integer, primary_key=True)
name = column(String(40))
addresses = one_to_many("Address")
class Address(ActiveMapper):
class mapping:
id = column(Integer, primary_key=True)
address = column(String(40))
city = column(String(40))
person_id = column(Integer,
foreign_key=ForeignKey("person.id"))
else:
persons_table = Table("persons", metadata,
Column("id", Integer, primary_key=True),
Column("name", String(40)))
addresses_table = Table(
"addresses", metadata, Column("id", Integer, primary_key=True),
Column("address", String(40)), Column("city", String(40)),
Column("person_id", Integer, ForeignKey(persons_table.c.id)))
class Person(object):
pass
class Address(object):
pass
mapper(Person, persons_table)
mapper(Address,
addresses_table,
properties=dict(person=relation(Person, backref='addresses')))
test_table = Table("test", fresh_metadata,
Column("id", Integer, primary_key=True),
Column("val", String(40)))
class Test(object):
pass
mapper(Test, test_table)
try:
metadata.create_all()
fresh_metadata.create_all()
except Exception, error:
# workaround for a problem with PySqlite < 2.6 and SQLAlchemy < 0.5
if 'Cannot operate on a closed cursor' in str(error):
metadata.create_all(checkfirst=False)
fresh_metadata.create_all(checkfirst=False)
else:
raise
# pylint: disable-msg=R0903
def __init__(self, acl, statuscode=None, grouppackagelistingid=None):
# pylint: disable-msg=R0913
super(GroupPackageListingAcl, self).__init__()
self.grouppackagelistingid = grouppackagelistingid
self.acl = acl
self.statuscode = statuscode
def __repr__(self):
return 'GroupPackageListingAcl(%r, %r, grouppackagelistingid=%r)' % (
self.acl, self.statuscode, self.grouppackagelistingid)
#
# Mappers
#
mapper(PersonPackageListing, PersonPackageListingTable, properties={
'acls': relation(PersonPackageListingAcl),
'acls2': relation(PersonPackageListingAcl,
backref=backref('personpackagelisting'),
collection_class=attribute_mapped_collection('acl'))
})
mapper(GroupPackageListing, GroupPackageListingTable, properties={
'acls': relation(GroupPackageListingAcl),
'acls2': relation(GroupPackageListingAcl,
backref=backref('grouppackagelisting'),
collection_class=attribute_mapped_collection('acl'))
})
mapper(PersonPackageListingAcl, PersonPackageListingAclTable)
mapper(GroupPackageListingAcl, GroupPackageListingAclTable)
Column('assoc_type', String(64), nullable = False),
PrimaryKeyConstraint('server_url', 'handle'))
class SamadhiAssociation(object):
@classmethod
def get(cls, server_url, handle = None):
if handle is None:
return cls.query.filter_by(server_url = server_url).order_by(samadhi_associations_table.c.issued.desc())
return cls.query.filter_by(server_url = server_url, handle = handle).order_by(samadhi_associations_table.c.issued.desc())
@classmethod
def remove(cls, server_url, handle):
for a in cls.query.filter_by(server_url = server_url, handle = handle):
session.delete(a)
mapper(SamadhiAssociation, samadhi_associations_table)
samadhi_nonces_table = Table('samadhi_nonces', metadata,
Column('server_url', String(2048), nullable = False),
Column('timestamp', Integer, nullable = False),
Column('salt', String(40), nullable = False),
PrimaryKeyConstraint('server_url', 'timestamp', 'salt'))
class SamadhiNonce(object):
pass
mapper(SamadhiNonce, samadhi_nonces_table)
# Implement an OpenID "store", which is how the OpenID library stores
# persisent data. Here's the docs that describe it:
#
def setup_module():
global fresh_metadata, users_table, test_table, Person, Address, Test
config.update({
"sqlalchemy.dburi" : "sqlite:///:memory:"})
if os.path.exists('freshtest.db'):
os.unlink('freshtest.db')
get_engine()
fresh_metadata = MetaData()
# :memory: can't be used in multiple threads
fresh_metadata.bind = 'sqlite:///freshtest.db'
metadata.bind.echo = True
fresh_metadata.bind.echo = True
users_table = Table("users", metadata,
Column("user_id", Integer, primary_key=True),
Column("user_name", String(40)),
Column("password", String(10)))
mapper(User, users_table)
if ActiveMapper:
class Person(ActiveMapper):
class mapping:
id = column(Integer, primary_key=True)
name = column(String(40))
addresses = one_to_many("Address")
class Address(ActiveMapper):
class mapping:
id = column(Integer, primary_key=True)
address = column(String(40))
city = column(String(40))
person_id = column(Integer,
foreign_key=ForeignKey("person.id"))
else:
persons_table = Table("persons", metadata,
Column("id", Integer, primary_key=True),
Column("name", String(40)))
addresses_table = Table("addresses", metadata,
Column("id", Integer, primary_key=True),
Column("address", String(40)),
Column("city", String(40)),
Column("person_id", Integer,
ForeignKey(persons_table.c.id)))
class Person(object):
pass
class Address(object):
pass
mapper(Person, persons_table)
mapper(Address, addresses_table, properties=dict(
person=relation(Person, backref='addresses')))
test_table = Table("test", fresh_metadata,
Column("id", Integer, primary_key=True),
Column("val", String(40)))
class Test(object):
pass
mapper(Test, test_table)
try:
metadata.create_all()
fresh_metadata.create_all()
except Exception, error:
# workaround for a problem with PySqlite < 2.6 and SQLAlchemy < 0.5
if 'Cannot operate on a closed cursor' in str(error):
metadata.create_all(checkfirst=False)
fresh_metadata.create_all(checkfirst=False)
else:
raise
as used
"""
used = cls.query.filter_by(nonce=nonce).first()
if used is not None:
# This nonce was already used
return False
captcha = CaptchaNonce()
captcha.nonce = nonce
return True
#
# set up mappers between tables and classes
#
mapper(Session, SessionTable)
mapper(CaptchaNonce, CaptchaNonceTable)
#
# mappers for filtering roles
#
mapper(ApprovedRoles, ApprovedRolesSelect, properties={"group": relation(Groups, backref="approved_roles", lazy=False)})
mapper(
UnApprovedRoles,
UnApprovedRolesSelect,
properties={"group": relation(Groups, backref="unapproved_roles", lazy=False)},
)
#
# General Mappers
class VisitIdentity(SABase):
'''Associate a user with a visit cookie.
This allows users to log in to app.
'''
pass
class Session(SABase):
'''Session'''
pass
#
# set up mappers between tables and classes
#
mapper(Session, SessionTable)
#
# mappers for filtering roles
#
mapper(ApprovedRoles, ApprovedRolesSelect, properties = {
'group': relation(Groups, backref='approved_roles', lazy = False)
})
mapper(UnApprovedRoles, UnApprovedRolesSelect, properties = {
'group': relation(Groups, backref='unapproved_roles', lazy = False)
})
#
# General Mappers
#
# your data tables
# your_table = Table('yourtable', metadata,
# Column('my_id', Integer, primary_key=True)
# )
comics_table = Table('comic', metadata,
Column('comic_id', Integer, primary_key=True),
Column('comic_name', UnicodeText),
Column('created', DateTime, default=datetime.datetime.now),
Column('base_url', String(4092)),
Column('first_comic', Integer),
Column('start_on', DateTime, default=datetime.datetime.now),
)
# your model classes
# class YourDataClass(object):
# pass
class Comic(object):
pass
# set up mappers between your data tables and classes
# mapper(YourDataClass, your_table)
mapper(Comic, comics_table)
def __repr__(self):
return "<Week('%s', '%s')>" % (self.week_num, self.comments)
class Game(object):
def __init__(self, week, teams, scores):
self.week = week
self.teams = teams
self.scores = scores
def __repr__(self):
return "<Game('%s', '%s', '%s')>" % (
self.week, self.teams, self.scores
)
# mappers between data tables and classes
mapper(Team, teams_table)
mapper(Score, scores_table,
properties={
'team' : relation(
Team, backref='scores')
}
)
mapper(Week, weeks_table)
mapper(Game, games_table,
properties={
'week' : relation(
Week, backref='games'),
'scores' : relation(
Score, secondary=games_scores_table, backref='game'),
'teams' : relation(
Team, secondary=games_teams_table, backref='games'),
return 'CollectionPackage(id=%r, name=%r, version=%r,' \
' statuscode=%r, numpkgs=%r,' % (
self.id, self.name, self.version, self.statuscode, self.numpkgs)
#
# Mappers
#
mapper(Collection, CollectionJoin,
polymorphic_on=CollectionJoin.c.kind,
polymorphic_identity='c',
with_polymorphic='*',
properties={
# listings is deprecated. It will go away in 0.4.x
'listings': relation(PackageListing),
# listings2 is slower than listings. It has a front-end cost to
# load the data into the dict. However, if we're using listings
# to search for multiple packages, this will likely be faster.
# Have to look at how it's being used in production and decide
# what to do.
'listings2': relation(PackageListing,
backref=backref('collection'),
collection_class=attribute_mapped_collection('packagename')),
'repos': relation(Repo, backref=backref('collection'))
})
mapper(Branch, BranchTable, inherits=Collection,
inherit_condition=CollectionJoin.c.id==BranchTable.c.collectionid,
polymorphic_identity='b')
mapper(CollectionPackage, CollectionPackageTable)
mapper(Repo, ReposTable)
Column('old_id', Unicode(5)),
Column('year', Integer),
Column('have', Integer),
Column('rating', Integer),
Column('genre_id', Integer, ForeignKey("genres.genre_id")),
Column('atype', Integer),
Column('date', Date)
)
# set up mappers between your data tables and classes
# http://www.sqlalchemy.org/docs/05/mappers.html
# mapper(YourDataClass, your_table)
mapper(Artist, artists, properties={
'genre': relationship(Genre, backref='artist')
})
mapper(Genre, genres_table)
mapper(Album, albums_table, properties={
'artist': relationship(Artist, backref='album'),
'genre': relationship(Genre, backref='album')
})
# functions for populating the database
def bootstrap_model(clean=False):
"""Create all database tables and fill them with default data.
This function is run by the 'bootstrap' function from the command module.
By default it creates all database tables for your model.
@classmethod
def get(cls, server_url, handle=None):
if handle is None:
return cls.query.filter_by(server_url=server_url).order_by(
samadhi_associations_table.c.issued.desc())
return cls.query.filter_by(
server_url=server_url,
handle=handle).order_by(samadhi_associations_table.c.issued.desc())
@classmethod
def remove(cls, server_url, handle):
for a in cls.query.filter_by(server_url=server_url, handle=handle):
session.delete(a)
mapper(SamadhiAssociation, samadhi_associations_table)
samadhi_nonces_table = Table(
'samadhi_nonces', metadata,
Column('server_url', String(2048), nullable=False),
Column('timestamp', Integer, nullable=False),
Column('salt', String(40), nullable=False),
PrimaryKeyConstraint('server_url', 'timestamp', 'salt'))
class SamadhiNonce(object):
pass
mapper(SamadhiNonce, samadhi_nonces_table)
"""
return self._password
password = property(_get_password, _set_password)
class Permission(object):
"""
A relationship that determines what each Group can do
"""
pass
# set up mappers between identity tables and classes
mapper(Bid, bids_table)
mapper(SubBid,
sub_bids_table,
properties=dict(bids=relation(Bid, backref='sub_bids')))
mapper(Auction,
auctions_table,
properties=dict(members=relation(Member, backref='auctions')))
mapper(
AuctionItem,
auction_items_table,
properties=dict(auction_items=relation(Auction, backref='auction_items')))
mapper(Item,
hopefully have localizations in pkgdb.
Table -- Languages
'''
def __init__(self, name, shortname):
super(Language, self).__init__()
self.name = name
self.shortname = shortname
def __repr__(self):
return 'Language(%r, %r)' % (self.name, self.shortname)
@classmethod
def find(cls, language):
'''Returns a shortname after searching for both short and longname.
:arg name: a short or long Language name
'''
#pylint:disable-msg=E1101
return session.query(Language).filter(or_(Language.name==language,
Language.shortname==language
)).one()
#pylint:enable-msg=E1101
#
# Mappers
#
mapper(Language, LanguagesTable)
Column('people_id', Integer,
ForeignKey('people.id'),
unique=True))
class Show(object):
@classmethod
def by_name(cls, name):
return cls.query.filter_by(name=name).one()
pass
mapper(Show, shows_table,
properties= \
dict(group=relation(Groups, uselist=False, backref='show'),
owner=relation(People, backref='shows'),
user_signups=relation(People,
backref=backref('show', uselist=False),
secondary=user_signups_table)))
class ShowPlugin(controllers.Controller):
capabilities = ['show_plugin']
def __init__(self):
'''Create a Show Controller.'''
self.path = ''
help = Help()
@expose(template="fas.templates.error")
def error(self, tg_errors=None):
'''Show a friendly error message'''
literal_column("'grouppkglistacllog'").label('kind'))),
'log':
select((LogTable, literal_column("'log'").label('kind')),
not_(
LogTable.c.id.in_(
select((LogTable.c.id, ), LogTable.c.id
== PackageListingLogTable.c.logid))))
}, None)
#
# Mappers
#
logMapper = mapper(Log,
LogTable,
select_table=logJoin,
polymorphic_on=logJoin.c.kind,
polymorphic_identity='log')
mapper(PersonPackageListingAclLog, PersonPackageListingAclLogTable,
inherits=logMapper, polymorphic_identity='personpkglistacllog',
inherit_condition=LogTable.c.id == \
PersonPackageListingAclLogTable.c.logid,
properties={
'acl': relation(PersonPackageListingAcl, backref='logs')
})
mapper(GroupPackageListingAclLog, GroupPackageListingAclLogTable,
inherits=logMapper, polymorphic_identity='grouppkglistacllog',
inherit_condition=LogTable.c.id == \
GroupPackageListingAclLogTable.c.logid,
literal_column("'grouppkglistacllog'").label("kind"),
)
),
"log": select(
(LogTable, literal_column("'log'").label("kind")),
not_(LogTable.c.id.in_(select((LogTable.c.id,), LogTable.c.id == PackageListingLogTable.c.logid))),
),
},
None,
)
#
# Mappers
#
logMapper = mapper(Log, LogTable, select_table=logJoin, polymorphic_on=logJoin.c.kind, polymorphic_identity="log")
mapper(
PersonPackageListingAclLog,
PersonPackageListingAclLogTable,
inherits=logMapper,
polymorphic_identity="personpkglistacllog",
inherit_condition=LogTable.c.id == PersonPackageListingAclLogTable.c.logid,
properties={"acl": relation(PersonPackageListingAcl, backref="logs")},
)
mapper(
GroupPackageListingAclLog,
GroupPackageListingAclLogTable,
inherits=logMapper,
polymorphic_identity="grouppkglistacllog",
)
users_table = Table('tg_user', metadata,
Column('user_id', Integer, primary_key=True),
Column('user_name', Unicode(16), unique=True),
Column('email_address', Unicode(255), unique=True),
Column('display_name', Unicode(255)),
Column('password', Unicode(40)),
Column('created', DateTime, default=datetime.now)
)
user_group_table = Table('user_group', metadata,
Column('user_id', Integer, ForeignKey('tg_user.user_id')),
Column('group_id', Integer, ForeignKey('tg_group.group_id'))
)
class User(object):
def __repr__(self):
return "class User user_id=%s email_address=%s display_name=%s" % (
self.user_id, self.email_address, self.display_name)
class Group(object):
pass
gmapper = database.mapper(Group, groups_table)
umapper = database.mapper(User, users_table, properties=dict(
groups = relation(Group, secondary=user_group_table, backref='users')
)
)
# your data tables
# your_table = Table('yourtable', metadata,
# Column('my_id', Integer, primary_key=True)
# )
servers_table = Table('servers', metadata,
Column('id', Integer, primary_key=True),
Column('tag', Integer),
Column('name', Unicode),
Column('description', Unicode),
Column('date_created', DateTime, default=datetime.now),
Column('last_modified', DateTime, default=datetime.now),
Column('physical_id', Integer, ForeignKey('servers.id'))
)
# your model classes
# class YourDataClass(object):
# pass
class Server(object):
pass
# set up mappers between your data tables and classes
# mapper(YourDataClass, your_table)
mapper(Server, servers_table,
properties=dict(physicals=relation(Server, backref='servers')))
"""
return self._password
password = property(_get_password, _set_password)
class Permission(object):
"""
A relationship that determines what each Group can do
"""
pass
# set up mappers between identity tables and classes
mapper(Bid, bids_table)
mapper(SubBid, sub_bids_table,
properties=dict(bids=relation(Bid, backref='sub_bids')))
mapper(Auction, auctions_table,
properties=dict(members=relation(Member, backref='auctions')))
mapper(AuctionItem, auction_items_table,
properties=dict(auction_items=relation(Auction, backref='auction_items')))
mapper(Item, items_table,
properties=dict(members=relation(Member, backref='items')))
mapper(ItemHistory, item_history_table,
properties=dict(items=relation(Item, backref='item_history')))
