class ServerPlan(db.Model):
__tablename__ = "server_plan"
rowid = db.Column(db.Integer, primary_key=True)
server_id = db.Column(
db.Integer,
db.ForeignKey("server.server_id", onupdate="cascade"),
nullable=False,
)
plan_id = db.Column(db.Integer, db.ForeignKey("plan.plan_id"), nullable=False)
created_at = db.Column(
db.String, nullable=False, default=datetime.now().strftime("%Y-%m-%d %H:%M:%S")
)
updated_at = db.Column(
db.String,
nullable=False,
default=datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
onupdate=current_time,
)
def to_dict(self):
entry = {}
entry["plan_id"] = self.plan_id
entry["server_id"] = self.server_id
return entry
def reinitialize(self):
self.record_seconds = 0
self.infraction_count = 0
class Author(db.Model):
__tablename__ = "author"
user_id = db.Column(db.Integer, primary_key=True)
infraction_count = db.Column(db.Integer, nullable=False, default=0)
created_at = db.Column(
db.String,
nullable=False,
default=datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
updated_at = db.Column(
db.String,
nullable=False,
default=datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
onupdate=current_time,
)
infractions = db.relationship("AuthorInfraction")
def to_dict(self):
entry = {}
entry["user_id"] = self.user_id
entry["infraction_count"] = self.infraction_count
entry["updated_at"] = self.updated_at
entry["infractions"] = [
infraction.to_dict() for infraction in self.infractions
]
return entry
class Ban(db.Model):
__tablename__ = "server_banned_word"
rowid = db.Column(db.Integer, primary_key=True)
banned_word = db.Column(db.String, nullable=False, default="defaultbannedword")
server_id = db.Column(db.Integer, db.ForeignKey("server.server_id"), nullable=False)
infracted_at = db.Column(
db.String, nullable=False, default=datetime.now().strftime("%Y-%m-%d %H:%M:%S")
)
calledout_at = db.Column(
db.String,
nullable=False,
default=(datetime.now() - timedelta(weeks=52)).strftime("%Y-%m-%d %H:%M:%S"),
)
record = db.relationship(
"BanRecord", uselist=False, cascade="delete", backref="server_banned_word"
)
def to_dict(self):
entries = {}
entries["server_id"] = self.server_id
entries["rowid"] = self.rowid
entries["banned_word"] = self.banned_word
entries["infracted_at"] = self.infracted_at
entries["calledout_at"] = self.calledout_at
entries["record"] = self.record.to_dict()
return entries
class Server(db.Model):
__tablename__ = "server"
server_id = db.Column(db.Integer, primary_key=True)
awake = db.Column(db.Boolean, default=True)
prefix = db.Column(db.String, nullable=False, default="!vt")
timeout_duration_seconds = db.Column(db.Integer,
nullable=False,
default=1800)
infracted_at = db.Column(db.String, nullable=False, default="-1")
calledout_at = db.Column(db.String, nullable=False, default="-1")
banned_words = db.relationship("Ban")
plan_mapping = db.relationship("ServerPlan",
uselist=False,
cascade="delete",
backref="server")
def to_dict(self):
entries = {}
entries["server_id"] = self.server_id
entries["timeout_duration_seconds"] = self.timeout_duration_seconds
entries["banned_words"] = [
word.to_dict() for word in self.banned_words
]
entries["awake"] = self.awake
entries["plan"] = self.plan_mapping.plan.to_dict()
entries["prefix"] = self.prefix
return entries
def get_plan(self):
return self.plan_mapping.plan
class BanRecord(db.Model):
__tablename__ = "ban_record"
rowid = db.Column(db.Integer, primary_key=True)
ban_id = db.Column(
db.Integer,
db.ForeignKey("server_banned_word.rowid", onupdate="cascade"),
nullable=False,
)
record_seconds = db.Column(db.Integer, nullable=False, default=0)
infraction_count = db.Column(db.Integer, nullable=False, default=0)
created_at = db.Column(
db.String,
nullable=False,
default=datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
updated_at = db.Column(
db.String,
nullable=False,
default=datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
onupdate=current_time,
)
def to_dict(self):
entry = {}
entry["record_seconds"] = self.record_seconds
entry["infraction_count"] = self.infraction_count
entry["updated_at"] = self.updated_at
return entry
def reinitialize(self):
self.record_seconds = 0
self.infraction_count = 0
class AuthorInfraction(db.Model):
__tablename__ = "author_infraction"
rowid = db.Column(db.Integer, primary_key=True)
user_id = db.Column(
db.Integer,
db.ForeignKey("author.user_id", onupdate="cascade"),
nullable=False,
)
ban_id = db.Column(
db.Integer,
db.ForeignKey("server_banned_word.rowid", onupdate="cascade"),
nullable=False,
)
infraction_count = db.Column(db.Integer, nullable=False, default=0)
created_at = db.Column(
db.String,
nullable=False,
default=datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
updated_at = db.Column(
db.String,
nullable=False,
default=datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
onupdate=current_time,
)
def to_dict(self):
entry = {}
entry["user_id"] = self.user_id
entry["ban_id"] = self.ban_id
entry["infraction_count"] = self.infraction_count
entry["updated_at"] = self.updated_at
return entry
class Plan(db.Model):
__tablename__ = "plan"
plan_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
bannings_allowed = db.Column(db.Integer, nullable=False)
created_at = db.Column(db.String, nullable=False, default=current_time())
updated_at = db.Column(db.String,
nullable=False,
default=current_time(),
onupdate=current_time)
server_mapping = db.relationship("ServerPlan",
cascade="delete",
backref="plan")
def to_dict(self):
entry = {}
entry["plan_id"] = self.plan_id
entry["name"] = self.name
entry["bannings_allowed"] = self.bannings_allowed
return entry