class Theme(TreeGroup):
__label__ = _(u"Theme")
__plural__ = _(u"Themes")
__tablename__ = "theme"
__table_args__ = {"schema": _schema}
__acl__ = [
(Allow, AUTHORIZED_ROLE, ALL_PERMISSIONS),
]
__mapper_args__ = {"polymorphic_identity": "theme"}
id = Column(Integer,
ForeignKey(_schema + ".treegroup.id"),
primary_key=True)
ordering = Column(Integer, nullable=False, label=_(u"Order"))
public = Column(Boolean, default=True, nullable=False, label=_(u"Public"))
icon = Column(Unicode, label=_(u"Icon"))
# functionality
functionalities = relationship("Functionality",
secondary=theme_functionality,
cascade="save-update,merge,refresh-expire")
# restricted to role
restricted_roles = relationship(
"Role",
secondary=restricted_role_theme,
cascade="save-update,merge,refresh-expire",
)
def __init__(self, name=u"", ordering=100, icon=u""):
TreeGroup.__init__(self, name=name)
self.ordering = ordering
self.icon = icon
class LayerGroup(TreeGroup):
__label__ = _(u"Layer Group")
__plural__ = _(u"Layer Groups")
__tablename__ = "layergroup"
__table_args__ = {"schema": _schema}
__acl__ = [
(Allow, AUTHORIZED_ROLE, ALL_PERMISSIONS),
]
__mapper_args__ = {"polymorphic_identity": "group"}
id = Column(Integer,
ForeignKey(_schema + ".treegroup.id"),
primary_key=True)
is_expanded = Column(Boolean,
label=_(u"Expanded")) # shouldn"t be used in V3
is_internal_wms = Column(Boolean, label=_(u"Internal WMS"))
# children have radio button instance of check box
is_base_layer = Column(
Boolean, label=_(u"Group of base layers")) # Shouldn't be used in V3
def __init__(self,
name=u"",
is_expanded=False,
is_internal_wms=True,
is_base_layer=False):
TreeGroup.__init__(self, name=name)
self.is_expanded = is_expanded
self.is_internal_wms = is_internal_wms
self.is_base_layer = is_base_layer
class Tag(Base, BaseModel):
__tablename__ = 'tag'
id = Column(Integer, primary_key=True)
name = Column(Unicode, nullable=False, unique=True, label=u'Descrição')
def __init__(self, name=None):
self.name = name
def __unicode__(self):
return self.name
@classmethod
def _configure_grid(cls, grid):
grid.configure(
readonly=True,
exclude=[
grid.posts,
],
)
grid.add_operations('tag')
@classmethod
def _configure_form(cls, form):
form.configure(exclude=[
form.posts,
], )
class TreeItem(Base):
__tablename__ = "treeitem"
__table_args__ = {"schema": _schema}
__acl__ = [DENY_ALL]
item_type = Column("type", String(10), nullable=False)
__mapper_args__ = {"polymorphic_on": item_type}
id = Column(Integer, primary_key=True)
name = Column(Unicode, label=_(u"Name"))
metadata_url = Column(Unicode,
label=_(u"Metadata URL")) # shouldn't be used in V2
@property
def parents(self): # pragma: nocover
return [c.group for c in self.parents_relation]
def is_in_interface(self, name):
if not hasattr(self, "interfaces"): # pragma: nocover
return False
for interface in self.interfaces:
if interface.name == name:
return True
return False
def __init__(self, name=u""):
self.name = name
def __unicode__(self):
return self.name or u"" # pragma: nocover
class Dimension(Base):
__label__ = _(u"Dimension")
__plural__ = _(u"Dimensions")
__tablename__ = "dimension"
__table_args__ = {"schema": _schema}
__acl__ = [
(Allow, AUTHORIZED_ROLE, ALL_PERMISSIONS),
]
id = Column(Integer, primary_key=True)
name = Column(Unicode, label=_(u"Name"))
value = Column(Unicode, label=_(u"Value"))
description = Column(Unicode, label=_(u"Description"))
layer_id = Column("layer_id",
Integer,
ForeignKey(_schema + ".layer.id"),
nullable=False)
layer = relationship(
"DimensionLayer",
backref=backref(
"dimensions",
cascade="save-update,merge,delete,delete-orphan",
),
)
def __init__(self, name="", value="", layer=None):
self.name = name
self.value = value
self.layer = layer
def __unicode__(self): # pragma: no cover
return self.name or u""
class Metadata(Base):
__label__ = _(u"Metadata")
__plural__ = _(u"Metadatas")
__tablename__ = "metadata"
__table_args__ = {"schema": _schema}
__acl__ = [
(Allow, AUTHORIZED_ROLE, ALL_PERMISSIONS),
]
id = Column(Integer, primary_key=True)
name = Column(Unicode, label=_(u"Name"))
value = Column(Unicode, label=_(u"Value"))
description = Column(Unicode, label=_(u"Description"))
item_id = Column("item_id",
Integer,
ForeignKey(_schema + ".treeitem.id"),
nullable=False)
item = relationship(
"TreeItem",
backref=backref(
"metadatas",
cascade="save-update,merge,delete,delete-orphan",
),
)
def __init__(self, name="", value=""):
self.name = name
self.value = value
def __unicode__(self): # pragma: no cover
return u"%s: %s" % (self.name or u"", self.value or u"")
class RoutingStats(Base):
__table_args__ = ({'schema': 'geov3_stats', 'autoload': False})
__tablename__ = 'routing'
id = Column(Integer, primary_key=True)
date = Column(DateTime, default=datetime.datetime.now)
transport_mode = Column(Integer)
transport_criteria = Column(Integer)
class RestrictionArea(Base):
__label__ = _(u'restrictionarea')
__plural__ = _(u'restrictionareas')
__tablename__ = 'restrictionarea'
__table_args__ = {'schema': _schema}
__acl__ = [
(Allow, AUTHORIZED_ROLE, ALL_PERMISSIONS),
]
id = Column(types.Integer, primary_key=True)
area = GeometryColumn(Polygon(srid=_srid))
name = Column(types.Unicode, label=_(u'Name'))
description = Column(types.Unicode, label=_(u'Description'))
readwrite = Column(types.Boolean, label=_(u'Read-write mode'), default=False)
# relationship with Role and Layer
roles = relationship(
'Role', secondary=role_ra,
backref='restrictionareas', cascade='save-update,merge,refresh-expire')
layers = relationship(
'Layer', secondary=layer_ra,
backref='restrictionareas', cascade='save-update,merge,refresh-expire')
def __init__(self, name='', description='', layers=[], roles=[],
area=None, readwrite=False):
self.name = name
self.description = description
self.layers = layers
self.roles = roles
self.area = area
self.readwrite = readwrite
def __unicode__(self):
return self.name or u'' # pragma: nocover
class Auction(Base):
__label__ = 'Veiling' # label used in UI
__plural__ = 'Veilingen' # plural used in UI
__tablename__ = 'auctions'
__mapper_args__ = {'polymorphic_identity': 'auction'}
cid = Column(Integer, primary_key=True)
catentry_cid = Column(Integer, ForeignKey('catalogentries.cid'))
auctiontype_cid = Column(Integer, ForeignKey('auctiontypes.cid'),
label='AuctionType (autocomplete: typ de eerste letter)')
url = Column(String(2048), label='URL')
image = Column(String(2048), label='Foto (absolute url naar de afbeelding)')
title = Column(Unicode)
openprice = Column(Integer, label="Startbod")
start_time = Column(DateTime)
end_time = Column(DateTime)
auct_intro = Column(Text, label="Veiling intro tekst",)
auctiontype = relationship("AuctionType",
backref=backref('ezine_auctions',
order_by=cid))
catentry = relationship("CatalogEntry",
cascade='all, delete-orphan',
backref=backref('auctions', order_by=cid))
reltags = relationship("RelTag",
secondary=assoc_table_reltags_auctions)
def __unicode__(self):
return ' | '.join( (str(self.cid), self.title) )
"""
class LuxPrintJob(Base):
__tablename__ = 'lux_print_job'
__table_args__ = {'schema': _schema}
id = Column(String, primary_key=True)
spec = Column(Unicode)
creation = Column(DateTime)
class LayerGroup(TreeGroup):
__label__ = _(u'layergroup')
__plural__ = _(u'layergroups')
__tablename__ = 'layergroup'
__table_args__ = {'schema': _schema}
__acl__ = [
(Allow, AUTHORIZED_ROLE, ALL_PERMISSIONS),
]
__mapper_args__ = {'polymorphic_identity': 'group'}
id = Column(types.Integer,
ForeignKey(_schema + '.treegroup.id'),
primary_key=True)
isExpanded = Column(types.Boolean, label=_(u'Expanded'))
isInternalWMS = Column(types.Boolean, label=_(u'Internal WMS'))
# children have radio button instance of check box
isBaseLayer = Column(types.Boolean, label=_(u'Group of base layers'))
def __init__(self,
name=u'',
order=100,
isExpanded=False,
isInternalWMS=True,
isBaseLayer=False):
TreeGroup.__init__(self, name=name, order=order)
self.isExpanded = isExpanded
self.isInternalWMS = isInternalWMS
self.isBaseLayer = isBaseLayer
class OTOParent(Base):
__tablename__ = 'one_to_one_parent'
id = Column(Integer, primary_key=True)
oto_child_id = Column(Integer,
ForeignKey('one_to_one_child.id'),
nullable=False)
child = relation(OTOChild, uselist=False)
class Interface(Base):
__label__ = _(u"Interface")
__plural__ = _(u"Interfaces")
__tablename__ = "interface"
__table_args__ = {"schema": _schema}
__acl__ = [
(Allow, AUTHORIZED_ROLE, ALL_PERMISSIONS),
]
id = Column(Integer, primary_key=True)
name = Column(Unicode, label=_(u"Name"))
description = Column(Unicode, label=_(u"Description"))
# relationship with Layer and Theme
layers = relationship("Layer",
secondary=interface_layer,
backref="interfaces",
cascade="save-update,merge,refresh-expire")
theme = relationship("Theme",
secondary=interface_theme,
backref="interfaces",
cascade="save-update,merge,refresh-expire")
def __init__(self, name="", description=""):
self.name = name
self.description = description
def __unicode__(self): # pragma: no cover
return self.name or u""
class User(Base):
__tablename__ = 'todo_user'
__admin_args__ = {'alias': u'用户表'}
id = Column(Integer, primary_key=True)
uid = Column(Integer)
todo = Column(Text, nullable=False, label=u'内容')
dt = Column(DateTime, default=func.now(), label=u'日期')
class Connections(Base):
__table_args__ = ({'schema': 'geov3_stats', 'autoload': False})
__tablename__ = 'connections'
id = Column(Integer, primary_key=True)
ip = Column(String)
action = Column(String)
login = Column(String)
application = Column(String)
class PagDownload(Base):
__table_args__ = ({'schema': 'geov3_stats', 'autoload': False})
__tablename__ = 'pag_download'
objectids = Column(String, primary_key=True)
download_date = Column(DateTime,
default=datetime.datetime.now,
primary_key=True)
download_link = Column(String, primary_key=True)
class OrderUser(Base):
__tablename__ = 'order_users'
user_id = Column(Integer, ForeignKey('users.id'), primary_key=True)
order_id = Column(Integer, ForeignKey('orders.id'), primary_key=True)
user = relation(User)
order = relation(Order)
def __repr__(self):
return 'OrderUser(%s, %s)' % (self.user_id, self.order_id)
class NaturalUser(Base):
__tablename__ = 'natural_users'
email = Column(Unicode(40), primary_key=True)
password = Column(Unicode(20), nullable=False)
name = Column(Unicode(30))
orders = relation(NaturalOrder, backref='user')
def __repr__(self):
return self.name
class LuxMeasurementLoginCommune(Base):
__label__ = _(u"Allowed measurement for a user")
__tablename__ = "lux_measurement_login_commune"
__table_args__ = {"schema": _schema}
__acl__ = [
(Allow, AUTHORIZED_ROLE, ALL_PERMISSIONS),
]
login = Column(String, primary_key=True)
num_commune = Column(String, primary_key=True)
class Recursive(Base):
__tablename__ = 'recursives'
id = Column(Integer, primary_key=True)
foo = Column(Text, nullable=True)
parent_id = Column(Integer, ForeignKey("recursives.id"))
parent = relation('Recursive',
primaryjoin=parent_id == id,
uselist=False,
remote_side=parent_id)
class Like(Base):
__tablename__ = 'like'
__admin_args__ = {
'alias': u'喜欢表',
}
lid = Column(Integer, primary_key=True)
uid = Column(Integer, label=u'谁喜欢')
uid2 = Column(Integer, label=u'被喜欢')
class LuxPrintServers(Base):
__tablename__ = 'lux_print_servers'
__table_args__ = {'schema': _schema}
__acl__ = [
(Allow, AUTHORIZED_ROLE, ALL_PERMISSIONS),
]
id = Column(String, primary_key=True)
url = Column(Unicode)
creation = Column(DateTime)
class LuxPredefinedWms(Base):
__tablename__ = 'lux_predefined_wms'
__table_args__ = {'schema': _schema}
__acl__ = [
(Allow, AUTHORIZED_ROLE, ALL_PERMISSIONS),
]
id = Column(String, primary_key=True)
url = Column(Unicode, unique=True, label=_(u"Url"))
label = Column(Unicode)
class OrderUserTag(Base):
__table__ = Table(
'order_user_tags', Base.metadata,
Column('id', Integer, primary_key=True),
Column('user_id', Integer, nullable=False),
Column('order_id', Integer, nullable=False),
Column('tag', String, nullable=False),
ForeignKeyConstraint(['user_id', 'order_id'],
['order_users.user_id', 'order_users.order_id']))
order_user = relation(OrderUser)
class NaturalOrder(Base):
__tablename__ = 'natural_orders'
id = Column(Integer, primary_key=True)
user_email = Column(String,
ForeignKey('natural_users.email'),
nullable=False)
quantity = Column(Integer, nullable=False)
def __repr__(self):
return 'Quantity: %s' % self.quantity
class OTOChild(Base):
__tablename__ = 'one_to_one_child'
id = Column(Integer, primary_key=True)
baz = Column(Text, nullable=False)
def __unicode__(self):
return self.baz
def __repr__(self):
return '<OTOChild %s>' % self.baz
class LuxDownloadUrl(Base):
__label__ = _(u"Base url for download")
__tablename__ = "lux_download_url"
__table_args__ = {"schema": _schema}
__acl__ = [
(Allow, AUTHORIZED_ROLE, ALL_PERMISSIONS),
]
id = Column(Integer, primary_key=True)
url = Column(Unicode, label=_(u"Url"))
protected = Column(Boolean, label=_(u"Only connected user can download"))
class OGCServer(Base):
__label__ = _(u"OGC server")
__plural__ = _(u"OGC servers")
__tablename__ = "ogc_server"
__table_args__ = {"schema": _schema}
__acl__ = [
(Allow, AUTHORIZED_ROLE, ALL_PERMISSIONS),
]
id = Column(Integer, primary_key=True)
name = Column(Unicode, label=_(u"Name"), nullable=False, unique=True)
description = Column(Unicode, label=_(u"Description"))
url = Column(Unicode, label=_(u"Base URL"), nullable=False)
url_wfs = Column(Unicode, label=_(u"WFS URL"))
type = Column(Enum(OGCSERVER_TYPE_MAPSERVER,
OGCSERVER_TYPE_QGISSERVER,
OGCSERVER_TYPE_GEOSERVER,
OGCSERVER_TYPE_OTHER,
native_enum=False),
nullable=False,
label=_(u"Server type"))
image_type = Column(Enum("image/jpeg", "image/png", native_enum=False),
nullable=False,
label=_(u"Image type"))
auth = Column(Enum(OGCSERVER_AUTH_NOAUTH,
OGCSERVER_AUTH_STANDARD,
OGCSERVER_AUTH_GEOSERVER,
native_enum=False),
nullable=False,
label=_(u"Authentication type"))
wfs_support = Column(Boolean, label=_(u"WFS support"))
is_single_tile = Column(Boolean, label=_(u"Single tile"))
def __init__(self,
name="",
description=None,
url="https://wms.example.com",
url_wfs=None,
type=u"mapserver",
image_type="image/png",
auth="Standard auth",
wfs_support=True,
is_single_tile=False):
self.name = name
self.description = description
self.url = url
self.url_wfs = url_wfs
self.type = type
self.image_type = image_type
self.auth = auth
self.wfs_support = wfs_support
self.is_single_tile = is_single_tile
def __unicode__(self):
return self.name or u"" # pragma: no cover
class LuxMeasurementDirectory(Base):
__label__ = _(u"Surveying file config")
__tablename__ = "lux_measurement_directory"
__table_args__ = {"schema": _schema}
__acl__ = [
(Allow, AUTHORIZED_ROLE, ALL_PERMISSIONS),
]
id = Column(Integer, primary_key=True)
name = Column(String)
path = Column(String)
town_code = Column(Integer)
class Order(Base):
__tablename__ = 'orders'
id = Column(Integer, primary_key=True)
user_id = Column(Integer, ForeignKey('users.id'), nullable=False)
quantity = Column(Integer, nullable=False)
def __unicode__(self):
return 'Quantity: %s' % self.quantity
def __repr__(self):
return '<Order for user %s: %s>' % (self.user_id, self.quantity)
