class User(BaseModel, UserMixin):
__tablename__ = "users"
__repr_fields__ = ("name", )
name = db.Column(db.String(255), nullable=False, unique=True)
admin = db.Column(db.Boolean(), default="f")
active = db.Column(db.Boolean(), default="t")
teams = association_proxy("grants", "team")
def is_authenticated(self):
return True
def is_active(self):
return self.active
def is_anonymous(self):
return False
def is_admin(self):
return self.admin
def get_id(self):
return self.id
class Log(BaseModel):
__tablename__ = "logs"
__repr_fields__ = ("level", "message", "key")
level = db.Column(db.String(10), nullable=False)
message = db.Column(db.String(), nullable=False)
key = db.Column(db.String(50), nullable=False)
class News(BaseModel):
__tablename__ = "news"
title = db.Column(db.String(100), nullable=False)
message = db.Column(db.String(), nullable=False)
users = db.relationship(
"User", backref=db.backref("news", uselist=True), secondary="users_news"
)
class Config(BaseModel):
__tablename__ = "configs"
__repr_fields__ = ("id", "team")
team_id = db.Column(UUIDType(binary=False),
db.ForeignKey("teams.id"),
nullable=False)
team = db.relationship("Team", back_populates="configs")
data = db.Column(MutableDict.as_mutable(JSONType),
default={},
nullable=False)
class Grant(BaseModel):
__tablename__ = "grants"
user_id = db.Column(UUIDType(binary=False), db.ForeignKey("users.id"))
user = db.relationship("User", backref="grants")
role = db.Column(db.Enum(RoleNames), nullable=False, unique=False)
team_id = db.Column(UUIDType(binary=False), db.ForeignKey("teams.id"))
team = db.relationship("Team", backref="grants")
def __repr__(self):
return "<Grant '{0}' is {1} of {2}>".format(self.user.name,
self.role.value,
self.team.name)
class Check(BaseModel):
__tablename__ = "checks"
__repr_fields__ = ("name",)
name = db.Column(db.String(255), nullable=False)
source_id = db.Column(
UUIDType(binary=False), db.ForeignKey("sources.id"), nullable=False
)
source = db.relationship(
"Source", backref=db.backref("source_checks", uselist=True)
)
type = db.Column(db.String(255), nullable=False)
parameters = db.Column(MutableDict.as_mutable(JSONType), default={}, nullable=True)
variables = db.relationship("Variable", backref="check")
class Team(BaseModel):
__tablename__ = "teams"
__repr_fields__ = ("name", )
name = db.Column(db.String(255), nullable=False)
sources = db.relationship("Source", back_populates="team")
rules = db.relationship("Rule", back_populates="team")
configs = db.relationship("Config", back_populates="team")
worst = db.relationship("Worst", back_populates="team")
grants = association_proxy("grants", "user")
variables = db.relationship(
"Variable",
primaryjoin="and_(Team.id==Variable.team_id, "
"Variable.rule_id==None, "
"Variable.source_id==None, "
"Variable.check_id==None)",
backref="team",
)
metas = db.Column(EncryptedDict, default={}, nullable=True)
@property
def members(self):
return [
grant.user for grant in self.grants if grant.role.value == "member"
]
@property
def editors(self):
return [
grant.user for grant in self.grants if grant.role.value == "editor"
]
@property
def managers(self):
return [
grant.user for grant in self.grants
if grant.role.value == "manager"
]
@property
def kafka_topic(self):
return "".join(e for e in self.name if e.isalnum()).lower()
class Worst(BaseModel):
__tablename__ = "worst"
__table_args__ = (UniqueConstraint("team_id",
"label",
"date",
"period",
name="team_label_date_period_uc"), )
__repr_fields__ = ("team", "label", "date", "period")
team_id = db.Column(UUIDType(binary=False),
db.ForeignKey("teams.id"),
nullable=False)
team = db.relationship("Team", back_populates="worst")
date = db.Column(db.DateTime(timezone=True), nullable=False)
label = db.Column(db.String(255), nullable=False)
period = db.Column(db.Enum(Periods), nullable=False, unique=False)
data = db.Column(MutableDict.as_mutable(JSONType),
default={},
nullable=False)
class Source(BaseModel):
__tablename__ = "sources"
__repr_fields__ = ("name", "plugin")
name = db.Column(db.String(255), nullable=False)
plugin = db.Column(db.String(255), nullable=False)
configuration = db.Column(EncryptedDict, default={}, nullable=True)
checks = db.relationship("Check", back_populates="source")
team_id = db.Column(UUIDType(binary=False),
db.ForeignKey("teams.id"),
nullable=True)
team = db.relationship("Team", back_populates="sources")
variables = db.relationship(
"Variable",
primaryjoin="and_(Source.id==Variable.source_id, "
"Variable.rule_id==None, "
"Variable.check_id==None)",
backref="source",
)
class Variable(BaseModel):
__tablename__ = "variables"
__repr_fields__ = ("name", "value", "type")
name = db.Column(db.String(255), nullable=False)
value = db.Column(db.String(), nullable=False)
type = db.Column(db.String(255), nullable=False)
rule_id = db.Column(UUIDType(binary=False),
db.ForeignKey("rules.id"),
nullable=True)
team_id = db.Column(UUIDType(binary=False),
db.ForeignKey("teams.id"),
nullable=False)
source_id = db.Column(UUIDType(binary=False),
db.ForeignKey("sources.id"),
nullable=True)
check_id = db.Column(UUIDType(binary=False),
db.ForeignKey("checks.id"),
nullable=True)
@property
def level(self):
if self.check_id:
return "check"
elif self.source_id:
return "source"
elif self.rule_id:
return "rule"
else:
return "team"
@property
def expression(self):
exp = "depc.{level}['{name}']" if " " in self.name else "depc.{level}.{name}"
return exp.format(level=self.level, name=self.name)
class BaseModel(db.Model):
__abstract__ = True
# A tuple of field names that will be used in the model repr
__repr_fields__ = ()
id = db.Column(UUIDType(binary=False),
primary_key=True,
nullable=False,
default=get_uuid)
created_at = db.Column(db.DateTime(timezone=True),
default=db.func.now(),
nullable=False,
index=True)
updated_at = db.Column(
db.DateTime(timezone=True),
default=db.func.now(),
onupdate=db.func.now(),
nullable=False,
)
def to_dict(self):
"""Serialize an object to a dict"""
# When committed, an ORM object is expired, which means that
# obj.__dict__ does not return its properties.
# session.refresh reloads the object from database
# http://docs.sqlalchemy.org/en/latest/orm/
# session_state_management.html#refreshing-expiring
state = inspect(self)
if state.expired and state._attached:
db.session.refresh(self)
d = dict(self.__dict__)
# Remove SQLAlchemy stuff
try:
del d["_sa_instance_state"]
except KeyError:
pass
return d
def check_integrity(self):
"""Custom integrity checks beyond schema."""
self._check_base_integrity()
def _check_base_integrity(self):
data = self.to_dict()
if self.id:
uuid.UUID(str(self.id))
del data["id"]
self._is_datetime_or_none("created_at")
self._is_datetime_or_none("updated_at")
# Do not check datetimes with schema
keys_to_remove = list()
for key, value in data.items():
if isinstance(value, datetime.datetime):
keys_to_remove.append(key)
for key in keys_to_remove:
del data[key]
try:
jsonschema.validate(data, self._schema)
except jsonschema.ValidationError as e:
raise ValueError(str(e))
except AttributeError:
pass
def _is_datetime_or_none(self, attribute):
value = self.__getattribute__(attribute)
if value:
if not isinstance(value, datetime.datetime):
raise ValueError("{} is not a valid date".format(attribute))
def __repr__(self):
"""Generate a repr using the model __repr_fields__ or a default repr.
Example: if a model class depc has a __repr_fields__ = ('x', ), the
generated repr will be <depc x=someval>
If no __repr_fields__ is defined, only the id will be displayed.
"""
if self.__repr_fields__:
return "<{} {}>".format(
self.__class__.__name__,
", ".join([
"{}={}".format(attr, str(getattr(self, attr, None)))
for attr in self.__repr_fields__
]),
)
return "<{} '{}'>".format(self.__class__.__name__, self.id)
from sqlalchemy.schema import UniqueConstraint
from sqlalchemy_utils import UUIDType
from depc.extensions import db
from depc.models import BaseModel
users_news_association_table = db.Table(
"users_news",
db.Column(
"user_id", UUIDType(binary=False), db.ForeignKey("users.id"), primary_key=True
),
db.Column(
"news_id", UUIDType(binary=False), db.ForeignKey("news.id"), primary_key=True
),
UniqueConstraint("user_id", "news_id", name="users_news_uix"),
)
class News(BaseModel):
__tablename__ = "news"
title = db.Column(db.String(100), nullable=False)
message = db.Column(db.String(), nullable=False)
users = db.relationship(
"User", backref=db.backref("news", uselist=True), secondary="users_news"
)
