class DeclEnumType(SchemaType, TypeDecorator):
def __init__(self, enum):
self.enum = enum
# convert CamelCase to underscore_separated
name = re.sub('.([A-Z])', lambda m: '_' + m.group(1).lower(),
enum.__name__).lower()
self.impl = Enum(*enum.values(), name=name)
def _set_table(self, table, column):
self.impl._set_table(table, column)
def copy(self):
return DeclEnumType(self.enum)
def process_bind_param(self, value, dialect):
if value is None:
return None
if isinstance(value, basestring):
return value
if value.cls_ != self.enum:
raise TypeError('Cannot use %r as bind parameter for column '
'of type %r' % (value, self.enum))
return value.value
def process_result_value(self, value, dialect):
if value is None:
return None
return self.enum.from_string(value.strip())
class LayerExternalWMS(Layer):
__label__ = _(u"External WMS layer")
__plural__ = _(u"External WMS layers")
__tablename__ = "layer_external_wms"
__table_args__ = {"schema": _schema}
__acl__ = [
(Allow, AUTHORIZED_ROLE, ALL_PERMISSIONS),
]
__mapper_args__ = {"polymorphic_identity": "l_ext_wms"}
id = Column(Integer, ForeignKey(_schema + ".layer.id"), primary_key=True)
url = Column(Unicode, label=_(u"Base URL"))
layer = Column(Unicode, label=_(u"Layers"))
image_type = Column(Enum("image/jpeg", "image/png", native_enum=False),
label=_(u"Image type"))
style = Column(Unicode, label=_(u"Style"))
is_single_tile = Column(Boolean, label=_(u"Single tile"))
time_mode = Column(Enum("disabled", "single", "range", native_enum=False),
default="disabled",
nullable=False,
label=_(u"Time mode"))
time_widget = Column(Enum("slider", "datepicker", native_enum=False),
default="slider",
nullable=True,
label=_(u"Time widget"))
def __init__(self, name=u"", public=True):
Layer.__init__(self, name=name, public=public)
class DeclEnumType(SchemaType, TypeDecorator):
"""DeclEnum augmented so that it can persist to the database."""
def __init__(self, enum):
self.enum = enum
self.impl = Enum(*enum.names(),
name="ck%s" %
re.sub('([A-Z])', lambda m: '_' + m.group(1).lower(),
enum.__name__))
def drop(self, bind=None, checkfirst=False):
return "DROP {} IF EXISTSZZ".format("ck%s" % re.sub(
'([A-Z])', lambda m: '_' + m.group(1).lower(), self.enum.__name__))
def _set_table(self, table, column):
self.impl._set_table(table, column)
def copy(self):
return DeclEnumType(self.enum)
def process_bind_param(self, value, dialect):
if isinstance(value, EnumSymbol):
value = value.name
return value
def process_result_value(self, value, dialect):
if value is not None:
return getattr(self.enum, value.strip())
def __init__(self, enum, name=None, default=None):
self.enum = enum
if name is None:
self.impl = Enum(*enum.values(),
name='RUCIO_ENUM_' + str(uuid.uuid4())[:6])
else:
self.impl = Enum(*enum.values(), name=name)
class IntegrityMetrics(Base):
"""."""
__tablename__ = "integrity"
integrity_id = Column("integrity_id", KeyInteger, primary_key=True)
wf_id = Column(
"wf_id",
KeyInteger,
ForeignKey(Workflow.wf_id, ondelete="CASCADE"),
nullable=False,
)
job_instance_id = Column(
"job_instance_id",
KeyInteger,
ForeignKey(JobInstance.job_instance_id, ondelete="CASCADE"),
nullable=False,
)
type = Column("type",
Enum("check", "compute", name="integrity_type_desc"),
nullable=False)
file_type = Column(
"file_type", Enum("input", "output", name="integrity_file_type_desc"))
count = Column("count", Integer, nullable=False)
duration = Column("duration", DurationType, nullable=False)
def __init__(self, enum, **kwargs):
super(DeclEnumType, self).__init__(**kwargs)
self.enum = enum
self.impl = Enum(*list(enum.values()),
name="ck%s" %
re.sub('([A-Z])', lambda m: "_" + m.group(1).lower(),
enum.__name__))
class Enum(SchemaType, TypeDecorator):
def __init__(self, enum):
name = re.sub('([A-Z])', lambda m:"_" + m.group(1).lower(),
enum.__name__)
self.enum = enum
self.impl = SaEnum(*enum.values(), name="ck%s" % name)
def _set_table(self, table, column):
self.impl._set_table(table, column)
def copy(self):
return Enum(self.enum)
def process_bind_param(self, value, dialect):
if value is None:
return None
return value.value
def process_result_value(self, value, dialect):
if value is None:
return None
return self.enum.from_string(value.strip())
def create(self, bind=None, checkfirst=False):
super(Enum, self).create(bind, checkfirst)
t = self.dialect_impl(bind.dialect)
if t.impl.__class__ is not self.__class__ and isinstance(t, SchemaType):
t.impl.create(bind=bind, checkfirst=checkfirst)
class DeclEnumType(SchemaType, TypeDecorator):
def __init__(self, enum):
self.enum = enum
self.impl = Enum(*enum.values(),
name="ck%s" %
re.sub('([A-Z])', lambda m: "_" + m.group(1).lower(),
enum.__name__))
def _set_table(self, table, column):
self.impl._set_table(table, column)
def copy(self):
return DeclEnumType(self.enum)
def process_bind_param(self, value, dialect):
if value is None:
return None
return value.value
def process_result_value(self, value, dialect):
if value is None:
return None
return self.enum.from_string(value.strip())
def create(self, bind=None, checkfirst=False):
"""Issue CREATE ddl for this type, if applicable."""
super(DeclEnumType, self).create(bind, checkfirst)
t = self.dialect_impl(bind.dialect)
if t.impl.__class__ is not self.__class__ and isinstance(
t, SchemaType):
t.impl.create(bind=bind, checkfirst=checkfirst)
class DeclEnumType(SchemaType, TypeDecorator):
def __init__(self, enum):
self.enum = enum
# convert CamelCase to underscore_separated
name = re.sub('.([A-Z])', lambda m: '_' + m.group(1).lower(), enum.__name__).lower()
self.impl = Enum(*enum.values(), name=name)
def _set_table(self, table, column):
self.impl._set_table(table, column)
def copy(self):
return DeclEnumType(self.enum)
def process_bind_param(self, value, dialect):
if value is None:
return None
if isinstance(value, basestring):
return value
if value.cls_ != self.enum:
raise TypeError('Cannot use %r as bind parameter for column '
'of type %r' % (value, self.enum))
return value.value
def process_result_value(self, value, dialect):
if value is None:
return None
return self.enum.from_string(value.strip())
class EnumType(SchemaType, TypeDecorator):
def __init__(self, enum):
self.enum = enum
self.impl = SAEnum(
*[sym.value for sym in enum],
name="enum%s" % re.sub(
'([A-Z])', lambda m: "_" + m.group(1).lower(), enum.__name__))
def _set_table(self, table, column):
self.impl._set_table(table, column)
def copy(self):
return EnumType(self.enum)
def process_bind_param(self, value, dialect):
if value is None:
return None
if isinstance(value, str):
return value
return value.value
def process_result_value(self, value, dialect):
if value is None:
return None
return self.enum(value.strip())
class DeclEnumType(SchemaType, TypeDecorator):
def __init__(self, enum):
self.enum = enum
self.impl = Enum(*enum.values(), name=to_underscore(enum.__name__))
def _set_table(self, table, column):
self.impl._set_table(table, column)
def copy(self):
return DeclEnumType(self.enum)
def process_bind_param(self, value, dialect):
if value is None:
return value
if isinstance(value, str):
return value
return value.value
def process_result_value(self, value, dialect):
if value is None:
return None
return self.enum.from_string(value.strip())
python_type = str
class Rune(Base):
__tablename__ = "runes"
runeType = Column(Enum(RuneID))
replayID = Column(BigInteger,
ForeignKey("Replays.replayID"),
primary_key=True)
id = Column(Integer, primary_key=True)
time = Column(Integer)
team = Column(Enum(Team), primary_key=True)
steamID = Column(BigInteger, ForeignKey(Player.steamID))
# Relationships
player = relationship(
Player,
lazy="select",
primaryjoin=
"and_(Rune.steamID == Player.steamID, Rune.replayID == Player.replayID)"
)
replay = relationship("Replay", back_populates="runes")
def __init__(self, replay_in):
self.replay = replay_in
self.replayID = replay_in.replayID
@hybrid_property
def game_time(self):
return self.time - self.replay.creepSpawn
@game_time.expression
def game_time(self):
from .Replay import Replay
creepSpawn = select([Replay.creepSpawn]).\
where(self.replayID == Replay.replayID).as_scalar()
return self.time - creepSpawn
class DeclarativeEnumType(SchemaType, TypeDecorator):
"""Column type usable in table column definitions."""
def __init__(self, enum):
self.enum = enum
constraint = 'ck{0}'.format(re.sub('([A-Z])',
lambda m: '_' + m.group(1).lower(),
enum.__name__))
self.impl = Enum(*enum.values(), name=constraint)
def _set_table(self, table, column):
self.impl._set_table(table, column)
def copy(self):
return DeclarativeEnumType(self.enum)
def process_bind_param(self, value, dialect):
if value is None: # pragma: no cover
return None
return value.value
def process_result_value(self, value, dialect):
if value is None: # pragma: no cover
return None
return self.enum.from_string(value.strip())
class DeclEnumType(SchemaType, TypeDecorator):
def __init__(self, enum):
self.enum = enum
self.impl = Enum(
*enum.values(),
name="ck%s" % re.sub(
'([A-Z])',
lambda m:"_" + m.group(1).lower(),
enum.__name__)
)
def _set_table(self, table, column):
self.impl._set_table(table, column)
def copy(self):
return DeclEnumType(self.enum)
def process_bind_param(self, value, dialect):
if value is None:
return None
return value.value
def process_result_value(self, value, dialect):
if value is None:
return None
return self.enum.from_string(value.strip())
def __init__(self, enum):
import re
self.enum = enum
self.impl = Enum(*enum.names(),
name="ck%s" %
re.sub('([A-Z])', lambda m: '_' + m.group(1).lower(),
enum.__name__))
class PhoneFunckey(Base):
__tablename__ = 'phonefunckey'
__table_args__ = (
PrimaryKeyConstraint('iduserfeatures', 'fknum'),
Index('phonefunckey__idx__exten', 'exten'),
Index('phonefunckey__idx__progfunckey', 'progfunckey'),
Index('phonefunckey__idx__typeextenumbers_typevalextenumbers', 'typeextenumbers', 'typevalextenumbers'),
Index('phonefunckey__idx__typeextenumbersright_typevalextenumbersright', 'typeextenumbersright', 'typevalextenumbersright'),
)
iduserfeatures = Column(Integer, nullable=False, autoincrement=False)
fknum = Column(Integer, nullable=False, autoincrement=False)
exten = Column(String(40))
typeextenumbers = Column(Enum('extenfeatures', 'featuremap', 'generalfeatures',
name='phonefunckey_typeextenumbers',
metadata=Base.metadata))
typevalextenumbers = Column(String(255))
typeextenumbersright = Column(Enum('agent', 'group', 'meetme', 'queue', 'user', 'paging',
name='phonefunckey_typeextenumbersright',
metadata=Base.metadata))
typevalextenumbersright = Column(String(255))
label = Column(String(32))
supervision = Column(Integer, nullable=False, server_default='0')
progfunckey = Column(Integer, nullable=False, server_default='0')
class DeclEnumType(SchemaType, TypeDecorator):
def __init__(self, enum, **kwargs):
super(DeclEnumType, self).__init__(**kwargs)
self.enum = enum
self.impl = Enum(
*enum.values(),
name="ck%s" % re.sub(
'([A-Z])',
lambda m:"_" + m.group(1).lower(),
enum.__name__)
)
def _set_table(self, column, table):
self.impl.name = "ck_%s_%s_%s" % (
'_'.join(table.schema.split('.')), table.name, self.impl.name[3:])
self.impl._set_table(column, table)
def copy(self, **kw):
return DeclEnumType(self.enum, **kw)
def process_bind_param(self, value, dialect):
if value is None:
return None
if isinstance(value, EnumSymbol):
return value.value
elif isinstance(value, (str, unicode)):
# Should not happen, but mask the error for now.
return value
def process_result_value(self, value, dialect):
if value is None:
return None
return self.enum.from_string(value.strip())
class Callerid(Base):
__tablename__ = 'callerid'
__table_args__ = (PrimaryKeyConstraint('type', 'typeval'), )
mode = Column(
Enum('prepend',
'overwrite',
'append',
name='callerid_mode',
metadata=Base.metadata))
callerdisplay = Column(String(80), nullable=False, server_default='')
type = Column(
Enum('callfilter',
'incall',
'group',
'queue',
name='callerid_type',
metadata=Base.metadata))
typeval = Column(Integer, nullable=False, autoincrement=False)
@hybrid_property
def name(self):
if self.callerdisplay == '':
return None
return self.callerdisplay
@name.setter
def name(self, value):
if value is None:
self.callerdisplay = ''
else:
self.callerdisplay = value
class DeclEnumType(SchemaType, TypeDecorator):
def __init__(self, enum, **kwargs):
super(DeclEnumType, self).__init__(**kwargs)
self.enum = enum
self.impl = Enum(*list(enum.values()),
name="ck%s" %
re.sub('([A-Z])', lambda m: "_" + m.group(1).lower(),
enum.__name__))
def _set_table(self, column, table):
self.impl.name = "ck_%s_%s_%s" % ('_'.join(
table.schema.split('.')), table.name, self.impl.name[3:])
self.impl._set_table(column, table)
def copy(self, **kw):
return DeclEnumType(self.enum, **kw)
def process_bind_param(self, value, dialect):
if value is None:
return None
if isinstance(value, EnumSymbol):
return value.value
elif isinstance(value, string_types):
# Should not happen, but mask the error for now.
return value
def process_result_value(self, value, dialect):
if value is None:
return None
return self.enum.from_string(value.strip())
class DeclEnumType(SchemaType, TypeDecorator):
def __init__(self, enum, **kwargs):
self.enum = enum
self.impl = Enum(*enum.values(),
name="ck%s" %
re.sub('([A-Z])', lambda m: "_" + m.group(1).lower(),
enum.__name__),
**kwargs)
super(DeclEnumType, self).__init__(**kwargs)
def _set_table(self, table, column):
self.impl._set_table(table, column)
def copy(self):
return DeclEnumType(self.enum)
def process_bind_param(self, value, dialect):
if value is None:
return None
return value.value
def process_result_value(self, value, dialect):
if value is None:
return None
return self.enum.from_string(value.strip())
def register_with_psycopg(self, conn):
import psycopg2.extensions
my_enum_array_oid = conn.execute(text(
"SELECT typarray FROM pg_catalog.pg_type "
"WHERE typname = :tn"),
tn=self.impl.name).scalar()
psycopg2.extensions.register_type(
psycopg2.extensions.new_array_type(
(my_enum_array_oid, ), self.impl.name + '[]', psycopg2.STRING))
class QueueMember(Base):
__tablename__ = 'queuemember'
__table_args__ = (
PrimaryKeyConstraint('queue_name', 'interface'),
UniqueConstraint('queue_name', 'channel', 'usertype', 'userid',
'category'),
Index('queuemember__idx__category', 'category'),
Index('queuemember__idx__channel', 'channel'),
Index('queuemember__idx__userid', 'userid'),
Index('queuemember__idx__usertype', 'usertype'),
)
queue_name = Column(String(128))
interface = Column(String(128))
penalty = Column(Integer, nullable=False, server_default='0')
commented = Column(Integer, nullable=False, server_default='0')
usertype = Column(Enum('agent',
'user',
name='queuemember_usertype',
metadata=Base.metadata),
nullable=False)
userid = Column(Integer, nullable=False)
channel = Column(String(25), nullable=False)
category = Column(Enum('queue',
'group',
name='queue_category',
metadata=Base.metadata),
nullable=False)
position = Column(Integer, nullable=False, server_default='0')
class t_ipsec(BaseModel):
__tablename__ = 't_ipsec'
id = Column(Integer, primary_key=True)
server_id = Column(Integer, index=True)
chain = Column(Enum('INPUT', 'OUTPUT', 'FORWARD'))
source_addr = Column(VARCHAR(50))
dest_addr = Column(VARCHAR(50))
protocal = Column(Enum('tcp', 'udp', 'icmp', 'all'))
dport = Column(VARCHAR(50))
#
status = Column(Integer)
description = Column(VARCHAR(100))
create_time = Column(DATETIME)
modify_time = Column(DATETIME)
def __init__(self,
server_id,
protocal,
source_addr,
dport,
description,
status=0,
chain='INPUT'):
self.chain = chain
self.server_id = server_id
self.chain = chain
self.source_addr = source_addr
self.protocal = protocal
self.dport = dport
self.status = status
self.description = description
self.create_time = datetime.datetime.now()
self.modify_time = datetime.datetime.now()
class Status(Base):
"""Representation of a logged status change."""
__tablename__ = 'Status'
__table_args__ = {'mysql_engine': 'InnoDB'}
OPEN = 'open'
CLOSED = 'closed'
AWAY = 'away'
timestamp = Column(DateTime, primary_key=True, default=datetime.now)
value = Column(
Enum(OPEN, CLOSED, AWAY),
nullable=False
)
modified_by = Column(Enum('BITS', 'web'), nullable=False)
def __init__(self, value, modified_by):
self.value = value
self.modified_by = modified_by
def __str__(self):
return 'Status {.value}'.format(self)
def jsondict(self, wrap=True):
"""Return a JSON-serializable dictionary representing the object"""
data = {
"timestamp": int(float(self.timestamp.strftime('%s.%f')) * 1000),
"modifiedby": self.modified_by,
"value": self.value
}
if wrap:
return {'status': data}
else:
return data
class EnumType(SchemaType, TypeDecorator):
def __init__(self, enum, name):
self.enum = enum
self.name = name
members = (member.value for member in enum)
kwargs = {'name': name}
self.impl = SAEnum(*members, **kwargs)
def _set_table(self, table, column):
self.impl._set_table(table, column)
def copy(self):
return EnumType(self.enum, self.name)
def process_bind_param(self, enum_instance, dialect):
if enum_instance is None:
return None
return enum_instance.value
def process_result_value(self, value, dialect):
if value is None:
return None
return self.enum(value)
class Job(Base):
__tablename__ = 'jobs'
job_id = Column(Integer(), primary_key=True)
title = Column(String(255), nullable=False)
company = Column(String(255))
region = Column(String(255), nullable=False)
city = Column(String(255), nullable=False)
country = Column(String(255), nullable=False)
job_type = Column(Enum(JobType), nullable=False)
description = Column(String(), nullable=False)
requirements = Column(String(), nullable=False)
posted_by = Column(String(100), nullable=False)
poster_family_name = Column(String(100), nullable=False)
poster_given_name = Column(String(100), nullable=False)
can_contact = Column(Boolean(), nullable=False)
people_contacted = Column(Integer(), default=0)
job_status = Column(Enum(JobStatus), nullable=False)
job_tags = Column(ARRAY(Enum(JobTags)), nullable=False)
salary = Column(Integer())
times_viewed = Column(Integer(), default=0)
deadline = Column(DateTime(), nullable=False)
created_on = Column(DateTime(), default=datetime.now)
updated_on = Column(DateTime(),
default=datetime.now,
onupdate=datetime.now)
job_applications = relationship("JobApplication")
class Certificate(Base):
__tablename__ = 'certificate'
id = Column(Integer # The key identifier
, primary_key=True)
Type = Column(Enum( 'CA' # sub-CA certificate
, 'Server' # Server certificate
, 'User' # User certificate
)
)
CommonName = Column(String) # Subject CN
OrganizationalUnit = Column(String) # Subject OU
Organization = Column(String) # Subject O
Location = Column(String) # Subject L
State = Column(String) # Subject S
Country = Column(String) # Subject CO
CSR = Column(String) # The certificate signing request PEM string
Certificate = Column(String) # The signed certificate PEM string
Status = Column(Enum( 'Waiting-For-Approval' # Certificate needs administrator approval
, 'Waiting-For-Signature' # Certificate is ready to be signed
, 'Waiting-For-Transmission' # Certificate is signed and is ready for transmission to the web interface
, 'Valid' # Certificate is valid
, 'Expired' # Certificate has expired
, 'Revoked-Unspecified' # From here on, only revocation reasons follow
, 'Revoked-KeyCompromise'
, 'Revoked-CACompromise'
, 'Revoked-AffiliationChanged'
, 'Revoked-Superseded'
, 'Revoked-CessationOfOperation'
, 'Revoked-CertificateHold'
)
)
class AccessRequest(Base):
__tablename__ = u'access_requests'
id = Column(UnicodeText, primary_key=True, default=make_uuid)
timestamp = Column(DateTime,
default=datetime.datetime.utcnow,
nullable=False)
user_id = Column(UnicodeText, nullable=False)
message = Column(UnicodeText, nullable=False)
role = Column(
Enum('member', 'editor', 'admin', name='access_request_role_enum'),
nullable=False,
)
status = Column(
Enum('requested',
'approved',
'rejected',
name='access_request_status_enum'),
default='requested',
nullable=False,
)
object_type = Column(
Enum('package',
'organization',
'user',
name='access_request_object_type_enum'),
nullable=False,
)
object_id = Column(UnicodeText, nullable=False)
data = Column(MutableDict.as_mutable(JSONB), nullable=True)
actioned_by = Column(
UnicodeText,
nullable=True) # user who approved or rejected the request
class Ranking(Base):
__tablename__ = "ranking"
id: int = Column(Integer, primary_key=True, autoincrement=True)
institution_id: int = Column(Integer, ForeignKey("institution.id"))
ranking_system: RankingSystemEnum = Column(
Enum(RankingSystemEnum), nullable=False, index=True
)
ranking_type: RankingTypeEnum = Column(
Enum(RankingTypeEnum), nullable=False, index=True
)
year: int = Column(Integer)
field: str = Column(String(255), nullable=False)
subject: str = Column(String(255), nullable=False)
metric: MetricEnum = Column(Enum(MetricEnum), nullable=False, index=True)
value: Decimal = Column(DECIMAL(13, 3))
value_type: ValueTypeEnum = Column(Enum(ValueTypeEnum), nullable=False)
# Relationships
institution: Institution = relationship(
"Institution", back_populates="rankings"
)
def __init__(self, **kwargs):
kwargs = {k: v for k, v in kwargs.items() if k in self.__table__.c}
super().__init__(**kwargs)
def __repr__(self):
return (
f"{self.ranking_system.name} ({self.year}) | "
+ f"{self.field} ({self.subject}) -> "
+ f"{self.metric.name}: {self.value}"
)
class EnumType(SchemaType, TypeDecorator):
def __init__(self, enum, name):
self.enum = enum
self.name = name
members = (member.value for member in enum)
kwargs = {'name': name}
self.impl = SAEnum(*members, **kwargs)
def _set_table(self, table, column):
self.impl._set_table(table, column)
def copy(self):
return EnumType(self.enum, self.name)
def process_bind_param(self, enum_instance, dialect):
if enum_instance is None:
return None
return enum_instance.value
def process_result_value(self, value, dialect):
if value is None:
return None
return self.enum(value)
class DeclarativeEnumType(SchemaType, TypeDecorator):
"""Column type usable in table column definitions."""
def __init__(self, enum, name=None):
self.enum = enum
enum_args = enum.__enum_args__.copy()
if name is not None:
enum_args['name'] = name
elif 'name' not in enum_args:
enum_args['name'] = 'ck_' + camelcase_to_underscore(enum.__name__)
self.impl = Enum(*enum.values(), **enum_args)
def _set_table(self, table, column):
self.impl._set_table(table, column)
def copy(self):
return DeclarativeEnumType(self.enum)
def process_bind_param(self, value, dialect):
if value is None: # pragma: no cover
return None
return value.value
def process_result_value(self, value, dialect):
if value is None: # pragma: no cover
return None
return self.enum.from_string(value.strip())
class EnumType(SchemaType, TypeDecorator):
def __init__(self, enum):
self.enum = enum
self.impl = SAEnum(
*[sym.value for sym in enum],
name="enum%s" % re.sub(
'([A-Z])',
lambda m: "_" + m.group(1).lower(),
enum.__name__)
)
def _set_table(self, table, column):
self.impl._set_table(table, column)
def copy(self):
return EnumType(self.enum)
def process_bind_param(self, value, dialect):
if value is None:
return None
if isinstance(value, str):
return value
return value.value
def process_result_value(self, value, dialect):
if value is None:
return None
return self.enum(value.strip())
class EnumType(SchemaType, TypeDecorator):
# pylint: disable=W0223
def __init__(self, enum, *args, **kwargs):
self.enum = enum
self.impl = SQLAEnum(
*enum.values(),
name="ck%s" % re.sub(
"([A-Z])",
lambda m: "_" + m.group(1).lower(),
enum.__name__))
super(EnumType, self).__init__(*args, **kwargs)
def _set_table(self, table, column):
# pylint: disable=W0212
self.impl._set_table(table, column)
def copy(self):
return EnumType(self.enum)
def process_bind_param(self, value, dialect):
if value is None:
return None
return value.value
def process_result_value(self, value, dialect):
if value is None:
return None
return self.enum.from_string(value.strip())
class DeclarativeEnumType(SchemaType, TypeDecorator):
"""Column type usable in table column definitions."""
def __init__(self, enum, name=None):
self.enum = enum
enum_args = enum.__enum_args__.copy()
if name is not None:
enum_args['name'] = name
elif 'name' not in enum_args:
enum_args['name'] = 'ck_' + camelcase_to_underscore(enum.__name__)
self.impl = Enum(*enum.values(), **enum_args)
def _set_table(self, table, column):
self.impl._set_table(table, column)
def copy(self):
return DeclarativeEnumType(self.enum)
def process_bind_param(self, value, dialect):
if value is None: # pragma: no cover
return None
return value.value
def process_result_value(self, value, dialect):
if value is None: # pragma: no cover
return None
return self.enum.from_string(value.strip())
class DeclEnumType(SchemaType, TypeDecorator):
"""
DeclEnumType supports object instantiation in two different ways:
Passing in an enum:
This is to be used in the application code. It will pull enum values straight from
the DeclEnum object. A helper for this is available in DeclEnum.db_type()
Passing in a tuple with enum values:
In migrations the enum value list needs to be fix. It should not be pulled in from
the application code, otherwise later modifications of enum values could result in
those values being added in an earlier migration when re-running migrations from the
beginning. Therefore DeclEnum(enum_values=('one', 'two'), enum_name='MyEnum') should
be used.
"""
def __init__(self, enum=None, enum_values=None, enum_name=None):
self.enum = enum
self.enum_values = enum_values
self.enum_name = enum_name
if enum:
self.enum_values=enum.values()
self.enum_name=enum.__name__
self.impl = Enum(
*self.enum_values,
name="ck%s" % re.sub(
'([A-Z])',
lambda m: "_" + m.group(1).lower(),
self.enum_name)
)
def create(self, bind=None, checkfirst=False):
"""Issue CREATE ddl for this type, if applicable."""
super(DeclEnumType, self).create(bind, checkfirst)
t = self.dialect_impl(bind.dialect)
if t.impl.__class__ is not self.__class__ and isinstance(t, SchemaType):
t.impl.create(bind=bind, checkfirst=checkfirst)
def _set_table(self, table, column):
self.impl._set_table(table, column)
def copy(self):
if self.enum:
return DeclEnumType(self.enum)
else:
return DeclEnumType(enum_name=self.enum_name, enum_values=self.enum_values)
def process_bind_param(self, value, dialect):
if value is None:
return None
return value.value
def process_result_value(self, value, dialect):
if value is None:
return None
return self.enum.from_string(value.strip())
class Item(Base):
__tablename__ = 'item'
id = Column(Integer, primary_key=True)
name = Column(String(64))
serial = Column(String(64), nullable=False, unique=True)
model_id = Column(Integer, ForeignKey('model.id'), nullable=False)
vendor_id = Column(Integer, ForeignKey('vendor.id'), nullable=False)
installed_id = Column(Integer, ForeignKey('item.id'))
installed_description = Column(String(32))
support = Column(Enum('None', 'on site', 'send back'), nullable=False)
support_end = Column(Date, default=datetime.datetime.now)
status = Column(Enum('in stock', 'in use', 'disposed'), nullable=False)
location_id = Column(Integer, ForeignKey('location.id'), nullable=False)
asset_number = Column(String(10))
settlement_number = Column(String(10))
delivery_date = Column(Date, default=datetime.datetime.now)
description = Column(String(256))
updated_at = Column(Date, onupdate=datetime.datetime.now)
#last_updated_by_id = Column(Integer, ForeignKey('user.id'))
model = relationship('Model', back_populates='items')
vendor = relationship('Vendor', back_populates='items')
location = relationship('Location', back_populates='items')
attachments = relationship('Item',
backref=backref('parent', remote_side=[id]))
class DeclEnumType(SchemaType, TypeDecorator):
def __init__(self, enum):
self.enum = enum
self.impl = Enum(
*enum.values(),
name="ck%s" % re.sub(
'([A-Z])',
lambda m: "_" + m.group(1).lower(),
enum.__name__)
)
def _set_table(self, table, column):
self.impl._set_table(table, column)
def copy(self):
return DeclEnumType(self.enum)
def process_bind_param(self, value, dialect):
if value is None:
return None
return value.value
def process_result_value(self, value, dialect):
if value is None:
return None
return self.enum.from_string(value.strip())
class Requirement(MappedBase):
"""Representation of a system requirement.
"""
# mapped table
__tablename__ = 'Requirements'
# field mapping
req_id = Column(String, primary_key=True)
description = Column(String)
parent_id = Column(String, ForeignKey('Requirements.req_id',
ondelete='CASCADE', onupdate='CASCADE'))
req_type = Column(Enum(*TYPE_LIST))
priority = Column(Enum(*PRIORITY_LIST))
source_id = Column(Integer, ForeignKey('Sources.source_id',
onupdate='CASCADE', ondelete='SET NULL'))
# relationships
use_cases = relationship('UseCase', secondary=_uc_req, cascade='all',
lazy='joined', join_depth=1)
tests = relationship('SystemTest', secondary=_req_test, cascade='all',
lazy='joined', join_depth=1)
source = relationship('Source', lazy='joined', join_depth=1, uselist=False)
def __init__(self, req_id, description, req_type, priority, source_id,
parent_id):
super(Requirement, self).__init__()
self.req_id = req_id
self.description = description
self.req_type = req_type
self.priority = priority
self.source_id = source_id
self.type = type
self.parent_id = parent_id
class LayerV1(Layer): # Deprecated in v2
__tablename__ = "layerv1"
__table_args__ = {"schema": _schema}
__acl__ = [
(Allow, AUTHORIZED_ROLE, ALL_PERMISSIONS),
]
__mapper_args__ = {"polymorphic_identity": "layerv1"}
id = Column(Integer, ForeignKey(_schema + ".layer.id"), primary_key=True)
layer = Column(Unicode)
is_checked = Column(Boolean, default=True) # by default
icon = Column(Unicode) # on the tree
layer_type = Column(
Enum("internal WMS",
"external WMS",
"WMTS",
"no 2D",
native_enum=False))
url = Column(Unicode) # for externals
image_type = Column(Enum("image/jpeg", "image/png",
native_enum=False)) # for WMS
style = Column(Unicode)
dimensions = Column(Unicode) # for WMTS
matrix_set = Column(Unicode) # for WMTS
wms_url = Column(Unicode) # for WMTS
wms_layers = Column(Unicode) # for WMTS
query_layers = Column(Unicode) # for WMTS
kml = Column(Unicode) # for kml 3D
is_single_tile = Column(Boolean) # for extenal WMS
legend = Column(Boolean, default=True) # on the tree
legend_image = Column(Unicode) # fixed legend image
legend_rule = Column(Unicode) # on wms legend only one rule
is_legend_expanded = Column(Boolean, default=False)
min_resolution = Column(Float) # for all except internal WMS
max_resolution = Column(Float) # for all except internal WMS
disclaimer = Column(Unicode)
# data attribute field in which application can find a human identifiable name or number
identifier_attribute_field = Column(Unicode)
time_mode = Column(
Enum("disabled", "value", "range", native_enum=False),
default="disabled",
nullable=False,
)
time_widget = Column(
Enum("slider", "datepicker", native_enum=False),
default="slider",
nullable=True,
)
def __init__(self,
name="",
public=True,
icon="",
layer_type="internal WMS"):
Layer.__init__(self, name=name, public=public)
self.layer = name
self.icon = icon
self.layer_type = layer_type
def __init__(self, enum, name):
self.enum = enum
self.name = name
members = (member.value for member in enum)
kwargs = {'name': name}
self.impl = SAEnum(*members, **kwargs)
def downgrade():
enum_type = Enum(u'by', u'for', u'of', name='user_artwork_relationship_type')
enum_type.create(bind=op.get_bind())
op.add_column('user_artwork',
Column('relationship_type',
enum_type,
primary_key=True,
nullable=False,
server_default=op.inline_literal('by')))
op.execute('ALTER TABLE user_artwork DROP CONSTRAINT user_artwork_pkey')
op.execute('ALTER TABLE user_artwork ADD PRIMARY KEY (user_id, artwork_id, relationship_type)')
op.drop_index('ix_user_artwork_user_id')
op.drop_index('ix_user_artwork_artwork_id')
def __init__(self, enum):
self.enum = enum
self.impl = SAEnum(
*[sym.value for sym in enum],
name="enum%s" % re.sub(
'([A-Z])',
lambda m: "_" + m.group(1).lower(),
enum.__name__)
)
def __init__(self, enum):
self.enum = enum
self.impl = Enum(
*enum.values(),
name="ck%s" % re.sub(
'([A-Z])',
lambda m:"_" + m.group(1).lower(),
enum.__name__)
)
def __init__(self, enum, **kwargs):
super(DeclEnumType, self).__init__(**kwargs)
self.enum = enum
self.impl = Enum(
*enum.values(),
name="ck%s" % re.sub(
'([A-Z])',
lambda m:"_" + m.group(1).lower(),
enum.__name__)
)
def __init__(self, enum, name=None):
self.enum = enum
enum_args = enum.__enum_args__.copy()
if name is not None:
enum_args['name'] = name
elif 'name' not in enum_args:
enum_args['name'] = 'ck_' + camelcase_to_underscore(enum.__name__)
self.impl = Enum(*enum.values(), **enum_args)
def __init__(self, enum, *args, **kwargs):
self.enum = enum
self.impl = SQLAEnum(
*enum.values(),
name="ck%s" % re.sub(
"([A-Z])",
lambda m: "_" + m.group(1).lower(),
enum.__name__))
super(EnumType, self).__init__(*args, **kwargs)
class ASEnumType(SchemaType, TypeDecorator):
def __init__(self, enum, regex = None):
self.enum = enum
self.impl = Enum(
*enum.values(),
name="ck%s" % re.sub(
'([A-Z])',
lambda m:"_" + m.group(1).lower(),
enum.__name__)
)
self.regex = regex
def _set_table(self, table, column):
self.impl._set_table(table, column)
def copy(self):
return ASEnumType(self.enum)
def process_bind_param(self, value, dialect):
if value is None:
return None
if self.__checkValue(value):
return value.value
return None
def process_result_value(self, value, dialect):
if value is None:
return None
if self.__checkValue(self.enum.from_string(value.strip())):
return self.enum.from_string(value.strip())
return None
def __checkValue(self, value):
if self.regex is not None:
if (re.match(self.regex, value)):
return value
if value in self.enum:
return True
return False;
class DeclEnumType(SchemaType, TypeDecorator):
def __init__(self, enum):
self.enum = enum
self.impl = Enum(
*enum.values(),
name="ck%s" % re.sub(
'([A-Z])',
lambda m: "_" + m.group(1).lower(),
enum.__name__)
)
def _set_table(self, table, column):
self.impl._set_table(table, column)
def copy(self):
return DeclEnumType(self.enum)
def process_bind_param(self, value, dialect):
if value is None:
return None
return value.value
def process_result_value(self, value, dialect):
if value is None:
return None
return self.enum.from_string(value.strip())
def create(self, bind=None, checkfirst=False):
"""Issue CREATE ddl for this type, if applicable."""
super(DeclEnumType, self).create(bind, checkfirst)
t = self.dialect_impl(bind.dialect)
if t.impl.__class__ is not self.__class__ and isinstance(t, SchemaType):
t.impl.create(bind=bind, checkfirst=checkfirst)
def drop(self, bind=None, checkfirst=False):
"""Issue DROP ddl for this type, if applicable."""
super(DeclEnumType, self).drop(bind, checkfirst)
t = self.dialect_impl(bind.dialect)
if t.impl.__class__ is not self.__class__ and isinstance(t, SchemaType):
t.impl.drop(bind=bind, checkfirst=checkfirst)
class DeclEnumType(SchemaType, TypeDecorator):
"""DeclEnum augmented so that it can persist to the database."""
def __init__(self, enum):
import re
self.enum = enum
self.impl = Enum(*enum.names(), name="ck%s" % re.sub(
'([A-Z])', lambda m: '_' + m.group(1).lower(), enum.__name__))
def _set_table(self, table, column):
self.impl._set_table(table, column)
def copy(self, **kw):
return DeclEnumType(self.enum)
def process_bind_param(self, value, dialect):
if isinstance(value, EnumSymbol):
value = value.name
return value
def process_result_value(self, value, dialect):
if value is not None:
return getattr(self.enum, value.strip())
def __init__(self, enum=None, enum_values=None, enum_name=None):
self.enum = enum
self.enum_values = enum_values
self.enum_name = enum_name
if enum:
self.enum_values=enum.values()
self.enum_name=enum.__name__
self.impl = Enum(
*self.enum_values,
name="ck%s" % re.sub(
'([A-Z])',
lambda m: "_" + m.group(1).lower(),
self.enum_name)
)
def __init__(self, enum):
self.enum = enum
constraint = 'ck{0}'.format(re.sub('([A-Z])',
lambda m: '_' + m.group(1).lower(),
enum.__name__))
self.impl = Enum(*enum.values(), name=constraint)
def __init__(self, enum):
self.enum = enum
# convert CamelCase to underscore_separated
name = re.sub('.([A-Z])', lambda m: '_' + m.group(1).lower(), enum.__name__).lower()
self.impl = Enum(*enum.values(), name=name)
def __init__(self, enum):
import re
self.enum = enum
self.impl = Enum(*enum.names(), name="ck%s" % re.sub(
'([A-Z])', lambda m: '_' + m.group(1).lower(), enum.__name__))
