class QuestionModel(db.DynamicDocument):
"""
正常使用的题目 question
"""
text = db.StringField(max_length=40960)
level = db.IntField(min_value=1, max_value=10)
q_type = db.IntField(min_value=1, max_value=6) # type是留字，可能会有一些坑，故使用q_type
# 1 朗读 2 复述 3 问答 4 选择 5 短文本英文阅读 6 长文本英文阅读
used_times = db.IntField(min_value=0, default=0)
up_count = db.IntField(min_value=0, default=0) # 疑似废弃字段？feedback_ups 替代
down_count = db.IntField(min_value=0,
default=0) # 疑似废弃字段？feedback_downs 替代
wordbase = db.DictField(default={})
weights = db.DictField(default={})
questions = db.ListField(default=None) # 选择题集合可以包含若干选择题
index = db.IntField(min_value=0) # 题号，从0开始
in_optimize = db.BooleanField(default=False) # 现在是否在优化中
last_optimize_time = db.DateTimeField(default=None) # 最后优化时间
auto_optimized = db.BooleanField(default=False) # 是否被自动优化过
feedback_ups = db.IntField(default=0) # 短时重复切换状态时，请求可能不按顺序到达，可能短时间内<0
feedback_downs = db.IntField(default=0)
feedback_likes = db.IntField(default=0)
meta = {'collection': 'questions'}
def __str__(self):
return "{id:%s,text:%s,level:%s,q_type:%s,used_times:%s,wordbase:%s}" % (
self.id, self.text.__str__(), self.level.__str__(),
self.q_type.__str__(), self.used_times.__str__(),
self.wordbase.__str__())
class User(db.Document):
name: db.StringField(default=True)
email = db.EmailField(unique=True)
password = db.StringField(default=True)
active = db.BooleanField(default=True)
isAdmin = db.BooleanField(default=False)
timestamp = db.DateTimeField(default=datetime.datetime.now())
class SnippetPost(db.Document):
desc = db.StringField(required=True)
user_id = db.StringField(required=True)
user_name = db.StringField()
access_type = db.StringField()
language = db.StringField()
frameworks = db.ListField()
code = db.StringField()
verified = db.BooleanField()
posted_on = db.DateTimeField()
likes = db.IntField()
share_id = db.StringField()
liked = db.BooleanField(default=False)
def to_json(self):
return {
"desc": self.desc,
"access_type": self.access_type,
"user_id": self.user_id,
"user_name": self.user_name,
"language": self.language,
"frameworks": self.frameworks,
"code": self.code,
"verified": self.verified,
"posted_on": self.posted_on,
"likes": self.likes,
"share_id": self.share_id,
"liked": self.liked
}
class ChannelProvider(db.Document):
meta = {
'db_alias': 'db_order',
}
name = db.StringField()
display_name = db.StringField()
description = db.StringField()
service_intro = db.DictField()
country = db.StringField()
is_active = db.BooleanField(default=False)
shipping = db.FloatField(required=True)
is_recommended = db.BooleanField(default=False)
def __repr__(self):
return '<ChannelProvider {}>'.format(self.name)
@classmethod
def get_shipping(cls, channel_name, country):
if not channel_name:
channel_name = 'default'
provider = cls.objects(name=channel_name, country=country).first()
return provider.shipping
@queryset_manager
def active(doc_cls, queryset):
return queryset.filter(is_active=True)
def to_json(self):
return dict(name=self.name,
display_name=self.display_name,
service_intro=self.service_intro,
desc=self.description)
class AfterSellBilling(db.Document):
REPLACE = 1
REFUND = 2
WAITING = 'waiting'
PROCESSING = 'processing'
REFUSED = 'refused'
DONE = 'done'
billing = db.ReferenceField(Billing, required=True)
isbn = db.StringField(required=True)
number = db.IntField(required=True, default=1)
type = db.IntField(required=True)
reason = db.StringField()
is_done = db.BooleanField(default=False) # 售后账单是否完成
canceled = db.BooleanField(default=False) # 售后账单是否已经取消
user = db.ReferenceField(User, required=True)
create_time = db.IntField(required=True, default=time_int)
process = db.StringField(default=WAITING)
process_change_time = db.IntField()
feedback = db.EmbeddedDocumentListField(BillingStatus)
carts = db.ListField(db.ReferenceField(Cart))
def change_process_status(self, next_process):
self.process = next_process
self.process_change_time = time_int()
self.save()
@classmethod
def status_to_string(cls, index):
status = {
"1": "REPLACE",
"2": "REFUND",
}
return status.get(str(index))
def save(self):
super(AfterSellBilling, self).save()
if not self.process_change_time:
self.process_change_time = self.create_time
self.save()
return self
def get_cart(self):
"""
从 billing 中找出属于该售后订单的 Cart
:return: Cart list
"""
return self.carts
all_carts = self.billing.carts
this_after_selling_carts = []
for cart in all_carts:
if isinstance(cart.in_after_selling_time, int):
if self.create_time - cart.in_after_selling_time in range(
0, 6):
this_after_selling_carts.append(cart)
return this_after_selling_carts
class User(db.Document):
email = db.EmailField(unique=True)
password = db.StringField(default=True)
active = db.BooleanField(default=True)
is_superuser = db.BooleanField(default=False)
is_staff = db.BooleanField(default=False)
last_login = db.DateTimeField(default=datetime.datetime.now())
date_joined = db.DateTimeField(default=datetime.datetime.now())
authenticated = db.BooleanField(default=False)
def set_password(self, password):
self.password = flask_bcrypt.generate_password_hash(password)
def check_password(self, password):
return flask_bcrypt.check_password_hash(self.password, password)
def is_anonymous(self):
return not self.authenticated
def is_active(self):
return self.active
def is_authenticated(self):
return self.authenticated
def get_id(self):
return self.id
class Roles(db.EmbeddedDocument):
"""
Doc embedded in User showing users permissions, roles, and rights.
"""
can_login = db.BooleanField(default=False)
can_comment = db.BooleanField(default=True)
can_post = db.BooleanField(default=True)
is_admin = db.BooleanField(default=False)
class Coupon(db.Document):
meta = {
'db_alias': 'db_order',
'indexes': ['code', 'apply', 'expire_date', 'description'],
'strict': False,
}
scope = db.StringField(required=True,
choices=COUPON_SCOPE,
default=COUPON_SCOPE.ORDER)
coupon_type = db.StringField(default=COUPON_SCOPE.NORMAL,
required=True,
choices=COUPON_TYPES)
value = db.FloatField()
description = db.StringField()
effective_date = db.DateTimeField(default=datetime.utcnow)
expire_date = db.DateTimeField(default=datetime(2022, 12, 31))
code = db.StringField(unique=True)
apply = db.StringField(required=True,
default=COUPON_APPLY.BY_DISPLAY_ID,
choices=COUPON_APPLY)
required_amount = db.FloatField(default=0)
required_final = db.FloatField(default=0)
required_new_order = db.BooleanField(default=False)
once_per_user = db.BooleanField(default=False)
note = db.StringField()
coupon_category = db.StringField(
choices=['PROMOTION', 'STAFF', 'NEW_USER'], default='PROMOTION')
@property
def is_expired(self):
if not self.expire_date:
return False
return datetime.utcnow() >= self.expire_date
def to_json(self):
return dict(
coupon_type=self.coupon_type,
value=self.value,
code=self.code,
effective_date=format_date(self.effective_date, '%Y-%m-%d'),
expire_date=format_date(self.expire_date, '%Y-%m-%d'),
is_expired=self.is_expired,
description=self.description,
)
def is_effective(self):
return self.effective_date <= datetime.utcnow() < self.expire_date
def can_apply(self, order):
res = bool(
self.required_final <= order.final
and self.required_amount <= order.amount
and not (self.require_new_order and order.customer.orders) and
not (self.once_per_user and order.customer.used_coupon(self.code)))
return res
class WallPosts(db.Document): author = db.GenericReferenceField(db_field='au', verbose_name='Autor') title = db.StringField(db_field='tl', verbose_name='Titlu') content = db.StringField(db_field='ct', verbose_name='Continut', required=True) timestamp = db.DateTimeField(db_field='ts', verbose_name='Data') sticky = db.BooleanField(db_field='st', verbose_name='Sticky', default=False) announce = db.BooleanField(db_field='an', verbose_name='Anunt') comments = db.ListField(db.GenericReferenceField(), db_field='cm',verbose_name='Comentarii')
class User(db.Document):
first_name = db.StringField(max_length=50, unique=True)
last_name = db.StringField(max_length=50)
email = db.StringField()
children = db.ListField(
db.ReferenceField("self", reverse_delete_rule=CASCADE))
admin = db.BooleanField(default=False)
faculty = db.BooleanField(default=False)
meta = {'allow_inheritance': True}
def __repr__(self):
return f'<User: {self.first_name} {self.last_name}'
class GameRoom(db.Document):
word = db.StringField(default="")
waiting = db.BooleanField(default=True)
currentQuestion = db.StringField(default="")
gameFinished = db.BooleanField(default=False)
winner = db.ListField(db.StringField())
bothAnswered = db.BooleanField(default=False)
members = db.ListField(db.EmbeddedDocumentField(Player),default=list)
answers = db.ListField(db.EmbeddedDocumentField(PlayerAnswer))
questions = db.ListField(db.StringField())
hasBot = db.BooleanField(default=False)
botName = db.StringField(default="")
created_at = db.DateTimeField(default=datetime.datetime.utcnow)
class UserAddress(db.Document):
"""
用户收获地址
"""
name = db.StringField(required=True)
phone = db.StringField(required=True)
dormitory = db.StringField(required=True)
enabled = db.BooleanField(required=True, default=True)
user = db.ReferenceField(User)
is_default = db.BooleanField(required=True, default=False)
def __unicode__(self):
return u"{}\n{}\n{}".format(self.name, self.phone, self.dormitory)
class LogisticProvider(db.Document, WeightPrice):
meta = {
'db_alias': 'db_order',
}
name = db.StringField()
display_name = db.StringField()
description = db.StringField()
service_intro = db.DictField()
logo = db.StringField()
country = db.StringField()
is_active = db.BooleanField(default=False)
rule_desc = db.StringField()
init_price = db.FloatField(required=True)
init_weight = db.IntField(required=True)
continued_price = db.FloatField(required=True)
continued_weight = db.FloatField(required=True)
init_coin = db.IntField(default=0)
features = db.ListField(db.StringField())
promotion = db.StringField(default='')
limited_weight = db.IntField(required=True)
limited_category = db.ListField(db.StringField())
is_recommended = db.BooleanField(default=False)
rating = db.DecimalField(precision=1)
rating_users = db.IntField()
def __repr__(self):
return '<LogisticProvider {}>'.format(self.name)
@classmethod
def get_provider_shipping(cls, logistic_name, country, weight):
if not logistic_name:
logistic_name = 'default'
provider = cls.objects(name=logistic_name, country=country).first()
return provider.get_shipping(weight)
@queryset_manager
def active(doc_cls, queryset):
return queryset.filter(is_active=True)
def to_json(self):
return dict(
name=self.name,
display_name=self.display_name,
service_intro=self.service_intro,
desc=self.description,
)
class UserActivity(db.EmbeddedDocument):
created = db.DateTimeField(default=lambda: now())
email_verification = db.EmbeddedDocumentField(EmailVerification,
default=EmailVerification)
password_reset = db.EmbeddedDocumentField(PasswordReset,
default=PasswordReset)
user_restricted = db.BooleanField(default=False)
failed_logins = db.IntField(default=0)
user_banned = db.BooleanField(default=False)
valid_tokens = db.ListField()
payment_reference = db.StringField(min_length=UID_SIZE,
max_length=UID_SIZE,
unique=True)
activity_audit = db.ListField(db.ReferenceField(ActivityAudit))
class UsersEmailuser(db.Model):
password = db.CharField(max_length=128)
last_login = db.DateTimeField(blank=True, null=True)
is_superuser = db.BooleanField()
first_name = db.CharField(max_length=30)
last_name = db.CharField(max_length=30)
email = db.CharField(unique=True, max_length=254)
is_staff = db.BooleanField()
is_active = db.BooleanField()
date_joined = db.DateTimeField()
last_updated = db.DateTimeField()
class Meta:
managed = False
db_table = 'users_emailuser'
class PaperTemplate(db.Document):
meta = {'collection': 'paper_tpl'}
deprecated = db.BooleanField(default=False) # 是否废弃不用
need_auth = db.BooleanField(default=False)
password = db.StringField(max_length=128, default=None)
duration = db.IntField(min=1, default=1800) # 考试时长,seconds
name = db.StringField(max_length=128, required=True)
desc = db.StringField(max_length=512, default=None)
questions = db.ListField(required=True)
def total_question_num(self):
return len(self.questions)
class Officer(db.Document):
firstName = db.StringField(max_length=255, required=True)
lastName = db.StringField(max_length=255, required=True)
employeeNum = db.IntField()
email = db.EmailField()
address1 = db.StringField(max_length=255, required=False)
address2 = db.StringField(max_length=255, required=False)
city = db.StringField(max_length=255, required=False)
state = db.StringField(max_length=255, required=False)
zip = db.StringField(max_length=255, required=False)
phone = db.StringField(max_length=255, required=False)
rank = db.StringField(max_length=255, required=False)
active = db.BooleanField(required=True)
armed = db.BooleanField(required=True)
customerID = db.StringField(max_length=255, required=True)
class Role(db.Document):
name = db.StringField(max_length=50,unique=True)
default = db.BooleanField(default=False,index=True)
permissions = db.IntField(default=0)
@staticmethod
def insert_roles():
roles = {
'User': [Permission.FOLLOW, Permission.COMMENT, Permission.WRITE_RECIPES],
'Admin': [Permission.FOLLOW, Permission.COMMENT,
Permission.WRITE_RECIPES,Permission.MOD_COMMENT, Permission.ADMIN],
}
for r in roles:
role = Role.objects(name=r).first()
if role is None:
role = Role(name=r)
role.set_permission(roles.get(r))
role.default = (role.name == 'User')
role.save()
def set_permission(self, perms):
for p in perms:
self.permissions += p
def remove_permission(self, perms):
for p in perms:
self.permission -= p
def is_permitted(self, p):
return (self.permissions & p == p)
class Users(db.Document):
name = db.StringField(max_length=50)
user = db.StringField(max_length=50, unique=True)
email = db.StringField(required=True, unique=True)
password = db.StringField(required=True)
birth = db.StringField(required=True)
is_confirmed = db.BooleanField(default=False)
class Course(db.Document):
"""Modeling of a course object.
course_id: integer
title: string
year: integer
description: string
prerequisites: list(integer), list of course ids
instructor: integer, instructor's user id
enrolled_students: list of students' user ids
time_added: datetime,
timestamp of the course added to the system
start_date: datetime
end_date: datetime
recurring: boolean, is a recurring course (or not)
announcements: list of announcements
"""
course_id = db.IntField(required=True)
#code = db.StringField(max_length=20)
title = db.StringField(max_length=60, required=True)
year = db.IntField(required=True)
description = db.StringField(required=True)
prerequisites = db.ListField(db.IntField())
instructor = db.IntField(required=True)
#school = db.StringField(max_length=60)
enrolled_students = db.ListField(db.IntField())
time_added = db.DateTimeField(default=datetime.now())
start_date = db.DateTimeField(required=True)
end_date = db.DateTimeField(required=True)
recurring = db.BooleanField(required=True)
announcements = db.ListField(db.EmbeddedDocumentField(Announcement))
class Account(db.Document):
# Sign-in
email = db.EmailField(required=True, primary_key=True)
password = db.StringField(required=True)
# Relationships
team = db.ReferenceField('Team')
# Core Info (Extra Credit)
first_name = db.StringField(required=True)
last_name = db.StringField(required=True)
fsuid = db.StringField()
signin = db.DateTimeField(null=True)
# Admin status
is_admin = db.BooleanField(null=True)
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
def __repr__(self):
return '<Account %r>' % self.email
def __str__(self):
return self.first_name + " " + self.last_name
def clean(self):
"""
Make sure self.email is always lowercase. This function is
automatically called on self.save()
"""
self.email = self.email.lower()
class User(db.Document):
"""The database uses mongoEngine and when called saves the user's details to the database"""
username = db.StringField(db_field="u", required=True, unique=True)
password = db.StringField(db_field="p", required=True)
email = db.EmailField(db_field="e", required=True, unique=True)
first_name = db.StringField(db_field="fn", max_length=50)
last_name = db.StringField(db_field="ln", max_length=50)
created = db.IntField(db_field="c", default=time_stamp())
bio = db.StringField(db_field="b", max_length=150)
email_confirmed = db.BooleanField(db_field="ec", default=False)
change_configuration = db.DictField(db_field="cc")
profile_image = db.StringField(db_field="pi", default=None)
def profile_image_src(self, size):
"""profile_image_src(str) -> return img path
The profile function allows the user of the application to fetch the path
of the desired image which will then be rendered to by the application
:param
size: Takes a string relating to the size of image
"""
if self.profile_image:
return join_path(
STATIC_IMAGE_URL, 'users',
"{}.{}.{}.png".format(self.id, self.profile_image,
size)).replace("\\", '/')
return join_path(STATIC_IMAGE_URL, "users",
"no_profile.jpg").replace("\\", '/')
meta = {"indexes": ["username", "email", "-created"]}
class ExpressRequestLog(db.Document):
""""""
created_at = db.DateTimeField(default=datetime.utcnow, required=True)
company = db.StringField()
number = db.StringField()
respond = db.DictField()
is_success = db.BooleanField()
class Account(db.Document):
# Sign-in
email = db.EmailField(required=True, primary_key=True)
password = db.StringField(required=True)
# Relationships
team = db.ReferenceField('Team')
profile = db.ReferenceField('Profile')
# Core Info (Extra Credit)
first_name = db.StringField(required=True)
last_name = db.StringField(required=True)
fsuid = db.StringField()
signin = db.DateTimeField(null=True)
# Admin status
is_admin = db.BooleanField(null=True)
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
def __repr__(self):
return '<Account %r>' % self.email
class Config(db.Document):
"""
Configuration for the Brain.
If you make changes to this model,
you will need to drop the saved record
in the database.
$ mongo
> show dbs
> use <your db>
> db.config.drop()
Then restart the application.
"""
# Retweet probability threshold.
# The higher this is, the less the brain will retweet.
retweet_threshold = db.FloatField(required=True, default=0.9)
# Chance to act. Probability the brain will tweet.
# The lower this is, the less the brain will tweet.
chance_to_act = db.FloatField(required=True, default=0.05)
# Maximum amount of retweets in an interval.
# Cause sometimes it accidentally retweets a TON of stuff.
max_retweets = db.IntField(required=True, default=10)
# Some brain configuration.
ngram_size = db.IntField(required=True, default=1)
ramble = db.BooleanField(default=True)
spasm = db.FloatField(required=True, default=0.05)
meta = {'max_documents': 1}
class User(db.Document):
name = db.StringField()
password = db.StringField()
email = db.StringField()
used = db.BooleanField(default=False)
code = db.StringField()
create_time = db.DateTimeField(default=datetime.now())
def __str__(self):
return self.name
def checkPassword(self, _password):
""" checkPassword: 验证密码是否正确
_password 需要验证的密码
return 密码是否正确
"""
if toMd5(_password) == self.password:
return True
return False
def changePassword(self, newPassword):
""" changePassword: 修改用户密码
newPassword 新密码
"""
self.password = toMd5(newPassword)
self.save()
def toJson(self):
return toJson(self)
class LogisticDelay(db.EmbededDocument):
"""物流延迟"""
reason = db.StringField()
is_done = db.BooleanField(default=False)
status = db.StringField(choices=LOG_STATUS)
creator = db.StringField()
created_at = db.DateTimeField(default=datetime.datetime.utcnow)
class Image(db.Document):
meta = {
'collection': 'image',
'ordering': ['-img_id'],
'strict': False,
}
img_id = db.IntField()
url = db.ListField(db.StringField())
word = db.StringField(max_length=512)
author = db.StringField()
board = db.StringField()
w_list = db.ListField(db.StringField())
m_list = db.ListField(db.StringField())
w = db.IntField(default=0)
m = db.IntField(default=0)
comments = db.ListField(db.EmbeddedDocumentField(Comment))
visible = db.BooleanField()
ct = db.DateTimeField(default=datetime.now)
def api_data(self):
return dict(
img_id=self.img_id,
url=self.url,
word=self.word,
author=self.author,
w=self.w,
m=self.m,
ct=self.ct.__str__(),
comments_num=len(self.comments),
)
class User(db.Document):
username = db.StringField(db_field="user_name", required=True, unique=True)
password = db.StringField(db_field="password", required=True)
email = db.EmailField(db_field="email", required=True, unique=True)
first_name = db.StringField(db_field="first_name", max_length=50)
last_name = db.StringField(db_field="last_name", max_length=50)
created_at = db.IntField(db_field="created_at", default=utc_now_ts())
bio = db.StringField(db_field="bio", max_length=160)
# confirm user email after register
email_confirmed = db.BooleanField(db_field="email_confirmed",
default=False)
# the files will be changed and need confirm
change_configuration = db.DictField(db_field="change_config")
avatar = db.StringField(db_field="avatar", default=None)
@classmethod
def pre_save(cls, sender, document, **kwargs):
document.username = document.username.lower()
document.email = document.email.lower()
def profile_imgsrc(self, size):
if self.avatar:
return url_for('static',
filename=os.path.join(
'images', 'user',
'%s.%s.%s.png' % (self.id, self.avatar, size)))
else:
return url_for('static',
filename=os.path.join('images', 'user',
'no-profile.%s.png' % (size)))
meta = {'indexes': ['username', 'email', '-created_at']}
class Team(db.Document):
MAX_NAME_LENGTH = 30
DIVISIONS = (
('1', 'Upper Division'),
('2', 'Lower Division'),
)
team_name = db.StringField()
# For joining the team in the db
teamID = db.StringField(required=True, unique=True)
teamPass = db.StringField(required=True)
# Password for domjudge
domPass = db.StringField(required=True)
# Division field
division = db.IntField(required=False)
# List of participants on team
members = db.ListField(db.ReferenceField('Account'), null=True)
# Block editing
shadowban = db.BooleanField()
def __repr__(self):
if self.team_name is not None:
return '<Team %r>' % self.team_name
else:
return super(Team, self).__repr__()
