def downgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.drop_table('manga_tags_link')
op.drop_index('manga_releases_source_site_id_idx',
table_name='manga_releases')
op.drop_index(op.f('ix_manga_releases_state'), table_name='manga_releases')
op.drop_index(op.f('ix_manga_releases_source_site'),
table_name='manga_releases')
op.drop_index(op.f('ix_manga_releases_source_id'),
table_name='manga_releases')
op.drop_table('manga_releases')
op.drop_table('hentai_tags_link')
op.drop_index(op.f('ix_hentai_releases_state'),
table_name='hentai_releases')
op.drop_index(op.f('ix_hentai_releases_source_site'),
table_name='hentai_releases')
op.drop_index(op.f('ix_hentai_releases_source_id'),
table_name='hentai_releases')
op.drop_index('hentai_releases_source_site_id_idx',
table_name='hentai_releases')
op.drop_table('hentai_releases')
op.drop_table('release_files')
op.drop_index(op.f('ix_manga_tags_tag'), table_name='manga_tags')
op.drop_table('manga_tags')
op.drop_index(op.f('ix_hentai_tags_tag'), table_name='hentai_tags')
op.drop_table('hentai_tags')
ENUM(name='filetype_enum').drop(op.get_bind(), checkfirst=False)
ENUM(name='dlstate_enum').drop(op.get_bind(), checkfirst=False)
ENUM(name='dirtype_enum').drop(op.get_bind(), checkfirst=False)
class Candidacy(Base):
__tablename__ = 'candidacies'
id = sa.Column(sa.Integer, primary_key=True)
candidate_id = sa.Column(sa.Integer)
candidate = sa.orm.relationship(
'Candidate',
primaryjoin='Candidacy.candidate_id==Candidate.id',
foreign_keys='Candidacy.candidate_id',
remote_side='Candidate.id',
backref='candidacies')
election_type = sa.Column(sa.String)
election_year = sa.Column(sa.Integer)
# Incumbent, challenger, open seat
race_type = sa.Column(
ENUM('incumbent',
'challenger',
'open seat',
'retired',
name='candidacy_race_type'))
outcome = sa.Column(ENUM('won', 'lost', name='candidacy_outcome'))
fair_campaign = sa.Column(sa.Boolean)
limits_off = sa.Column(sa.Boolean)
limits_off_reason = sa.Column(sa.String)
def __repr__(self):
return '<Candidacy %r %r, (%r %r)>' % (
self.candidate.first_name, self.candidate.last_name,
self.election_year, self.election_type)
def as_dict(self):
return {c.name: getattr(self, c.name) for c in self.__table__.columns}
def downgrade():
context = op.get_context()
op.execute(tcr.update().where(tcr.c.directmedia == u'outgoing').values(
directmedia=None))
if context.bind.dialect.name != 'postgresql':
op.alter_column('sippeers',
'directmedia',
type_=old_type,
existing_type=new_type)
else:
enum = ENUM("yes",
"no",
"nonat",
"update",
name="sip_directmedia_values")
enum.create(op.get_bind(), checkfirst=False)
op.execute('ALTER TABLE sippeers ALTER COLUMN directmedia TYPE'
' sip_directmedia_values USING'
' directmedia::text::sip_directmedia_values')
ENUM(name="sip_directmedia_values_v2").drop(op.get_bind(),
checkfirst=False)
def downgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.drop_constraint('alert_affected_services_alert_id_fkey',
'alert_affected_services',
type_='foreignkey')
op.drop_constraint('alert_affected_services_route_id_fkey',
'alert_affected_services',
type_='foreignkey')
op.drop_constraint('alert_effect_period_alert_id_fkey',
'alert_effect_period',
type_='foreignkey')
op.drop_constraint('alert_events_routes_fkey',
'alert_events',
type_='foreignkey')
op.drop_constraint('alert_events_day_check', 'alert_events', type_='check')
op.drop_table('alert_events')
op.drop_table('alert_affected_services')
op.drop_table('alert_effect_period')
op.drop_table('alerts')
op.drop_table('stops')
op.drop_table('routes')
ENUM(name="delayaccuracy").drop(op.get_bind(), checkfirst=False)
ENUM(name="direction").drop(op.get_bind(), checkfirst=False)
def downgrade():
downvert_data(op)
op.drop_table('user_preferences')
op.drop_table('query_policy')
# Create a temporary type "_resourcetypeenum" type
temporary_type = ENUM(*OLD_RESOURCE_TYPES, name='resourcetypeenum_temp')
new_type = ENUM(*NEW_RESOURCE_TYPES, name='resourcetypeenum')
temporary_type.create(op.get_bind(), checkfirst=True)
# Convert the name column from old_type to temporary_type
with op.batch_alter_table('resource_type', schema=None) as batch_op:
batch_op.alter_column(
'name',
existing_type=new_type,
type_=temporary_type,
nullable=False,
postgresql_using='name::text::resourcetypeenum_temp')
# Drop the old type, create a new enum of type 'resourcetypeenum'
new_type.drop(op.get_bind(), checkfirst=True)
old_type = ENUM(*OLD_RESOURCE_TYPES, name='resourcetypeenum')
old_type.create(op.get_bind(), checkfirst=True)
# Convert the name column from temporary_type to new_type
with op.batch_alter_table('resource_type', schema=None) as batch_op:
batch_op.alter_column('name',
existing_type=temporary_type,
type_=old_type,
nullable=False,
postgresql_using='name::text::resourcetypeenum')
# Drop the temporary type
temporary_type.drop(op.get_bind(), checkfirst=True)
class SubOrder(Model):
__tablename__ = 'sub_order'
title = Column(String, nullable=True)
order_id = Column(UUIDType(binary=False),
ForeignKey('order.id'),
nullable=False)
total_price = Column(Float)
receiver_id = Column(UUIDType(binary=False), ForeignKey('receivers.id'))
address_id = Column(UUIDType(binary=False), ForeignKey('addresses.id'))
delivery_type = Column(ENUM('fast', 'scheduled', name='delivery_typess'))
delivery_date = Column(DateTime)
delivery_time = Column(String)
message = Column(String)
order_status = Column(
ENUM('pending', 'ongoing', 'done', name='sub_order_status'))
is_cart = Column(Boolean, unique=False, default=True)
@hybrid_property
def product(self):
return Product.query.filter_by(id=str(self.product_id)).first()
@hybrid_property
def address(self):
return Address.query.filter_by(id=str(self.address_id)).first()
@hybrid_property
def receiver(self):
return Receiver.query.filter_by(id=str(self.receiver_id)).first()
@hybrid_property
def extra_orders(self):
return ExtraOrder.query.filter_by(suborder_id=str(self.id)).all()
def upgrade():
context = op.get_context()
# Upgrading to this revision WILL clear your directmedia values.
if context.bind.dialect.name == 'sqlite':
with op.batch_alter_table('sippeers') as batch_op:
batch_op.alter_column('directmedia', type_=new_type)
elif context.bind.dialect.name != 'postgresql':
op.alter_column('sippeers',
'directmedia',
type_=new_type,
existing_type=old_type)
else:
enum = ENUM("yes",
"no",
"nonat",
"update",
"outgoing",
name="sip_directmedia_values_v2")
enum.create(op.get_bind(), checkfirst=False)
op.execute('ALTER TABLE sippeers ALTER COLUMN directmedia TYPE'
' sip_directmedia_values_v2 USING'
' directmedia::text::sip_directmedia_values_v2')
ENUM(name="sip_directmedia_values").drop(op.get_bind(),
checkfirst=False)
class Data(db.Model):
"""
Attribute metadata.
Gives some informations about the data columns
"""
__tablename__ = 'tjs_data'
pkid = db.Column(db.Integer, primary_key=True)
dataset = db.relationship(
'Dataset',
backref=db.backref('datas', lazy='dynamic')
)
dataset_id = db.Column(db.Integer, db.ForeignKey('tjs_datasets.pkid'))
isframeworkkey = db.Column(db.Boolean)
name = db.Column(db.String, nullable=False)
type = db.Column(xmldtypes, default="string")
length = db.Column(db.Integer, default=0)
purpose = db.Column(db.String, default="Attribute")
title = db.Column(db.String)
abstract = db.Column(db.Text)
values = db.Column(
ENUM('count', 'measure', 'nominal', 'ordinal', name='tjs_valuetype'),
default='ordinal')
# extensions
curves = db.Column(emp_chart_rules)
jointoframeworkkey = db.Column(db.Integer, db.ForeignKey('tjs_frameworkkey.pkid'))
bars = db.Column(emp_chart_rules)
tabular = db.Column(emp_chart_rules)
brush = db.Column(emp_chart_rules)
map = db.Column(emp_chart_rules)
map_mode = db.Column(ENUM('flow-source', 'flow-dest', 'standard', name='emp_mapmodes'))
def __repr__(self):
return '{} : {}'.format(self.dataset.dataseturi, self.name)
class Pickup(Base):
__tablename__ = "pickups"
id = sa.Column("id", sa.Integer, primary_key=True)
firebase_id = sa.Column("firebase_id", sa.String, nullable=False)
firebase_run_id = sa.Column("firebase_run_id", sa.String, nullable=False)
centerline_id =\
sa.Column("centerline_id", sa.Integer, sa.ForeignKey("centerlines.id"), nullable=False)
type = sa.Column("type",
ENUM(*RUBBISH_TYPES, name="rubbish_type"),
nullable=False)
timestamp = sa.Column("timestamp", sa.DateTime, nullable=False)
geometry = sa.Column("geometry", Geometry("POINT"), nullable=False)
snapped_geometry = sa.Column("snapped_geometry",
Geometry("POINT"),
nullable=False)
linear_reference = sa.Column("linear_reference",
sa.Float(precision=3),
nullable=False)
curb = sa.Column("curb",
ENUM('left', 'right', 'middle', name='curb'),
nullable=False)
centerline = relationship("Centerline", back_populates="pickups")
def __repr__(self):
return (
f"""<Pickup id={self.id} """
f"""geometry={self.geometry} snapped_geometry={self.snapped_geometry} """
f"""centerline_id={self.centerline_id} firebase_id={self.firebase_id} """
f"""firebase_run_id={self.firebase_run_id} """
f"""type={self.type} timestamp={self.timestamp} """
f"""linear_reference={self.linear_reference} curb={self.curb}>""")
def upgrade():
ENUM(u'gcc', u'g++', u'java', name=u'user_program_language_enum').create(op.get_bind(), checkfirst=False)
op.alter_column('user', 'program_language', existing_type=sa.Enum(u'gcc', u'g++', u'java', name=u'user_program_language_enum'), nullable=True)
op.alter_column('user_deleted', 'program_language', existing_type=sa.Enum(u'male', u'female', name='user_gender'), nullable=True)
ENUM(u'gcc', u'g++', u'java', name=u'solution_program_language_enum').create(op.get_bind(), checkfirst=False)
op.alter_column('solution', 'program_language', existing_type=sa.Enum(u'gcc', u'g++', u'java', name=u'solution_program_language_enum'), nullable=False)
class Committee(Base):
__tablename__ = 'committees'
id = sa.Column(sa.Integer, primary_key=True)
type = sa.Column(sa.String)
state_committee = sa.Column(sa.Boolean)
state_id = sa.Column(sa.Integer)
local_committee = sa.Column(sa.Boolean)
local_id = sa.Column(sa.Integer)
refer_name = sa.Column(sa.String)
name = sa.Column(sa.String)
address1 = sa.Column(sa.String)
address2 = sa.Column(sa.String)
address3 = sa.Column(sa.String)
city = sa.Column(sa.String)
state = sa.Column(sa.String)
zipcode = sa.Column(sa.String)
active = sa.Column(sa.Boolean)
status_date = sa.Column(sa.DateTime)
creation_date = sa.Column(sa.DateTime)
creation_amount = sa.Column(DOUBLE_PRECISION)
disp_funds_return = sa.Column(sa.Boolean)
disp_funds_political_committee = sa.Column(sa.Boolean)
disp_funds_charity = sa.Column(sa.Boolean)
disp_funds_95 = sa.Column(sa.Boolean)
disp_funds_description = sa.Column(sa.Text)
# These use the same ENUM. Need to create it separately
candidate_position = sa.Column(
ENUM('support', 'oppose', name='committee_position',
create_type=False))
policy_position = sa.Column(
ENUM('support', 'oppose', name='committee_position',
create_type=False))
party = sa.Column(sa.String)
purpose = sa.Column(sa.Text)
candidates = sa.orm.relationship(
'Candidate',
primaryjoin='Committee.id==candidate_committees.c.committee_id',
secondaryjoin='candidate_committees.c.candidate_id==Candidate.id',
secondary=candidate_committees,
backref='committees')
officers = sa.orm.relationship(
'Officer',
primaryjoin='Committee.id==officer_committees.c.committee_id',
secondaryjoin='officer_committees.c.officer_id==Officer.id',
secondary=officer_committees,
backref='committees')
def __repr__(self):
return '<Committee %r>' % self.name
def as_dict(self):
d = {c.name: getattr(self, c.name) for c in self.__table__.columns}
d['officers'] = [o.as_dict() for o in self.officers]
def downgrade():
yesno_values = ENUM(*YESNO_VALUES, name=YESNO_NAME, create_type=False)
if op.get_context().bind.dialect.name != 'mssql':
op.alter_column('ps_transports', 'verify_server', type_=yesno_values,
new_column_name='verifiy_server')
else:
op.alter_column('ps_transports', 'verify_server', existing_type=yesno_values, type_=sa.String(3),
new_column_name='verifiy_server')
yesno_values = ENUM(*YESNO_VALUES, name=YESNO_NAME, create_type=True)
op.alter_column('ps_transports', 'verifiy_server', existing_type=sa.String(3), type_=yesno_values)
def upgrade():
# Create a temporary type "_resourcetypeenum" type
temporary_type = ENUM(*NEW_RESOURCE_TYPES, name='resourcetypeenum_temp')
old_type = ENUM(*OLD_RESOURCE_TYPES, name='resourcetypeenum')
temporary_type.create(op.get_bind(), checkfirst=True)
# Convert the name column from old_type to temporary_type
with op.batch_alter_table('resource_type', schema=None) as batch_op:
batch_op.alter_column(
'name',
existing_type=old_type,
type_=temporary_type,
nullable=False,
postgresql_using='name::text::resourcetypeenum_temp')
# Drop the old type, create a new enum of type 'resourcetypeenum'
old_type.drop(op.get_bind(), checkfirst=True)
new_type = ENUM(*NEW_RESOURCE_TYPES, name='resourcetypeenum')
new_type.create(op.get_bind(), checkfirst=True)
# Convert the name column from temporary_type to new_type
with op.batch_alter_table('resource_type', schema=None) as batch_op:
batch_op.alter_column('name',
existing_type=temporary_type,
type_=new_type,
nullable=False,
postgresql_using='name::text::resourcetypeenum')
# Drop the temporary type
temporary_type.drop(op.get_bind(), checkfirst=True)
op.create_table(
'query_policy', sa.Column('id', sa.Integer(), nullable=False),
sa.Column('name', sa.String(), nullable=False),
sa.Column('description', sa.Text(), nullable=True),
sa.Column('policy_filters',
postgresql.JSONB(astext_type=sa.Text()),
nullable=False),
sa.Column('resource_id', sa.Integer(), nullable=False),
sa.ForeignKeyConstraint(['resource_id'], ['resource.id'],
name='valid_query_definition_resource',
ondelete='CASCADE'),
sa.PrimaryKeyConstraint('id'), sa.UniqueConstraint('name'),
sa.UniqueConstraint('resource_id'))
op.create_table(
'user_preferences', sa.Column('id', sa.Integer(), nullable=False),
sa.Column('user_id', sa.Integer(), nullable=False),
sa.Column('preferences',
postgresql.JSONB(astext_type=sa.Text()),
nullable=False),
sa.ForeignKeyConstraint(['user_id'], ['user.id'],
name='valid_user',
ondelete='CASCADE'),
sa.PrimaryKeyConstraint('id'))
upvert_data(op)
def upgrade():
op.create_table(
'activity_log',
sa.Column('id', sa.Integer, primary_key=True, autoincrement=True),
sa.Column('box_code', sa.Integer(), nullable=False),
sa.Column('worker_id', sa.Integer, sa.ForeignKey('worker.id')),
sa.Column('payload', sa.Integer()),
sa.Column('type', ENUM(ActivityType, name="type")),
sa.Column('status', ENUM(ActivityStatus, name="status")),
sa.Column('local_time', sa.DateTime()),
sa.Column('server_time', sa.DateTime(), default=dt.now))
def downgrade():
op.alter_column('user', 'program_language',
existing_type=sa.VARCHAR(length=64),
nullable=True)
op.alter_column('user_deleted', 'program_language',
existing_type=sa.VARCHAR(length=64),
nullable=True)
op.alter_column('solution', 'program_language',
existing_type=sa.VARCHAR(length=64),
nullable=False)
ENUM(name=u'user_program_language_enum').drop(op.get_bind(), checkfirst=False)
ENUM(name=u'solution_program_language_enum').drop(op.get_bind(), checkfirst=False)
def upgrade():
context = op.get_context()
if context.bind.dialect.name == 'postgresql':
enum = ENUM(*SHA_HASH_VALUES, name=SHA_HASH_NAME)
enum.create(op.get_bind(), checkfirst=False)
op.add_column(
'ps_endpoints',
sa.Column(
'dtls_fingerprint',
ENUM(*SHA_HASH_VALUES, name=SHA_HASH_NAME, create_type=False)))
class Candidate(BaseModelWithTimestamps):
fec_id = db.Column(db.String(9), unique=True, nullable=False)
name = db.Column(db.String)
party_affiliation = db.Column(db.String(3))
election_year = db.Column(db.SmallInteger, nullable=False)
office = db.Column(ENUM("H", "S", name="office"), nullable=False)
office_state = db.Column(db.String(2), nullable=False)
office_district = db.Column(db.String(2))
incumbent_challenger_status = db.Column(
ENUM("C", "I", "O", name="incumbent_challenger_status")
)
principal_campaign_committee_fec_id = db.Column(db.String(9))
pledge_date = db.Column(db.Date)
class RecordsAuthors(db.Model):
__tablename__ = "records_authors"
__table_args__ = (
db.Index("ix_authors_records_record_id", "record_id"),
db.Index(
"ix_authors_records_author_id_id_type_record_id",
"author_id",
"id_type",
"record_id",
),
db.Index("ix_records_authors_id_type_authors_id", "id_type",
"author_id"),
)
id = db.Column(db.Integer, primary_key=True)
author_id = db.Column(Text, nullable=False)
id_type = db.Column(
ENUM(*[key.value for key in AuthorSchemaType],
name="enum_author_schema_type"),
nullable=False,
)
record_id = db.Column(
UUIDType,
db.ForeignKey("records_metadata.id",
name="fk_authors_records_record_id"),
nullable=False,
)
def upgrade():
# ### commands auto generated by Alembic - please adjust! ###
authenticationtype = ENUM('email',
'facebook',
'google',
name='authenticationtype')
authenticationtype.create(op.get_bind())
op.add_column(
'User',
sa.Column('authentication_type',
ENUM('email',
'facebook',
'google',
name='authenticationtype'),
nullable=True))
class GroupStat(DatabaseModel):
"""Model for a statistic of a group inside a certain time period."""
__tablename__ = "group_stats"
group_id: int = Column(
Integer, ForeignKey("groups.group_id"), nullable=False, primary_key=True,
)
stat: GroupStatType = Column(ENUM(GroupStatType), nullable=False, primary_key=True)
period: DateTimeTZRange = Column(TSTZRANGE, nullable=False, primary_key=True)
value: float = Column(Float, nullable=False)
group: Group = relationship("Group", innerjoin=True, lazy=False)
# Add a GiST index on the period column for range operators
__table_args__ = (
Index("ix_group_stats_period_gist", period, postgresql_using="gist"),
)
def __init__(
self,
group: Group,
stat: GroupStatType,
start_time: datetime,
end_time: datetime,
value: Union[int, float],
):
"""Create a new statistic for the group and time period.
The time period will be inclusive of start_time but exclusive of end_time.
"""
self.group = group
self.stat = stat
self.period = DateTimeTZRange(start_time, end_time, bounds="[)")
self.value = float(value)
def upgrade():
### commands auto generated by Alembic - please adjust! ###
enum = ENUM('unverified',
'valid',
'rejected',
name='nu_item_enum',
create_type=False)
enum.create(op.get_bind(), checkfirst=True)
op.execute(
"ALTER TABLE nu_release_item ALTER COLUMN reviewed DROP DEFAULT")
op.alter_column(
'nu_release_item',
'reviewed',
existing_type=sa.BOOLEAN(),
type_=enum,
existing_nullable=False,
nullable=False,
server_default=sa.text("'unverified'"),
existing_server_default=sa.text('false'),
postgresql_using=
"CASE WHEN reviewed = false THEN 'unverified'::nu_item_enum ELSE 'valid'::nu_item_enum END"
)
op.execute(
"ALTER TABLE nu_release_item ALTER COLUMN reviewed SET DEFAULT 'unverified'"
)
class Account(PrimaryModel, Base):
__tablename__ = 'accounts'
person_id = Column(UUID, ForeignKey(Person.id), nullable=False)
value = Column(Float, default=0.00)
type = Column(ENUM(AccountTypes), nullable=False)
person = relationship(Person,
primaryjoin=person_id == Person.id,
lazy=True)
def __init__(self, username):
super(Account, self).__init__(username)
def to_dict(self):
data = {
'id': self.id,
'person_id': self.person_id,
'value': self.value,
'creator': self.creator,
'creation_date': self.creation_date,
'version': self.version,
'modification_date': self.modification_date,
'modifier': self.modifier,
'tags': self.tags
}
if self.person is not None:
data.update({'person': self.person.to_dict()})
if isinstance(self.type, str):
data.update({'type': self.type})
else:
data.update({'type': self.type.value})
return data
class Subscription(db.Model):
"""Model class to represent ATT subscriptions"""
__tablename__ = "subscriptions"
id = db.Column(db.Integer, primary_key=True)
phone_number = db.Column(db.String(10))
status = db.Column(ENUM(SubscriptionStatus), default=SubscriptionStatus.new)
activation_date = db.Column(db.TIMESTAMP(timezone=True), nullable=True)
expiry_date = db.Column(db.TIMESTAMP(timezone=True), nullable=True)
plan_id = db.Column(db.String(30), db.ForeignKey("plans.id"), nullable=False)
plan = db.relationship("Plan", foreign_keys=[plan_id], lazy="select")
def __repr__(self): # pragma: no cover
return (
f"<{self.__class__.__name__}: {self.id} ({self.status}), "
f"phone_number: {self.phone_number or '[no phone number]'}, ",
f"plan: {self.plan_id}>"
)
@classmethod
def get_subscriptions(cls, **kwargs):
"""Gets a list of Subscription objects using given kwargs
Generates query filters from kwargs param using base class method
Args:
kwargs: key value pairs to apply as filters
Returns:
list: objects returned from query result
"""
return cls.query.filter(**kwargs).all()
class InterfaceInstance(Base, StdObject):
internal_name = Column(String(36), nullable=False)
external_name = Column(String(36), nullable=False)
vm_instance_id = Column(UUID(True), ForeignKey('vm_instances.uuid'))
vm_instance = relationship(VmInstance,
backref=backref('interface_instances',
uselist=True))
net_instance_id = Column(UUID(True), ForeignKey('net_instances.uuid'))
net_instance = relationship(NetInstance,
backref=backref('interface_instances',
uselist=True))
interface_id = Column(UUID(True), ForeignKey('interfaces.uuid'))
interface = relationship(Interface,
backref=backref('interface_instances',
uselist=True))
type = Column('type',
ENUM('bridge', 'ptp', 'data', 'mgmt', name='interfacetype'),
default='data',
nullable=False)
vpci = Column(CHAR(12), nullable=False)
bw = Column(INT, nullable=False)
physical_name = Column(String(36))
ip_address = Column(String(36))
class Post(db.Model):
__tablename__ = 'post'
id = db.Column(db.BigInteger, primary_key=True)
owner_id = db.Column(db.BigInteger,
db.ForeignKey('user.id'),
nullable=False)
description = db.Column(db.String(1024))
content = db.Column(db.String(20000))
time_created = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
title = db.Column(db.String(256), nullable=True)
status = db.Column(
"status",
ENUM("init", "draft", "published", "deleted", name="post_status"))
files = db.relationship('File', backref='posts', lazy=True)
@property
def serialize(self):
return {
'id': self.id,
'title': self.title,
'description': self.description,
'owner': self.owner.serialize,
'content': self.content,
'status': self.status,
'createdAt': self.time_created
}
def upgrade():
# If we don't do this, Alembic won't create the type automatically
enum_type = ENUM('yahoo', 'google', 'kofia', name='asset_value_source')
enum_type.create(op.get_bind())
op.add_column('asset_value', sa.Column('source', enum_type,
nullable=False))
class StudentsAdvisors(db.Model):
"""Links students with their thesis advisors"""
__tablename__ = "students_advisors"
__table_args__ = (db.Index("ix_students_advisors_student_id",
"student_id"), )
advisor_id = db.Column(
UUIDType,
db.ForeignKey("records_metadata.id",
name="fk_students_advisors_advisor_id"),
nullable=False,
primary_key=True,
)
student_id = db.Column(
UUIDType,
db.ForeignKey("records_metadata.id",
name="fk_students_advisors_student_id"),
nullable=False,
primary_key=True,
)
degree_type = db.Column(
ENUM(*[key.value for key in DegreeType], name="enum_degree_type"))
class EventUser(db.Model):
__tablename__ = "event_users"
id = db.Column(db.Integer, primary_key=True)
user_type = db.Column(
ENUM(*user_types, name="user_types"), nullable=False, default=GUEST
)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"))
user = db.relationship("User", back_populates="events")
event_id = db.Column(db.Integer, db.ForeignKey("events.id"))
event = db.relationship("Event", back_populates="users")
user_types = user_types
GUEST = GUEST
HOST = HOST
# user_event_items = db.relationship("UserEventItem", back_populates="user_event")
UniqueConstraint(user_id, event_id, name="event_users_user_id_event_id_key")
def __repr__(self):
return "<EventUser: id={}, user_id={}, event_id={}>".format(
self.id, self.user_id, self.event_id
)
def upgrade():
############################# Enums ##############################
# yesno_values have already been created, so use postgres enum object
# type to get around "already created" issue - works okay with mysql
yesno_values = ENUM(*YESNO_VALUES, name=YESNO_NAME, create_type=False)
op.add_column('ps_endpoints', sa.Column('g726_non_standard', yesno_values))
def downgrade():
op.drop_column('user', 'name')
op.drop_column('user', 'ident_type')
op.drop_column('user', 'ident')
op.drop_column('post_history', 'ident_type')
op.drop_column('post', 'ident_type')
ENUM(name='ident_type').drop(op.get_bind(), checkfirst=True)
