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')))