def upgrade():
op.create_table(
'profile-profile-association',
sa.Column('first-person-profile', sau.UUIDType(binary=False),
sa.ForeignKey('conduit_api_profile.user-id')),
sa.Column('second-person-profile', sau.UUIDType(binary=False),
sa.ForeignKey('conduit_api_profile.user-id')))
class Comment(Base, sau.Timestamp):
"""
Comment model class
"""
__tablename__ = 'conduit_api_comment'
# base fields
id = sa.Column(
'id',
sa.Integer,
autoincrement=True,
primary_key=True,
nullable=False,
unique=True
)
body = sa.Column(
'body',
sa.String(100),
nullable=False
)
author_id = sa.Column(
'author-id',
sau.UUIDType(binary=False),
sa.ForeignKey('conduit_api_profile.user-id'),
nullable=False
)
article_id = sa.Column(
'article-id',
sau.UUIDType(binary=False),
sa.ForeignKey('conduit_api_article.uuid'),
nullable=False
)
# relationship fields
author = relationship('Profile', back_populates='conduit_api_profile')
article = relationship(
'Article',
secondary=articles_comments_relationship_table,
back_populates='conduit_api_article'
)
__manager__ = CommentManager()
def __repr__(self):
pass
def __str__(self):
return 'Conduit API Comment Model'
def serialize(self):
pass
class LeadOrder(Order):
"""A Lead order from the customer."""
__tablename__ = 'leadorders'
_workflow = workflows.LeadOrderWorkflow
_default_notify_events = {
'POST': events.LeadOrderCreatedEvent,
'PUT': events.LeadOrderUpdatedEvent,
'GET': events.LeadOrderLoadedEvent,
'DELETE': events.LeadOrderDeletedEvent,
}
id = sa.Column(sautils.UUIDType(),
sa.ForeignKey('orders.id'),
index=True,
unique=True,
primary_key=True,
info={
'colanderalchemy': {
'title': 'LeadOrder ID',
'validator': colander.uuid,
'missing': colander.drop,
'typ': colander.String
}
})
confirmation_fields = association_proxy('project',
'leadorder_confirmation_fields')
"""List of fields to be used in confirmation."""
def id(cls):
return sqlalchemy.Column(
sqlalchemy_utils.UUIDType(),
sqlalchemy.ForeignKey('resource.id',
ondelete="CASCADE",
name="fk_%s_id_resource_id" %
cls.__tablename__),
primary_key=True)
class UUIDSchema(resource_type.UUIDSchema, SchemaMixin):
satype = sqlalchemy_utils.UUIDType()
def for_filling(self, dialect):
if self.fill is None:
return False # Don't set any server_default
return sqlalchemy.literal(
self.satype.process_bind_param(self.fill, dialect))
class Article(Base, sau.Timestamp):
"""
Article model class
"""
__tablename__ = 'conduit_api_article'
# base fields
uuid = sa.Column('uuid',
sau.UUIDType(binary=False),
primary_key=True,
nullable=False,
unique=True,
default=uuid.uuid4)
title = sa.Column('title', sa.String(100), nullable=False)
slug = sa.Column('slug', sa.String(100), nullable=False)
description = sa.Column('description', sa.String(300), nullable=False)
body = sa.Column('body', sa.Text, nullable=False)
author_id = sa.Column('author-id',
sau.UUIDType(binary=False),
sa.ForeignKey('conduit_api_profile.user-id'),
nullable=False,
primary_key=False,
unique=True)
# relationship fields
author = relationship('Profile', back_populates='conduit_api_profile')
favorited_user = relationship(
'Profile',
secondary=profiles_articles_relationship_table,
back_populates='conduit_api_articles')
tags = relationship('Article',
secondary=articles_tags_relationship_table,
back_populates='conduit_api_tags')
__manager__ = ArticleManager()
def __repr__(self):
pass
def __str__(self):
return 'Conduit API Article Model'
def serialize(self):
pass
def upgrade():
op.create_table(
'conduit_api_profile',
sa.Column(
'user-id',
sau.UUIDType(binary=False),
sa.ForeignKey('conduit_api_user.uuid'),
nullable=False,
))
def upgrade():
op.create_table(
'conduit_api_comment',
sa.Column('id',
sa.Integer,
autoincrement=True,
primary_key=True,
nullable=False,
unique=True),
sa.Column('body', sa.String(100), nullable=False),
sa.Column('author-id',
sau.UUIDType(binary=False),
sa.ForeignKey('conduit_api_profile.user-id'),
nullable=False),
sa.Column('article-id',
sau.UUIDType(binary=False),
sa.ForeignKey('conduit_api_article.uuid'),
nullable=False))
def upgrade():
op.create_table(
'article-comment-association',
sa.Column(
'article-id',
sau.UUIDType(binary=False),
sa.ForeignKey('conduit_api_article.uuid'),
),
sa.Column('comment-id', sa.Integer,
sa.ForeignKey('conduit_api_comment.id')))
def upgrade():
op.create_table(
'conduit_api_article',
sa.Column('uuid',
sau.UUIDType(binary=False),
primary_key=True,
nullable=False,
unique=True,
default=uuid.uuid4),
sa.Column('title', sa.String(100), nullable=False),
sa.Column('slug', sa.String(100), nullable=False),
sa.Column('description', sa.String(300), nullable=False),
sa.Column('body', sa.Text, nullable=False),
sa.Column('author-id',
sau.UUIDType(binary=False),
sa.ForeignKey('conduit_api_profile.user-id'),
nullable=False,
primary_key=False,
unique=True),
)
class LegacyCustomer(Customer):
__tablename__ = 'wflegacycustomer'
_workflow_klass = LegacyCustomerWorkflow
parent_id = sa.Column(
sautils.UUIDType(),
sa.ForeignKey('wfcustomer.id'),
unique=True,
primary_key=True,
)
def dataclass_field_to_sqla_col(prop: dataclasses.Field) -> sqlalchemy.Column:
t = dataclass_get_type(prop)
if t["type"] == date:
params = sqlalchemy_params(prop, typ=sqlalchemy.Date())
return sqlalchemy.Column(**params)
if t["type"] == datetime:
params = sqlalchemy_params(prop, typ=sqlalchemy.DateTime(timezone=True))
return sqlalchemy.Column(**params)
if t["type"] == str:
str_format = t["metadata"].get("format", None)
if str_format and "/" in str_format:
str_format = str_format.split("/")[0]
if str_format == "text":
params = sqlalchemy_params(prop, typ=sqlalchemy.Text())
elif str_format == "uuid":
params = sqlalchemy_params(prop, typ=sautils.UUIDType())
elif str_format == "fulltextindex":
params = sqlalchemy_params(prop, typ=sautils.TSVectorType)
else:
str_len = prop.metadata.get("length", 256)
params = sqlalchemy_params(prop, typ=sqlalchemy.String(str_len))
return sqlalchemy.Column(**params)
if t["type"] == int:
if t["metadata"].get("format", None) == "bigint":
params = sqlalchemy_params(prop, typ=sqlalchemy.BigInteger())
else:
params = sqlalchemy_params(prop, typ=sqlalchemy.Integer())
return sqlalchemy.Column(**params)
if t["type"] == float:
if t["metadata"].get("format", None) == "numeric":
params = sqlalchemy_params(prop, typ=sqlalchemy.Numeric())
else:
params = sqlalchemy_params(prop, typ=sqlalchemy.Float())
return sqlalchemy.Column(**params)
if t["type"] == bool:
params = sqlalchemy_params(prop, typ=sqlalchemy.Boolean())
return sqlalchemy.Column(**params)
if is_dataclass_field(prop):
raise NotImplementedError("Sub schema is not supported")
if t["type"] == dict:
params = sqlalchemy_params(prop, typ=sajson.JSONField())
return sqlalchemy.Column(**params)
if t["type"] == list:
params = sqlalchemy_params(prop, typ=sajson.JSONField())
return sqlalchemy.Column(**params)
raise KeyError(prop)
def id(cls):
tablename_compact = cls.__tablename__
if tablename_compact.endswith("_history"):
tablename_compact = tablename_compact[:-6]
return sqlalchemy.Column(
sqlalchemy_utils.UUIDType(),
sqlalchemy.ForeignKey(
'resource.id',
ondelete="CASCADE",
name="fk_%s_id_resource_id" % tablename_compact,
# NOTE(sileht): We use to ensure that postgresql
# does not use AccessExclusiveLock on destination table
use_alter=True),
primary_key=True)
class User(Base, sau.Timestamp):
__tablename__ = 'conduit_api_user'
# base fields
uuid = sa.Column('uuid',
sau.UUIDType(binary=False),
primary_key=True,
nullable=False,
unique=True,
default=uuid.uuid4())
email = sa.Column(
'email',
sau.EmailType,
nullable=False,
unique=True,
)
username = sa.Column('username', sa.String(20), nullable=False)
password = sa.Column('password',
sau.PasswordType(schemes=[
'pbkdf2_sha512',
], ),
nullable=False)
bio = sa.Column('bio', sa.String(100), nullable=True)
image = sa.Column('image', sau.URLType, nullable=True)
# relationship fields
profile = relationship('Profile',
uselist=False,
back_populates='conduit_api_profile')
__manager__ = UserManager()
def __repr__(self):
return '<User email: {}, username: {} >'.format(
self.email, self.username)
def __str__(self):
return 'Conduit API User Model'
def serialize(self):
"""
returns JSON-serialized format of Model
"""
return {
'email': self.email,
'username': self.username,
'bio': self.bio,
'image': self.image
}
class ResourceHistory(ResourceMixin, Base, GnocchiBase):
__tablename__ = 'resource_history'
revision = sqlalchemy.Column(sqlalchemy.Integer, autoincrement=True,
primary_key=True)
id = sqlalchemy.Column(sqlalchemy_utils.UUIDType(),
sqlalchemy.ForeignKey(
'resource.id',
ondelete="CASCADE",
name="fk_rh_id_resource_id"),
nullable=False)
revision_end = sqlalchemy.Column(types.TimestampUTC, nullable=False,
default=lambda: utils.utcnow())
metrics = sqlalchemy.orm.relationship(
Metric, primaryjoin="Metric.resource_id == ResourceHistory.id",
foreign_keys='Metric.resource_id')
class Resource(ResourceMixin, Base, GnocchiBase):
__tablename__ = 'resource'
_extra_keys = ['revision', 'revision_end']
revision = -1
id = sqlalchemy.Column(sqlalchemy_utils.UUIDType(), primary_key=True)
revision_end = None
metrics = sqlalchemy.orm.relationship(
Metric,
backref="resource",
primaryjoin="and_(Resource.id == Metric.resource_id, "
"Metric.status == 'active')")
def get_metric(self, metric_name):
m = super(Resource, self).get_metric(metric_name)
if m:
if sqlalchemy.orm.session.object_session(self):
# NOTE(jd) The resource is already loaded so that should not
# trigger a SELECT
m.resource
return m
class Profile(Base, sau.Timestamp):
"""
Profile model class
"""
__tablename__ = 'conduit_api_profile'
# base fields
user_id = sa.Column('user-id',
sau.UUIDType(binary=False),
sa.ForeignKey('conduit_api_user.uuid'),
nullable=False,
primary_key=True,
unique=True)
# relationship fields
user = relationship('User', back_populates='conduit_api_user')
followers = relationship('Profile',
secondary=profiles_relationship_table,
back_populates='conduit_api_profiles')
favorite_articles = relationship(
'Article',
secondary=profiles_articles_relationship_table,
back_populates='conduit_api_articles')
written_articles = relationship('Article',
back_populates='conduit_api_articles')
__manager__ = ProfileManager()
def __repr__(self):
pass
def __str__(self):
return 'Conduit API Profile Model'
def serialize(self):
"""
returns JSON-serialized format of Model
"""
pass
def upgrade():
op.create_table(
'tbl_usage_logs', sa.Column('id', su.UUIDType(), nullable=False),
sa.Column('user_id', sa.Integer(), nullable=False),
sa.Column('instance_name', sa.Unicode(length=255), nullable=False),
sa.Column('instance_quantity', sa.Integer(), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), nullable=False),
sa.ForeignKeyConstraint(
['user_id'],
['tbl_users.id'],
), sa.PrimaryKeyConstraint('id'))
op.create_index(op.f('ix_tbl_usage_logs_created_at'),
'tbl_usage_logs', ['created_at'],
unique=False)
op.create_index(op.f('ix_tbl_usage_logs_instance_name'),
'tbl_usage_logs', ['instance_name'],
unique=False)
op.create_index(op.f('ix_tbl_usage_logs_instance_quantity'),
'tbl_usage_logs', ['instance_quantity'],
unique=False)
op.create_index(op.f('ix_tbl_usage_logs_user_id'),
'tbl_usage_logs', ['user_id'],
unique=False)
class Business(WarehouseBase, BaseTable):
__tablename__ = "Google_Businesses"
id = sql.Column("id",
sqlalchemy_utils.UUIDType(binary=True),
primary_key=True)
address = sql.Column("formatted_address", sql.VARCHAR)
name = sql.Column("name", sql.VARCHAR)
assigned = sql.Column("assigned", sql.Boolean)
edited = sql.Column("Edited", sql.Boolean)
priority = sql.Column("priority", sql.Integer)
editor = sql.Column("editor", sql.VARCHAR)
def handle_type(self, attr):
if hasattr(getattr(self, attr), "hex"):
return getattr(getattr(self, attr), "hex")
else:
return getattr(self, attr)
def to_json(self):
return {
name: self.handle_type(name)
for name in
["id", "address", "name", "edited", "priority", "assigned"]
}
class LocalRoleDeprecated(Identifiable, Timestamp, Base):
"""Local role support for Briefy."""
__tablename__ = 'localroles_deprecated'
entity_type = sa.Column(
sa.String(255),
index=True,
nullable=False
)
"""Entity type.
Name of the entity -- as in its classname.
"""
entity_id = sa.Column(
sautils.UUIDType(),
nullable=False,
index=True,
info={
'colanderalchemy': {
'title': 'Entity ID',
'validator': colander.uuid,
'typ': colander.String
}
}
)
"""Entity ID.
ID of the entity that will receive this Local Role.
"""
user_id = sa.Column(
sautils.UUIDType(),
nullable=False,
index=True,
info={
'colanderalchemy': {
'title': 'User ID',
'validator': colander.uuid,
'typ': colander.String
}
}
)
"""User ID.
User ID assigned the local role here.
"""
role_name = sa.Column(
sautils.ChoiceType(LocalRolesChoices, impl=sa.String()),
nullable=False,
index=True,
)
"""Local role name.
i.e: project_manager
"""
can_create = sa.Column(
sa.Boolean(),
nullable=False,
default=False,
index=True
)
"""Boolean indicating a user can create sub-objects."""
can_delete = sa.Column(
sa.Boolean(),
nullable=False,
default=False,
index=True
)
"""Boolean indicating a user can delete this object."""
can_edit = sa.Column(
sa.Boolean(),
nullable=False,
default=False,
index=True
)
"""Boolean indicating a user can update this object."""
can_list = sa.Column(
sa.Boolean(),
nullable=False,
default=False,
index=True
)
"""Boolean indicating a user can list this object."""
can_view = sa.Column(
sa.Boolean(),
nullable=False,
default=False,
index=True
)
"""Boolean indicating a user can read this object."""
def __repr__(self) -> str:
"""Representation of this object."""
return (
"""<{0}(id='{1}' entity='{2}' entity_id='{3}' user_id='{4}' role='{5}')>""").format(
self.__class__.__name__,
self.id,
self.entity_type,
self.entity_id,
self.user_id,
self.role_name.value
)
def uuid_field(field):
return sqlalchemy_utils.UUIDType()
class Chore(db.Model):
__tablename__ = 'chores'
assignees = [
('0', 'Alex'),
('1', 'Marissa'),
('2', 'Rodney'),
]
cadences = [
('0', 'Weekly'),
('1', 'Monthly'),
('2', 'Every Two Weeks'),
('3', 'Every Two Months'),
('4', 'Every Three Months'),
]
id = sa.Column(sau.UUIDType(binary=False),
primary_key=True,
default=uuid.uuid4,
unique=True,
nullable=False)
name = sa.Column(sa.String(80), nullable=False)
assignee = sa.Column(sau.ChoiceType(assignees), nullable=False)
cadence = sa.Column(sau.ChoiceType(cadences), nullable=False)
next_due_date = sa.Column(sa.Date, nullable=False)
@staticmethod
def validate_missing(data):
required = ['name', 'assignee', 'cadence', 'next_due_date']
return [f for f in required if not data.get(f)]
@staticmethod
def validate_values(data):
invalid, clean = [], {}
name = data.get('name', '')
if len(name) > 80:
invalid.append('name is greater than 80 chars')
else:
clean['name'] = name
try:
assignee = str(int(data.get('assignee')))
valid_assignees = [a[0] for a in Chore.assignees]
if assignee not in valid_assignees:
invalid.append(f'assignee not one of {valid_assignees}')
else:
clean['assignee'] = assignee
except (TypeError, ValueError):
invalid.append('assignee is not an integer')
try:
cadence = str(int(data.get('cadence')))
valid_cadences = [a[0] for a in Chore.cadences]
if cadence not in valid_cadences:
invalid.append(f'cadence not one of {valid_cadences}')
else:
clean['cadence'] = cadence
except (TypeError, ValueError):
invalid.append('cadence is not an integer')
try:
clean['next_due_date'] = datetime.datetime.strptime(
data.get('next_due_date', ''), '%Y-%m-%d')
except ValueError:
invalid.append('next_due_date is not in %Y-%m-%d format')
return invalid, clean
@staticmethod
def validate(data):
missing = Chore.validate_missing(data)
invalid, clean = Chore.validate_values(data)
return missing, invalid, clean
def toJsonSafe(self):
return {
'id': str(self.id),
'name': self.name,
'assignee': str(self.assignee.code),
'cadence': str(self.cadence.code),
'next_due_date': str(self.next_due_date),
}
@property
def next_due_delta(self):
cadence = int(self.cadence.code)
if cadence == 0:
return relativedelta(days=7)
elif cadence == 1:
return relativedelta(months=+1)
elif cadence == 2:
return relativedelta(days=+14)
elif cadence == 3:
return relativedelta(months=+2)
elif cadence == 4:
return relativedelta(months=+3)
else:
raise ValueError(f'unexpected cadence type {self.cadence}')
def find_next_due_date(self):
today = datetime.datetime.now().date()
next_due = copy.copy(self.next_due_date)
if next_due > today: # eager beaver, advance into future
return next_due + self.next_due_delta
else: # slacker, keep advancing until caught up
while not (next_due > today):
next_due += self.next_due_delta
return next_due
class Metric(Base, GnocchiBase, storage.Metric):
__tablename__ = 'metric'
__table_args__ = (
sqlalchemy.Index('ix_metric_status', 'status'),
sqlalchemy.UniqueConstraint("resource_id",
"name",
name="uniq_metric0resource_id0name"),
COMMON_TABLES_ARGS,
)
id = sqlalchemy.Column(sqlalchemy_utils.UUIDType(), primary_key=True)
archive_policy_name = sqlalchemy.Column(
sqlalchemy.String(255),
sqlalchemy.ForeignKey('archive_policy.name',
ondelete="RESTRICT",
name="fk_metric_ap_name_ap_name"),
nullable=False)
archive_policy = sqlalchemy.orm.relationship(ArchivePolicy, lazy="joined")
creator = sqlalchemy.Column(sqlalchemy.String(255))
resource_id = sqlalchemy.Column(
sqlalchemy_utils.UUIDType(),
sqlalchemy.ForeignKey('resource.id',
ondelete="SET NULL",
name="fk_metric_resource_id_resource_id"))
name = sqlalchemy.Column(sqlalchemy.String(255))
unit = sqlalchemy.Column(sqlalchemy.String(31))
status = sqlalchemy.Column(sqlalchemy.Enum('active',
'delete',
name="metric_status_enum"),
nullable=False,
server_default='active')
def jsonify(self):
d = {
"id": self.id,
"creator": self.creator,
"name": self.name,
"unit": self.unit,
}
unloaded = sqlalchemy.inspect(self).unloaded
if 'resource' in unloaded:
d['resource_id'] = self.resource_id
else:
d['resource'] = self.resource
if 'archive_policy' in unloaded:
d['archive_policy_name'] = self.archive_policy_name
else:
d['archive_policy'] = self.archive_policy
if self.creator is None:
d['created_by_user_id'] = d['created_by_project_id'] = None
else:
d['created_by_user_id'], _, d['created_by_project_id'] = (
self.creator.partition(":"))
return d
def __eq__(self, other):
# NOTE(jd) If `other` is a SQL Metric, we only compare
# archive_policy_name, and we don't compare archive_policy that might
# not be loaded. Otherwise we fallback to the original comparison for
# storage.Metric.
return ((isinstance(other, Metric) and self.id == other.id
and self.archive_policy_name == other.archive_policy_name
and self.creator == other.creator and self.name == other.name
and self.unit == other.unit
and self.resource_id == other.resource_id)
or (storage.Metric.__eq__(self, other)))
__hash__ = storage.Metric.__hash__
class UUIDSchema(resource_type.UUIDSchema):
satype = sqlalchemy_utils.UUIDType()
class InstanceDisk(object):
name = sqlalchemy.Column(sqlalchemy.String(255), nullable=False)
instance_id = sqlalchemy.Column(sqlalchemy_utils.UUIDType(),
nullable=False)
class InstanceNetworkInterface(object):
__tablename__ = 'instance_net_int'
name = sqlalchemy.Column(sqlalchemy.String(255), nullable=False)
instance_id = sqlalchemy.Column(sqlalchemy_utils.UUIDType(),
nullable=False)
class Cluster(db.Model):
""" Cluster model for storing cluster related details """
__tablename__ = 'clusters'
id = db.Column(sqlalchemy_utils.UUIDType(),
primary_key=True,
default=uuid.uuid4())
provider = db.Column(db.String(10), nullable=False, default='manual')
project_id = db.Column(db.String(20), nullable=True)
cluster_name = db.Column(db.String(30), nullable=False)
zone = db.Column(db.String(20), nullable=False)
master_node_type = db.Column(db.String(20), nullable=False)
worker_node_type = db.Column(db.String(20), nullable=False)
master_node_count = db.Column(db.Integer, default=1)
worker_node_count = db.Column(db.Integer, default=3)
network_range = db.Column(db.String(20),
default='10.0.0.0/14',
nullable=False)
network_policy = db.Column(db.String(20),
default='PROVIDER_UNSPECIFIED',
nullable=False)
network_enabled = db.Column(db.Boolean(), default=False)
state = db.Column(db.String(30), default='')
kube_config = db.Column(sqlalchemy_utils.JSONType(), default={})
def __init__(self, **kwargs):
if (not kwargs.get('cluster_name', '') or not kwargs.get('zone', '')
or not kwargs.get('master_node_type', '')
or not kwargs.get('worker_node_type', '')):
raise ValueError(
'some variables are missing to provision the cluster')
if kwargs.get('provider', 'manual') == 'gce' and kwargs.get(
'project_id', '') == '':
raise ValueError(
'project id needed to provision k8s cluster on gce')
self.id = uuid.uuid4()
self.cluster_name = kwargs.get('cluster_name')
self.zone = kwargs.get('zone')
self.provider = kwargs.get('provider', 'manual')
self.project_id = kwargs.get('project_id', '')
self.master_node_type = kwargs.get('master_node_type', 1)
self.master_node_count = kwargs.get('master_node_count', 1)
self.worker_node_type = kwargs.get('worker_node_type')
self.worker_node_count = kwargs.get('worker_node_count', 3)
self.network_range = kwargs.get('network_range', '10.0.0.0/14')
self.network_policy = kwargs.get('network_policy',
'PROVIDER_UNSPECIFIED')
self.network_enabled = self.network_policy != 'PROVIDER_UNSPECIFIED'
def get_kubeconfig(self):
""" Get kube config data of cluster """
# @TODO: fix this to check for cluster state and retrive cluster config
# if the cluster successfully gots provisioned
logger.debug('get cluster {} kube config details'.format(
self.cluster_name))
return self.kube_config
def save(self):
""" Save cluster to DB """
logger.debug('saving cluster {} to database'.format(self.cluster_name))
return True, ''
def delete(self):
""" Delete cluster from DB """
logger.debug('deleting cluster {} from database'.format(
self.cluster_name))
return True, ''
def update_state(self):
""" Check for cluster state """
logger.debug('updating cluster {} details in database'.format(
self.cluster_name))
return True, ''
"""
defines many-to-many relationship tables
"""
import sqlalchemy as sa
import sqlalchemy_utils as sau
from models.database import Base
profiles_relationship_table = sa.Table(
'profile-profile-association', Base.metadata,
sa.Column('first-person-profile', sau.UUIDType(binary=False),
sa.ForeignKey('conduit_api_profile.user-id')),
sa.Column('second-person-profile', sau.UUIDType(binary=False),
sa.ForeignKey('conduit_api_profile.user-id')))
profiles_articles_relationship_table = sa.Table(
'profile-article-association', Base.metadata,
sa.Column('profile-id', sau.UUIDType(binary=False),
sa.ForeignKey('conduit_api_profile.user-id')),
sa.Column('article-id', sau.UUIDType(binary=False),
sa.ForeignKey('conduit_api_article.uuid')))
articles_comments_relationship_table = sa.Table(
'article-comment-association', Base.metadata,
sa.Column(
'article-id',
sau.UUIDType(binary=False),
sa.ForeignKey('conduit_api_article.uuid'),
),
sa.Column('comment-id', sa.Integer,
sa.ForeignKey('conduit_api_comment.id')))
