class UserModel(models.Model):
id = fields.UUIDField(pk=True)
email = fields.CharField(null=False, max_length=255)
hashed_password = fields.CharField(null=True, max_length=255)
is_active = fields.BooleanField(null=False, default=False)
confirmation = fields.UUIDField(null=True)
class Meta:
table: str = 'users'
class Call(Model):
id: uuid4 = fields.UUIDField(pk=True)
created_at: datetime = fields.DatetimeField(auto_now_add=True)
updated_at: datetime = fields.DatetimeField(auto_now=True, null=True)
company: fields.ForeignKeyRelation[Company] = fields.ForeignKeyField(
model_name='models.Company',
related_name='calls',
on_delete=fields.CASCADE,
)
operator: str = fields.CharField(max_length=15)
operator_session_id: str = fields.CharField(max_length=50,
default='',
index=True)
call_type: str = fields.CharField(max_length=15)
state: str = fields.CharField(max_length=15)
from_number: str = fields.CharField(max_length=256)
from_user: str = fields.CharField(max_length=50, default='')
from_pin: str = fields.CharField(max_length=15, default='')
request_number: str = fields.CharField(max_length=256)
request_user: str = fields.CharField(max_length=50, default='')
request_pin: str = fields.CharField(max_length=50, default='')
record_url: str = fields.CharField(max_length=250, default='')
appeal_id: uuid4 = fields.UUIDField(null=True, default=None, index=True)
has_appeal: bool = fields.BooleanField(null=True, default=None)
appeal_number: int = fields.IntField(null=True, default=None)
managed_by: int = fields.IntField(null=True)
is_record: bool = fields.BooleanField(default=False)
disconnect_reason: str = fields.CharField(max_length=150, default='')
comment: str = fields.CharField(max_length=255, default='')
managed_at: datetime = fields.DatetimeField(null=True)
started_at: datetime = fields.DatetimeField(null=True)
voice_started_at: datetime = fields.DatetimeField(null=True)
voice_finished_at: datetime = fields.DatetimeField(null=True)
finished_at: datetime = fields.DatetimeField(null=True)
is_hidden: bool = fields.BooleanField(null=True, default=False)
voximplant_session_id: str = fields.CharField(max_length=20,
default=None,
null=True)
dialog: str = fields.TextField(default='')
campaign_id: int = fields.IntField(null=True, default=None)
campaign_contact_id: int = fields.IntField(null=True, default=None)
duration_sec: int = fields.IntField(default=0)
duration_min: int = fields.IntField(default=0)
class Meta:
table = 'calls'
def create_record_filename(self):
return str(self.id).replace('-', '') + '.mp3'
@property
def sign(self) -> str:
call_str = f'{self.id}{self.call_type}{self.state}'.encode()
return md5(call_str).hexdigest()
class UserModel(models.Model):
id = fields.UUIDField(pk=True)
email = fields.CharField(null=False, max_length=255)
hashed_password = fields.CharField(null=True, max_length=255)
is_active = fields.BooleanField(null=False, default=False)
confirmation = fields.UUIDField(null=True)
def verify_password(self, password: str) -> bool:
return bcrypt.verify(password, self.hashed_password)
class Meta:
table: str = 'users'
class Client(Model, ClientMixin):
id = fields.UUIDField(pk=True)
secret = fields.CharField(80, null=True)
name = fields.CharField(32, unique=True)
redirect_uris = fields.JSONField()
scopes = fields.JSONField()
token_endpoint_auth_method = fields.CharField(
128, default="client_secret_basic")
grant_types = fields.JSONField(default=lambda: ["authorization_code"])
response_types = fields.JSONField(default=lambda: ["code"])
client_uri = fields.CharField(256, null=True)
logo_uri = fields.CharField(256, null=True)
contacts = fields.JSONField(null=True)
tos_uri = fields.CharField(256, null=True)
policy_uri = fields.CharField(256, null=True)
jwks_uri = fields.CharField(256, null=True)
jwks = fields.JSONField(null=True)
software_id = fields.UUIDField(unique=True, null=True)
software_version = fields.CharField(32, null=True)
class Meta:
table = "clients"
def get_client_id(self) -> str:
return str(self.id)
def get_client_secret(self) -> str:
return self.secret
def get_client_public_key(self, key_id: str) -> JsonWebKey:
if self.jwks is None:
return None
return JsonWebKey(self.jwks)
def get_allowed_scopes(self, scopes: list[str]) -> list[str]:
if scopes is None:
return self.scopes
return [scope for scope in self.scopes if scope in scopes]
def get_redirect_uris(self) -> list[str]:
return self.redirect_uris
def get_token_endpoint_auth_method(self) -> str:
return self.token_endpoint_auth_method
def get_grant_types(self) -> list[str]:
return self.grant_types
def get_response_types(self) -> list[str]:
return self.response_types
class MosyneModel(models.Model):
"""Mosyne base model.
All models inherit from this model and set
trhee fields:
- id - The pk represented by UUID v4 string.
- created - The creation datetime.
- updated - The datetime of latest update.
"""
id = fields.UUIDField(pk=True)
created = fields.DatetimeField(auto_now_add=True)
updated = fields.DatetimeField(auto_now=True)
class Meta:
"""Meta info."""
abstract = True
ordering = ["-created", "-updated"]
class PydanticMeta:
"""Pydantic meta settings.
Add query properties:
- max_recursion: Automatic fetch all related fields
with one level of deep.
"""
max_recursion = 1
class AutoResponseModel(Model):
id = fields.UUIDField(pk=True)
trigger = fields.TextField(description="Trigger for the autoresponse")
response = fields.TextField(
default=None,
null=True,
description=
"Response to be sent after being triggered from the trigger",
)
enabled = fields.BooleanField(
default=False, description="Boolean to show of the trigger is enabled")
extra_arguements = fields.BooleanField(
default=False,
description=
"If the autoresponse should be run even when extra arguements are passed",
)
has_variables = fields.BooleanField(
default=False, description="If the autoresponse output has variables")
guild = fields.ForeignKeyField("main.GuildModel",
related_name="Autoresponses")
created_by = fields.ForeignKeyField("main.UserModel",
related_name="Autoresponses",
null=True)
class Meta:
table = "autoresponses"
table_description = "Represents the autoresponses for each GuildModel"
class UUIDFkRelatedNullModel(Model):
id = fields.UUIDField(pk=True)
name = fields.CharField(max_length=50, null=True)
model: fields.ForeignKeyNullableRelation[
UUIDPkModel] = fields.ForeignKeyField("models.UUIDPkModel",
related_name="children_null",
null=True)
class Issue(models.Model):
issue_uuid = fields.UUIDField(unique=True, default=uuid.uuid4)
title = fields.CharField(max_length=255)
description = fields.TextField()
customer = fields.ForeignKeyField(
"models.User", related_name="issues", on_delete=fields.CASCADE
)
city = fields.CharEnumField(enum_type=City, max_length=400)
sub_city = fields.CharEnumField(enum_type=SubCity, max_length=200)
time_to_come_from = fields.DatetimeField()
time_to_come_to = fields.DatetimeField()
amount_from = fields.IntField(null=True)
amount_to = fields.IntField(null=True)
is_negotiable = fields.BooleanField(default=False)
is_open = fields.BooleanField(default=True)
created_at = fields.DatetimeField(auto_now_add=True)
def __str__(self) -> str:
return f"{self.title}"
class Trade(models.Model):
# ==== FROM GRYPHON
trade_id = fields.IntField(pk=True, unique=True)
unique_id = fields.UUIDField(unique=True, default=uuid.uuid4().hex)
exchange_id = fields.ForeignKeyField("models.Exchange")
exchange_trade_id = fields.CharField(max_length=30, unique=True)
time_created = fields.BigIntField(
default=datetime.datetime.utcnow().timestamp())
trade_side = fields.CharField(max_length=5)
pair = fields.CharField(max_length=10)
price = fields.FloatField()
volume = fields.FloatField()
fee = fields.FloatField()
slippage = fields.FloatField()
leverage = fields.IntField(default=0)
order_id: fields.ForeignKeyRelation[Order] = fields.ForeignKeyField(
"models.Order",
related_name="trade",
to_field="order_id",
from_field="trade")
def __str__(self) -> str:
return f"Trade {self.trade_id}: {self.price}"
class CurrencyAccount(Model):
uuid = fields.UUIDField(pk=True)
user = fields.ForeignKeyField('models.User',
related_name='currency_accounts',
index=True)
balance = fields.IntField(default=0)
ran_daily_at = fields.DatetimeField(null=True)
created_at = fields.DatetimeField(null=True, auto_now_add=True)
modified_at = fields.DatetimeField(null=True, auto_now=True)
def get_balance(self) -> float:
bal = self.balance # type: int
return bal / 100.0
def add_to_balance(self, amount: float) -> None:
bal = self.balance # type: int
bal += int(amount * 100)
self.balance = bal
@classmethod
async def get_by_discord_user(
cls, discord_user: DiscordUser) -> 'CurrencyAccount':
user = await User.get_by_discord_user(discord_user)
account, _ = await CurrencyAccount.get_or_create(
user=user) # type: CurrencyAccount, bool
return account
class Meta:
table = 'currency_accounts'
class Game(Model):
id = fields.UUIDField(pk=True)
author = fields.ForeignKeyField('models.User',
related_name='games',
on_delete='CASCADE')
name = fields.CharField(50)
created = fields.DatetimeField(auto_now_add=True, )
class SampleModelChild(Model):
id = fields.UUIDField(pk=True)
name = fields.TextField(max_length=400)
number = fields.IntField()
created = fields.DatetimeField(auto_now_add=True)
data = fields.BinaryField()
sample_model = fields.ForeignKeyField('tests.SampleModel', related_name='childs')
class User(Model):
class Meta:
table = 'users'
id = fields.UUIDField(pk=True)
auth_user: fields.OneToOneRelation[AuthUser] = fields.OneToOneField(
'users.AuthUser',
related_name='user',
source_field='id_auth_user',
to_field='id')
first_name = fields.CharField(max_length=64, null=True)
last_name = fields.CharField(max_length=64, null=True)
email = fields.CharField(max_length=64, null=True)
alarm_type = fields.IntField(default=0)
notification_type = fields.IntField(default=0)
phone = fields.CharField(max_length=64, null=True)
data = fields.JSONField(null=True)
language = fields.CharField(max_length=16, null=False, default=EN)
async def get_display_name(self):
if self.first_name and self.last_name:
return f'{self.first_name} {self.last_name}'
if self.email:
return self.email
return self.auth_user.username
class User(Model, UserMixin):
id = fields.UUIDField(pk=True)
password = fields.CharField(80)
given_name = fields.CharField(24)
middle_name = fields.CharField(64, null=True)
family_name = fields.CharField(64)
nickname = fields.CharField(16, null=True)
preferred_username = fields.CharField(16, null=True)
profile = fields.CharField(128, null=True)
picture = fields.CharField(256, null=True)
website = fields.CharField(128, null=True)
email = fields.CharField(64)
email_verified = fields.BooleanField(default=False)
gender = fields.CharEnumField(Genders, max_length=6, null=True)
birthdate = fields.DateField(null=True)
zoneinfo = fields.CharField(32, null=True)
locale = fields.CharField(16, null=True)
phone_number = fields.CharField(32, null=True)
phone_number_verified = fields.BooleanField(default=False)
address = fields.JSONField(null=True)
created_at = fields.DatetimeField(auto_now_add=True)
updated_at = fields.DatetimeField(auto_now=True)
class Meta:
table = "users"
def get_user_id(self) -> str:
return str(self.id)
class Meal(models.Model):
meal_id = fields.UUIDField(pk=True)
event: fields.ForeignKeyRelation[Event] = fields.ForeignKeyField(
"my_child.Event", related_name="meals", on_delete=fields.CASCADE)
type = fields.IntField()
rations: fields.ReverseRelation["Ration"]
class UserOrder(Base):
"""用户订单表"""
id = fields.IntField(pk=True)
user = fields.ForeignKeyField("market.MarketUser",
"orders",
on_delete=fields.SET_NULL,
null=True)
product_id = fields.UUIDField(index=True) # 商品 ID
product_type = fields.IntEnumField(ProductType) # 商品类型：1= 策略，2= 套餐，3=vip
status = fields.IntEnumField(OrderStatus, default=OrderStatus.unpayed
) # 订单状态：1= 待支付，2= 支付成功，3= 支付失败，4= 取消支付 / 超时
total_cash = fields.FloatField(default=0) # 订单总金额
total_days = fields.IntField(default=0) # 订单总天数
coupon_days = fields.IntField(default=0) # 优惠券抵扣天数
coupon_cash = fields.FloatField(default=0) # 优惠券优惠金额
pay_cash = fields.FloatField(default=0) # 订单需支付金额
days = fields.IntField(default=0) # 购买时长
gift_days = fields.IntField(default=0) # 赠送时长
expire_dt = fields.DatetimeField(null=True) # 过期时间
create_dt = fields.DatetimeField(auto_now_add=True) # 创建时间
update_dt = fields.DatetimeField(auto_now=True)
foreign_order_id = fields.CharField(max_length=32, default="") # 外部订单号
pay_id = fields.CharField(max_length=48, default="") # 支付平台订单号
pay_method = fields.IntEnumField(PayMethod, default=PayMethod.wechat)
pay_url = fields.CharField(max_length=255, default="") # 支付链接（重新支付）
pay_dt = fields.DatetimeField(null=True) # 支付时间
payed_cash = fields.FloatField(default=0) # 已支付金额
source = fields.CharField(max_length=32,
default="default") # 订单来源：pc/mobile
delete = fields.BooleanField(default=False)
coupon = fields.JSONField(default=[]) # 使用的优惠券
product_snapshot = fields.JSONField(default={}) # 商品快照
class BaseModel(models.Model):
id = fields.UUIDField(pk=True)
created_at = fields.DatetimeField(null=True, auto_now_add=True)
modified_at = fields.DatetimeField(null=True, auto_now=True)
""" Database methods """
@classmethod
async def create_one(cls, item):
return await cls.create(**item.dict())
@classmethod
async def find_by(cls, **kwargs):
return await cls.filter(**kwargs).all()
@classmethod
async def find_one(cls, **kwargs):
return await cls.filter(**kwargs).first()
@classmethod
async def update_one(cls, _id: str, item):
await cls.filter(id=_id).update(**item.dict(exclude_unset=True))
return cls.get(id=_id)
@classmethod
async def delete_one(cls, _id: str) -> int:
deleted_count = await cls.filter(id=_id).delete()
return deleted_count
class Meta:
__abstract__ = True
class Book(Model):
def __init__(self, **kwargs):
genres = kwargs.get("genres", [])
for genre in genres:
if not isinstance(genre, BookGenres):
raise TypeError(
"{} is not a BookGenres instance".format(genre))
if genres:
kwargs["genres"] = [genre.value for genre in genres]
super(Book, self).__init__(**kwargs)
id = fields.UUIDField(pk=True, default=uuid.uuid4)
title = fields.TextField()
author = fields.ForeignKeyField("models.Author",
related_name="books",
null=True)
published = fields.DatetimeField(null=True)
status = fields.ForeignKeyField("models.BookStatus", null=True)
retail_price = fields.IntField(null=True)
cost_price = fields.IntField(null=True)
run = fields.IntField(null=True)
volume = fields.IntField(null=True)
# Let's assume we're lazy and don't bother with many-many relationships
genres = JSONEncodedField(null=False,
default=[BookGenres.existential_fiction.value])
class User(BaseModel):
email = fields.CharField(max_length=100, unique=True)
hashed_password = fields.CharField(max_length=200, null=True)
refresh_token = fields.UUIDField(null=True)
username = fields.CharField(max_length=100, required=True)
@classmethod
async def get_active_user(cls, user_id: int = None, email: str = None):
if user_id is not None:
return await cls.get_or_none(id=user_id, deleted_at=None)
if email is not None:
return await cls.get_or_none(email=email, deleted_at=None)
return None
@classmethod
def create(cls, **kwargs):
kwargs["hashed_password"] = auth.get_password_hash(kwargs["password"])
kwargs["refresh_token"] = uuid.uuid4().hex
return super().create(**kwargs)
def get_access_token(self):
return auth.create_access_token(data={
"sub": self.email,
"username": self.username
})
class School(Model):
uuid = fields.UUIDField(pk=True)
name = fields.TextField()
id = fields.IntField(unique=True)
students: fields.ReverseRelation["Student"]
principal: fields.ReverseRelation["Principal"]
class StrategyPackage(Base):
"""套餐表"""
product_id = fields.UUIDField(pk=True)
name = fields.CharField(max_length=64, unique=True, index=True)
market = fields.ForeignKeyField("market.StrategyMarket",
"packages",
on_delete=fields.SET_NULL,
null=True)
tags = fields.JSONField()
desc = fields.TextField()
status = fields.IntEnumField(ListStatus,
default=1) # 套餐状态：1= 正常，2= 下架，3= 删除
limit_copy = fields.IntField() # 连续复制次数
limit_interval = fields.IntField() # 复制间隔
view_cnt = fields.IntField(default=0) # 浏览次数
collect_cnt = fields.IntField(default=0) # 收藏次数
share_cnt = fields.IntField(default=0) # 分享次数
buyout_price = fields.FloatField() # 买断价格
# 时段购买价格信息 [{"day": 20, "gift_day": 20, "price": 350}, ...]
period_prices = fields.JSONField()
enable_discount = fields.BooleanField(default=True)
# 折扣信息 [{"start_dt": xxx, "end_dt": xxx, "day": 10, "gift_day": 10, "price": 200}, ...]
discount_info = fields.JSONField()
allow_coupon = fields.BooleanField() # 是否可使用优惠券
create_dt = fields.DatetimeField(auto_now_add=True) # 最初申请上架时间
update_dt = fields.DatetimeField(auto_now=True)
online_dt = fields.DatetimeField(null=True)
offline_dt = fields.DatetimeField(null=True)
# reverse relations
strategies: fields.ReverseRelation["market.models.QStrategy"]
class Assignment(models.Model):
"""The assignment model."""
id = fields.UUIDField(pk=True)
title = fields.CharField(max_length=100)
description = fields.TextField()
file = fields.TextField(null=True)
section = fields.ForeignKeyField(
model_name="models.Section",
related_name="assignments",
on_delete=fields.CASCADE,
)
slug = fields.CharField(unique=True, max_length=200, null=True)
created_at = fields.DatetimeField(auto_now_add=True)
updated_at = fields.DatetimeField(auto_now=True)
class Meta:
"""Meta data."""
table = "assignment"
def __str__(self: "Assignment") -> str:
"""The string representative for course class."""
return f"{self.title}"
class Requirement(models.Model):
"""The requirement model."""
id = fields.UUIDField(pk=True)
name = fields.CharField(max_length=100)
course = fields.ForeignKeyField(
model_name="models.Course",
related_name="requirements",
on_delete=fields.CASCADE,
)
created_at = fields.DatetimeField(auto_now_add=True)
updated_at = fields.DatetimeField(auto_now=True)
class Meta:
"""Meta data."""
table = "requirement"
def __str__(self: "Requirement") -> str:
"""The string representative for course class."""
return f"{self.name} for {self.course}"
class BookMark(models.Model):
"""The bookmark model."""
id = fields.UUIDField(pk=True)
course = fields.ForeignKeyField(
model_name="models.Course",
related_name="book_marks",
on_delete=fields.CASCADE,
)
student = fields.ForeignKeyField(
model_name="models.Student",
related_name="book_marks",
on_delete=fields.CASCADE,
)
created_at = fields.DatetimeField(auto_now_add=True)
updated_at = fields.DatetimeField(auto_now=True)
class Meta:
"""Meta data."""
table = "bookmark"
def __str__(self: "BookMark") -> str:
"""The string representative for course class."""
return f"book marked {self.course} for {self.student}"
class Enrollment(models.Model):
"""The enrollment model."""
id = fields.UUIDField(pk=True)
course = fields.ForeignKeyField(
model_name="models.Course",
related_name="enrollments",
on_delete=fields.CASCADE,
)
student = fields.ForeignKeyField(
model_name="models.Student",
related_name="enrollments",
on_delete=fields.CASCADE,
)
created_at = fields.DatetimeField(auto_now_add=True)
updated_at = fields.DatetimeField(auto_now=True)
class Meta:
"""Meta data."""
table = "enrollment"
def __str__(self: "Enrollment") -> str:
"""The string representative for course class."""
return f"{self.student} enrollment for {self.course}"
class Review(models.Model):
"""The review model."""
id = fields.UUIDField(pk=True)
course = fields.ForeignKeyField(model_name="models.Course",
on_delete=fields.CASCADE,
related_name="reviews")
rate = fields.IntField()
review = fields.TextField()
student = fields.ForeignKeyField(
model_name="models.Student",
related_name="reviews",
on_delete=fields.SET_NULL,
null=True,
)
created_at = fields.DatetimeField(auto_now_add=True)
updated_at = fields.DatetimeField(auto_now=True)
class Meta:
"""Meta data."""
table = "review"
def __str__(self: "Review") -> str:
"""The string representative for course class."""
return f"{self.course} by {self.student}"
class Lecture(models.Model):
"""The lecture model."""
id = fields.UUIDField(pk=True)
title = fields.CharField(max_length=100)
text = fields.TextField(null=True)
video = fields.CharField(null=True, max_length=200)
section = fields.ForeignKeyField(
model_name="models.Section",
on_delete=fields.CASCADE,
related_name="lectures",
)
order = models.IntField()
slug = fields.CharField(unique=True, max_length=200, null=True)
created_at = fields.DatetimeField(auto_now_add=True)
updated_at = fields.DatetimeField(auto_now=True)
class Meta:
"""Meta data."""
table = "lecture"
def __str__(self: "Lecture") -> str:
"""The string representative for course class."""
return f"{self.title}"
class Section(models.Model):
"""The section model."""
id = fields.UUIDField(pk=True)
title = fields.CharField(max_length=100)
objective = fields.TextField()
course = fields.ForeignKeyField(
model_name="models.Course",
on_delete=fields.CASCADE,
related_name="sections",
)
order = models.IntField()
slug = fields.CharField(unique=True, max_length=200, null=True)
created_at = fields.DatetimeField(auto_now_add=True)
updated_at = fields.DatetimeField(auto_now=True)
class Meta:
"""Meta data."""
table = "section"
def __str__(self: "Section") -> str:
"""The string representative for course class."""
return f"Section {self.order}: {self.title}"
class WordleResults(Model):
uuid = fields.UUIDField(pk=True)
name = fields.TextField(default='wordle result')
user = fields.ForeignKeyField('models.User',
related_name='wordle_results',
index=True)
guesses = fields.IntField() # guesses to solve word (0 for quit)
word = fields.TextField() # word guessed
created_at = fields.DatetimeField(null=True, auto_now_add=True)
@classmethod
async def create_result(cls, discord_user: DiscordUser, guesses: int,
word: str) -> None:
user = await User.get_by_discord_user(discord_user)
result = WordleResults(user=user, guesses=guesses, word=word)
await result.save()
@classmethod
async def fetch_all_by_user(cls, discord_user: DiscordUser) -> Any:
user = await User.get_by_discord_user(discord_user)
stat = await WordleResults.filter(user=user)
return stat
class Meta:
table = 'wordle_results'
class Team(Model):
id = fields.UUIDField(pk=True)
name = data.CharField(max_length=50, editable=True)
members: fields.ReverseRelation["User"]
rooms: fields.ReverseRelation["Room"]
def __str__(self):
return self.name
