class Feed(Model, Base):
"""
Feed model.
Stores feeds and their info.
"""
id = fields.IntField(pk=True)
state = fields.SmallIntField(default=1, description='Feed state: '
'0=deactivated, 1=activated')
link = fields.CharField(max_length=4096, # hey, is there really any rss feed url > 4096B?
unique=True, # will also be indexed
description='Feed link')
title = fields.CharField(max_length=1024, description='Feed title')
interval = fields.SmallIntField(null=True, description='Monitoring task interval. '
'Should be the minimal interval of all subs to the feed,'
'default interval will be applied if null')
entry_hashes = fields.JSONField(null=True, description='Hashes (CRC32) of entries')
etag = fields.CharField(max_length=128, null=True,
description='The etag of webpage, will be changed each time the feed is updated. '
'Can be null because some websites do not support')
last_modified = fields.DatetimeField(null=True, description='The last modified time of webpage. ')
error_count = fields.SmallIntField(default=0,
description='Error counts. If too many, deactivate the feed. '
'+1 if an error occurs, reset to 0 if feed fetched successfully')
next_check_time = fields.DatetimeField(null=True,
description='Next checking time. '
'If too many errors occur, let us wait sometime')
subs: fields.ReverseRelation['Sub']
class Meta:
table = 'feed'
def __str__(self):
return self.link
class Tournaments(Model):
class Meta:
table = 'tournaments'
unique_together = ('schedule_type', 'slug')
id = fields.IntField(pk=True)
schedule_type = fields.CharField(45, null=True)
slug = fields.CharField(45, null=True)
guild_id = fields.BigIntField(null=True)
helper_roles = fields.CharField(2000, null=True)
audit_channel_id = fields.BigIntField(null=True)
commentary_channel_id = fields.BigIntField(null=True)
scheduling_needs_channel_id = fields.BigIntField(null=True)
scheduling_needs_tracker = fields.SmallIntField(null=True)
mod_channel_id = fields.BigIntField(null=True)
tracker_roles = fields.CharField(2000, null=True)
commentator_roles = fields.CharField(2000, null=True)
mod_roles = fields.CharField(2000, null=True)
admin_roles = fields.CharField(2000, null=True)
category = fields.CharField(200, null=True)
goal = fields.CharField(200, null=True)
active = fields.SmallIntField(null=True)
has_submission = fields.BooleanField(null=True)
lang = fields.CharField(20, null=True)
coop = fields.BooleanField(null=True)
class DiscordGuild(Model):
id = fields.IntField(pk=True)
discord_id = fields.BigIntField(index=True)
name = fields.TextField()
prefix = fields.CharField(20, null=True)
permissions = fields.JSONField(default={})
language = fields.CharField(6, default="en")
overtime_confirmed = fields.BooleanField(default=False)
is_premium = fields.BooleanField(default=False)
enable_tips = fields.BooleanField(default=True)
disable_simulations = fields.BooleanField(default=False)
used_updaters = fields.SmallIntField(default=0)
total_updaters = fields.SmallIntField(default=1)
minigame_enabled = fields.BooleanField(default=False)
log_channel = fields.BigIntField(default=None, null=True)
infected_role = fields.BigIntField(default=None, null=True)
cured_role = fields.BigIntField(default=None, null=True)
dead_role = fields.BigIntField(default=None, null=True)
class Meta:
table = "guilds"
def __str__(self):
return self.name
def __repr__(self):
return f"<Guild name={self.name}>"
class Botbakuadmin_beer(Model):
style = fields.CharField(max_length=64)
ibu = fields.SmallIntField()
abv = fields.FloatField()
og = fields.SmallIntField()
country = fields.CharField(max_length=64)
manufacturer = fields.CharField(max_length=64)
size = fields.FloatField()
class Journal(Model):
timestamp = fields.DatetimeField(auto_now_add=True)
level = fields.SmallIntField(index=True)
text = fields.CharField(max_length=255, index=True)
col_float1 = fields.FloatField(default=2.2)
col_smallint1 = fields.SmallIntField(default=2)
col_int1 = fields.IntField(default=2000000)
col_bigint1 = fields.BigIntField(default=99999999)
col_char1 = fields.CharField(max_length=255, default='value1')
col_text1 = fields.TextField(
default='Moo,Foo,Baa,Waa,Moo,Foo,Baa,Waa,Moo,Foo,Baa,Waa')
col_decimal1 = fields.DecimalField(12, 8, default=Decimal('2.2'))
col_json1 = fields.JSONField(default={
'a': 1,
'b': 'b',
'c': [2],
'd': {
'e': 3
},
'f': True
})
col_float2 = fields.FloatField(null=True)
col_smallint2 = fields.SmallIntField(null=True)
col_int2 = fields.IntField(null=True)
col_bigint2 = fields.BigIntField(null=True)
col_char2 = fields.CharField(max_length=255, null=True)
col_text2 = fields.TextField(null=True)
col_decimal2 = fields.DecimalField(12, 8, null=True)
col_json2 = fields.JSONField(null=True)
col_float3 = fields.FloatField(default=2.2)
col_smallint3 = fields.SmallIntField(default=2)
col_int3 = fields.IntField(default=2000000)
col_bigint3 = fields.BigIntField(default=99999999)
col_char3 = fields.CharField(max_length=255, default='value1')
col_text3 = fields.TextField(
default='Moo,Foo,Baa,Waa,Moo,Foo,Baa,Waa,Moo,Foo,Baa,Waa')
col_decimal3 = fields.DecimalField(12, 8, default=Decimal('2.2'))
col_json3 = fields.JSONField(default={
'a': 1,
'b': 'b',
'c': [2],
'd': {
'e': 3
},
'f': True
})
col_float4 = fields.FloatField(null=True)
col_smallint4 = fields.SmallIntField(null=True)
col_int4 = fields.IntField(null=True)
col_bigint4 = fields.BigIntField(null=True)
col_char4 = fields.CharField(max_length=255, null=True)
col_text4 = fields.TextField(null=True)
col_decimal4 = fields.DecimalField(12, 8, null=True)
col_json4 = fields.JSONField(null=True)
class Journal(Model):
timestamp = fields.DatetimeField(auto_now_add=True)
level = fields.SmallIntField(index=True)
text = fields.CharField(max_length=255, index=True)
col_float1 = fields.FloatField(default=2.2)
col_smallint1 = fields.SmallIntField(default=2)
col_int1 = fields.IntField(default=2000000)
col_bigint1 = fields.BigIntField(default=99999999)
col_char1 = fields.CharField(max_length=255, default="value1")
col_text1 = fields.TextField(
default="Moo,Foo,Baa,Waa,Moo,Foo,Baa,Waa,Moo,Foo,Baa,Waa")
col_decimal1 = fields.DecimalField(12, 8, default=Decimal("2.2"))
col_json1 = fields.JSONField(default={
"a": 1,
"b": "b",
"c": [2],
"d": {
"e": 3
},
"f": True
})
col_float2 = fields.FloatField(null=True)
col_smallint2 = fields.SmallIntField(null=True)
col_int2 = fields.IntField(null=True)
col_bigint2 = fields.BigIntField(null=True)
col_char2 = fields.CharField(max_length=255, null=True)
col_text2 = fields.TextField(null=True)
col_decimal2 = fields.DecimalField(12, 8, null=True)
col_json2 = fields.JSONField(null=True)
col_float3 = fields.FloatField(default=2.2)
col_smallint3 = fields.SmallIntField(default=2)
col_int3 = fields.IntField(default=2000000)
col_bigint3 = fields.BigIntField(default=99999999)
col_char3 = fields.CharField(max_length=255, default="value1")
col_text3 = fields.TextField(
default="Moo,Foo,Baa,Waa,Moo,Foo,Baa,Waa,Moo,Foo,Baa,Waa")
col_decimal3 = fields.DecimalField(12, 8, default=Decimal("2.2"))
col_json3 = fields.JSONField(default={
"a": 1,
"b": "b",
"c": [2],
"d": {
"e": 3
},
"f": True
})
col_float4 = fields.FloatField(null=True)
col_smallint4 = fields.SmallIntField(null=True)
col_int4 = fields.IntField(null=True)
col_bigint4 = fields.BigIntField(null=True)
col_char4 = fields.CharField(max_length=255, null=True)
col_text4 = fields.TextField(null=True)
col_decimal4 = fields.DecimalField(12, 8, null=True)
col_json4 = fields.JSONField(null=True)
class SpecialItem(BaseModel):
post_id = fields.IntField()
index = fields.SmallIntField()
special_id = fields.SmallIntField()
class Meta:
table = 'special_item'
@classmethod
@cache(MC_KEY_SPECIAL_BY_PID % ('{post_id}'))
async def get_special_id_by_pid(cls, post_id: int) -> List[Any]:
return await SpecialItem.filter(post_id=post_id).values_list(
'special_id', flat=True)
class Account(models.Model):
# surrogate primary key
spk = fields.SmallIntField(pk=True, generated=True)
# time at which we took the snapshot
time_recorded = fields.DatetimeField(auto_now=True)
# event responsible for the creation of the record
event = fields.CharField(max_length=40)
balances = fields.JSONField()
exposure = fields.JSONField(null=True)
open_positions = fields.JSONField(null=True)
# foreign key relationships (must contain suffix "_id" when referenced)
exchange = fields.ForeignKeyField("models.Exchange")
# exchange: fields.ForeignKeyRelation[Exchange] = fields.ForeignKeyField("models.Exchange",
# related_name="balance",
# to_field="id",
# from_field="exchange"
# )
def __str__(self) -> str:
return f"Exchange {self.exchange}: {self.holdings}"
class Users(Model):
id = fields.IntField(pk=True)
user_id = fields.IntField(unique=True)
attempts = fields.SmallIntField(default=env.START_ATTEMPTS)
category = fields.TextField(null=True)
gender = fields.TextField(null=True)
referals = fields.SmallIntField(default=0)
step = fields.TextField(null=True)
role = fields.TextField(default="user")
pic_id = fields.SmallIntField(null=True)
text = fields.TextField(null=True)
message_id = fields.IntField(default=0)
promocode_ids = fields.TextField(null=True)
def __str__(self):
return self.user_id
class User(Model, Base):
"""
User model.
Stores users, their info and their default feed options.
"""
id = fields.BigIntField(pk=True, description='Telegram user id, 8Bytes')
state = fields.SmallIntField(
default=0,
description='User state: '
'-1=banned, 0=guest, 1=user, 50=channel, 51=group, 100=admin')
lang = fields.CharField(default='zh-Hans',
max_length=16,
description='Preferred language, lang code')
admin = fields.BigIntField(
null=True,
description='One of the admins of the channel or group, '
'can be null if this "user" is not a channel or a group')
subs: fields.ReverseRelation['Sub']
# default options of a user's feeds
# interval = fields.SmallIntField(null=True)
# notify = fields.SmallIntField(null=True)
# send_mode = fields.SmallIntField(null=True)
# length_limit = fields.SmallIntField(null=True)
# display_author = fields.SmallIntField(null=True)
# display_via = fields.SmallIntField(null=True)
# display_title = fields.SmallIntField(null=True)
class Meta:
table = 'user'
def __str__(self):
return self.id
class Tournament(Model):
tid = fields.SmallIntField(pk=True)
name = fields.CharField(max_length=100, description="Tournament name", index=True)
created = fields.DatetimeField(auto_now_add=True, description="Created */'`/* datetime")
class Meta:
table_description = "What Tournaments */'`/* we have"
class PatchDistribution(Model):
class Meta:
table = 'patch_distribution'
id = fields.IntField(pk=True)
patch_id = fields.CharField(45, null=True)
game = fields.CharField(45, null=True)
used = fields.SmallIntField(index=True)
class Promo(Model):
id = fields.IntField(pk=True)
name = fields.TextField()
attempts = fields.SmallIntField()
activate = fields.IntField(default=0)
def __str__(self):
return f"{self.name} - {self.attempts}"
class Tournament(Model):
id = fields.SmallIntField(pk=True)
name = fields.CharField(max_length=255)
desc = fields.TextField(null=True)
created = fields.DatetimeField(auto_now_add=True, index=True)
def __str__(self):
return self.name
class WarningCV(TimestampMixin, Model):
frame = fields.TextField(null=True)
duration = fields.TimeDeltaField()
report: fields.ForeignKeyRelation[Report] = fields.ForeignKeyField('models.Report', related_name='warnings')
type_warning = fields.SmallIntField(default=1)
class Meta:
table = 'warning'
class Journal(Model):
timestamp = fields.DatetimeField(auto_now_add=True)
level = fields.SmallIntField(index=True)
text = fields.CharField(max_length=255, index=True)
parent = fields.ForeignKeyField("models.Journal",
related_name="children",
null=True)
related = fields.ManyToManyField("models.Journal",
related_name="related_from")
class Backtest(models.Model):
name = fields.CharField(max_length=50)
description = fields.TextField()
exchange = fields.CharField(max_length=40)
symbol = fields.CharField(max_length=20)
timeframe = fields.SmallIntField()
performance = fields.JSONField()
parameters = fields.JSONField()
class WorkModel(BaseModel):
'''
农事表
'''
class Meta:
table = "agro_cloud_doctor_work"
plant_id = fields.IntField(null=True)
operator_id = fields.IntField(null=True)
operator_name = fields.CharField(40, null=True)
content = fields.TextField(default="")
work_type = fields.CharField(50, default="")
assigner = fields.CharField(40, default="")
assigner_id = fields.IntField(null=True)
approver = fields.CharField(40, default="")
approver_id = fields.IntField(null=True)
aim_datetime = fields.DatetimeField(null=True)
start_datetime = fields.DatetimeField(null=True)
end_datetime = fields.DatetimeField(null=True)
# cost = fields.DecimalField(max_digits=15, decimal_places=3)
status = fields.CharEnumField(WorkStatusMapping,
default=WorkStatusMapping.awaiting)
snapshot = fields.TextField(default="")
commitStatus = fields.SmallIntField(default=0)
isShow = fields.SmallIntField(default=0) # 是否展示
work_hours = fields.FloatField(default=0.0)
customer_id = fields.IntField()
# 种植位置
plant_position = fields.CharField(255, default="")
def __str__(self):
return self.id
@classmethod
async def get_statistic(cls, userId):
works = await cls.filter(operator_id=userId,
status=WorkStatusMapping.success.value).all()
totalSeconds = 0
for item in works:
totalSeconds += (item.start_datetime -
item.end_datetime).total_seconds()
return totalSeconds
class Offer(BaseModel):
value = fields.DecimalField(14, 2)
installments = fields.SmallIntField()
tax_rate_percent_monthly = fields.DecimalField(3, 2)
total_value = fields.DecimalField(14, 2)
offer_package = fields.ForeignKeyField("models.OfferPackage",
related_name="offers")
partner = fields.ForeignKeyField("models.Partner",
related_name="offers_partner")
customer = fields.ForeignKeyField("models.Customer",
related_name="offers_customer")
class ReactionRole(Model):
class Meta:
table = 'reaction_role'
id = fields.IntField(pk=True)
guild_id = fields.BigIntField(null=False)
reaction_group = fields.ForeignKeyField('models.ReactionGroup', related_name='reaction_roles')
role_id = fields.BigIntField(null=True)
name = fields.CharField(45, null=True)
emoji = fields.CharField(200, null=True)
protect_mentions = fields.SmallIntField(null=True)
class User(Model):
class Meta:
table = "users"
id = fields.IntField(pk=True)
username = fields.CharField(max_length=32, null=False, unique=True)
age = fields.SmallIntField()
address = fields.CharField(max_length=256, null=False)
mobile = fields.CharField(max_length=16)
def __str__(self):
return self.username
class Exchange(models.Model):
# primary key
id = fields.SmallIntField(pk=True, generated=False)
name = fields.CharField(max_length=20)
# balance = fields.ReverseRelation["models.Balance"]
# trade = fields.ReverseRelation["models.Trade"]
def __str__(self) -> str:
return f"Exchange {self.name}: ID#{self.exchange_id}"
class Tournament(Model):
id = fields.SmallIntField(pk=True)
name = fields.CharField(max_length=255)
desc = fields.TextField(null=True)
created = fields.DatetimeField(auto_now_add=True, index=True)
events: fields.ReverseRelation["Event"]
minrelations: fields.ReverseRelation["MinRelation"]
uniquetogetherfieldswithfks: fields.ReverseRelation["UniqueTogetherFieldsWithFK"]
def __str__(self):
return self.name
class ChatUser(BaseEntityMixin):
"""
Models a chat user.
"""
# personal data
first_name = fields.CharField(max_length=255)
last_name = fields.CharField(max_length=255)
age = fields.SmallIntField()
# app data
nick_name = fields.CharField(max_length=255, unique=True)
class TournamentGames(Model):
class Meta:
table = 'tournament_games'
episode_id = fields.IntField(pk=True, generated=False)
event = fields.CharField(45, null=True)
game_number = fields.IntField(null=True)
settings = fields.JSONField(null=True)
preset = fields.CharField(100, null=True)
notes = fields.TextField(null=True)
submitted = fields.SmallIntField(null=True)
created = fields.DatetimeField(auto_now_add=True)
updated = fields.DatetimeField(auto_now=True)
class DiscordUser(Model):
id = fields.IntField(pk=True)
discord_id = fields.BigIntField(index=True)
name = fields.TextField()
discriminator = fields.CharField(4)
last_modified = fields.DatetimeField(auto_now=True)
times_ran_example_command = fields.IntField(default=0)
permissions = fields.JSONField(default={})
language = fields.CharField(6, default="en")
is_premium = fields.BooleanField(default=False)
future_simulation = fields.ForeignKeyField('models.FutureSimulations')
updater_credits = fields.SmallIntField(default=0)
opened_support_tickets = fields.SmallIntField(default=0)
class Meta:
table = "users"
def __str__(self):
return self.name
def __repr__(self):
return f"<User name={self.name}#{self.discriminator}>"
class LeaguePlayoffs(Model):
class Meta:
table = 'league_playoffs'
episode_id = fields.IntField(pk=True, generated=False)
playoff_round = fields.CharField(45, null=True)
game_number = fields.IntField(null=True)
type = fields.CharField(45, null=True)
preset = fields.CharField(45, null=True)
settings = fields.JSONField(null=True)
submitted = fields.SmallIntField(null=True)
created = fields.DatetimeField(auto_now_add=True)
modified = fields.DatetimeField(auto_now=True)
class SpeedGamingDailies(Model):
class Meta:
table = 'sgdailies'
id = fields.IntField(pk=True)
slug = fields.CharField(45, null=True)
guild_id = fields.BigIntField(null=False)
announce_channel = fields.BigIntField(null=False)
announce_message = fields.BigIntField(null=False)
racetime_category = fields.CharField(45, null=True)
racetime_goal = fields.CharField(45, null=True)
race_info = fields.CharField(2000, null=False)
active = fields.SmallIntField(null=True)
class Strategy(models.Model):
# surrogate primary key
spk = fields.SmallIntField(pk=True, generated=True)
# for discretionary trades, we will assign it the id 0
# avoid calling any parameter "id": tortoise reserves it for primary keys
strategy_id = fields.IntField(unique=True, default=random.getrandbits(32))
# name of strategy
name = fields.CharField(max_length=15)
# description of the strategy
description = fields.TextField(null=True)
# type of trading the strategy does (eg trend-following, mean-reversion etc)
timeframe = fields.IntField(null=True)
class CallRecord(Model):
created_at: datetime = fields.DatetimeField(auto_now_add=True)
updated_at: datetime = fields.DatetimeField(auto_now=True, null=True)
call: fields.ForeignKeyRelation[Call] = fields.ForeignKeyField(
model_name='models.Call',
related_name='records',
on_delete=fields.CASCADE,
unique=True)
file_name: str = fields.CharField(max_length=150)
remove_at: datetime = fields.DatetimeField(null=True)
# download attempts count
attempts_count: int = fields.SmallIntField(null=False, default=0)
class Meta:
table = 'call_records'
