class UndoneTrade(mongoengine.Document):
user_id: mongoengine.LongField()
calculation_start_date = mongoengine.DateField()
undue_trades_count = mongoengine.IntField()
past_due_trades_count_with_less_than_30_day_delays = mongoengine.IntField()
arrear_trades_count_with_more_than_30_day_delays = mongoengine.IntField()
undue_trades_total_balance_of_last_year = mongoengine.DecimalField()
past_due_trades_total_balance_of_last_year = mongoengine.DecimalField()
arrear_trades_total_balance_of_last_year = mongoengine.DecimalField()
meta = {'db_alias': 'core', 'collection': 'undoneTrades'}
class UserDocument(BaseDocument):
username = mongo.StringField(unique=True)
password = mongo.StringField()
email = mongo.EmailField(unique=True)
birth_date = mongo.DateField()
active = mongo.BooleanField()
document = mongo.StringField(unique=True)
def set_password(self, password):
self.password = bcrypt.hash(password)
self.save()
def verify_password(self, password):
return bcrypt.verify(password, self.password)
class Proyecto(_db.Document):
titulo = _db.StringField()
descripcion = _db.StringField()
cover = _db.ReferenceField(Media)
fecha_publicacion = _db.DateField()
productores_proyecto = _db.ListField(_db.ReferenceField(Estudio))
colaboradores_proyecto = \
_db.ListField(_db.ReferenceField(Colaborador))
rated = _db.StringField()
menciones = _db.ListField(_db.EmbeddedDocumentField(menciones))
tags = _db.ListField(_db.ReferenceField(Tag))
keywords = _db.ListField()
# allow
meta = {'allow_inheritance': True}
class Cart(me.Document):
user = me.ReferenceField(User, required=True)
products = me.ListField(me.ReferenceField(Product))
is_active = me.BooleanField(default=True)
created_at = me.DateField()
def save(self, *args, **kwargs):
self.created_at = datetime.datetime.now()
super().save(*args, **kwargs)
def add_product(self, product):
self.products.append(product)
self.save()
def remove_product(self, product):
self.products.remove(product)
self.save()
def get_products(self):
data = []
for i in set(self.products):
product = {'id': i.id, 'description': self.get_detail(i.id)}
data.append(product)
return data
def get_cost_cart(self):
len_obj = [j.price for j in self.products]
if len_obj:
return sum(len_obj)
return 0
def get_active_order(self):
order = Order.objects(user=self.user, cart=self).first()
if not order or order.sum_order == 0:
order = Order()
order.user = self.user
order.cart = self
order.sum_order = self.get_cost_cart()
if order.sum_order > 0:
order.save()
else:
return None
return order
def get_detail(self, id_):
product = Product.objects.get(id=id_)
len_obj = [j for j in self.products if j == product]
return f'{product.title} \nprice {product.price} x {len(len_obj)} = {len(len_obj) * product.price}'
class finance(mongoengine.Document):
abstract = mongoengine.StringField(max_length=20, )
checkPeople = mongoengine.StringField(max_length=20)
city = mongoengine.StringField(max_length=20)
cityarea = mongoengine.StringField(max_length=20)
classify = mongoengine.StringField(max_length=20)
FEATURE = mongoengine.StringField(max_length=100)
indicatorOfAdvert = mongoengine.IntField(default=0)
indicatorOfComplaint = mongoengine.IntField(default=0)
indicatorOfIllegal = mongoengine.IntField(default=0)
indicatorOfIncome = mongoengine.IntField(default=0)
indicatorOfInfluence = mongoengine.IntField(default=0)
modifyDate = mongoengine.DateField(default=datetime.datetime.now)
monitorCompanySource = mongoengine.StringField(max_length=200)
monitorTime = mongoengine.DateField()
name = mongoengine.StringField(max_length=200)
province = mongoengine.StringField(max_length=20)
RATEOFRETURN = mongoengine.IntField(default=0)
score = mongoengine.IntField(default=0)
shortname = mongoengine.StringField(max_length=20)
state = mongoengine.StringField(max_length=20)
status = mongoengine.IntField(default=0)
url = mongoengine.StringField(max_length=50)
class GRB(moe.Document):
name = moe.StringField(required=True)
date = moe.DateField()
detectors = moe.ListField(moe.StringField(max_length=2), max_lenght=14)
brightest_detector = moe.StringField(max_length=2)
background_selection = moe.ListField(moe.FloatField(), max_length=2)
location = moe.ListField(moe.FloatField(), max_lenght=3)
selection = moe.ReferenceField(Selection)
data = moe.DictField()
class Watchlist(me.EmbeddedDocument): # Embedded in User
name = me.StringField(required=True, max_length=30)
id = me.ObjectIdField(default=ObjectId)
tickers = me.ListField(me.DictField())
columns = me.ListField(me.DictField())
date_created = me.DateField(default=datetime.utcnow)
def to_json(self):
return {
"name": self.name,
"id": str(self.id),
"tickers": self.tickers,
"columns": self.columns,
"date_created": datetime.strftime(self.date_created, "%Y/%m/%d"),
}
class Profile(mongoengine.Document):
user_id: mongoengine.LongField()
has_kyc = mongoengine.BooleanField()
military_service_status = mongoengine.StringField()
sim_card_ownership = mongoengine.BooleanField()
address_verification = mongoengine.BooleanField()
membership_date = mongoengine.DateField()
recommended_to_others_count = mongoengine.IntField()
star_count = mongoengine.IntField()
score = mongoengine.IntField()
meta = {
'db_alias': 'core',
'collection': 'profiles'
}
class Case(mongoengine.EmbeddedDocument):
_id = mongoengine.IntField(required=True)
_type = mongoengine.StringField(required=True)
date = mongoengine.DateTimeField(default=datetime.datetime.now,
required=True)
until = mongoengine.DateTimeField(default=None)
mod_id = mongoengine.IntField(required=True)
mod_tag = mongoengine.StringField(required=True)
reason = mongoengine.StringField(required=True)
punishment = mongoengine.StringField()
lifted = mongoengine.BooleanField(default=False)
lifted_by_tag = mongoengine.StringField()
lifted_by_id = mongoengine.IntField()
lifted_reason = mongoengine.StringField()
lifted_date = mongoengine.DateField()
class GradeSheetModel(BaseMixin, me.Document):
'''
Grade sheets
'''
grade_sheet_id = me.StringField(primary_key=True, default=uuid_value)
student = me.ReferenceField(UserModel, required=True)
instructor = me.ReferenceField(UserModel, required=True)
event = me.ReferenceField(EventModel, required=True)
date = me.DateField()
grade = me.StringField()
status = me.StringField()
lesson_type = me.StringField()
comments = me.StringField(default="")
meta = {'collection': 'grade_sheets'}
class Event(mongoengine.DynamicDocument):
"""
Document object for a outcome event. All records will relate to a unique Patient via "parent-referencing".
Outcome events log when a change has happened during a patients stay and are "time-series" in nature.
Parameters
-----------
patient_id: str, required
Unique patient ID
component: str, optional
Even component (for further stratification of event types)
eventType: str, required
The type of event
eventDate: Date, required
Date of event
eventTime: float, optional
Time passed in minutes (relative to 0:00am event date)
covidStatus: str, (default="U")
COVID-19 status at time of event (options: "P", "N", "U")
death: int, (default=0)
1 = event corresponds to patient death, else 0
criticalCareAdmission, int (default=0)
1 = event corresponds to a critical care admission, else 0
source: str, optional
Source of event
sourceType: str, optional
Type of source
destination: str, optional
The patients destination as a result of the event
wimd: int, optional
Welsh deprivation score
"""
patientId = mongoengine.StringField(required=True)
component = mongoengine.StringField(required=False)
eventType = mongoengine.StringField(required=True)
eventDate = mongoengine.DateField(required=True)
eventTime = mongoengine.FloatField(required=False)
covidStatus = mongoengine.StringField(default="U", choices=("P", "N", "U"))
death = mongoengine.IntField(default=0, choices=(1, 0))
criticalCareAdmission = mongoengine.IntField(default=0, choices=(1, 0))
source = mongoengine.StringField(required=False)
sourceType = mongoengine.StringField(required=False)
destination = mongoengine.StringField(required=False)
wimd = mongoengine.IntField(required=False)
meta = {"db_alias": "core", "collection": "outcomes"}
class Measurement(mongoengine.DynamicDocument):
"""
Base class for measurements.
"""
patientId = mongoengine.StringField(required=True)
name = mongoengine.StringField(required=True)
date = mongoengine.DateField(required=False)
time = mongoengine.FloatField(required=False)
requestSource = mongoengine.StringField(required=False)
notes = mongoengine.StringField(required=False)
flags = mongoengine.ListField(required=False)
meta = {
"db_alias": "core",
"collection": "testResults",
"allow_inheritance": True
}
class DoneTrade(mongoengine.Document):
user_id = mongoengine.LongField()
calculation_start_date = mongoengine.DateField()
timely_trades_count_of_last_3_months = mongoengine.IntField()
past_due_trades_count_of_last_3_months = mongoengine.IntField()
arrear_trades_count_of_last_3_months = mongoengine.IntField()
timely_trades_count_between_last_3_to_12_months = mongoengine.IntField()
past_due_trades_count_between_last_3_to_12_months = mongoengine.IntField()
arrear_trades_count_between_last_3_to_12_months = mongoengine.IntField()
trades_total_balance = mongoengine.DecimalField()
total_delay_days = mongoengine.IntField()
meta = {'db_alias': 'core', 'collection': 'doneTrades'}
class Account(me.Document):
id = me.StringField(primary_key=True)
twitter_handle = me.StringField(required=True, unique=True)
name = me.StringField()
update_date = me.DateField(default=datetime.datetime.utcnow)
group_type = me.ReferenceField(Group)
profile_image_url = me.URLField()
following = me.EmbeddedDocumentListField(FollowingConnections)
total_following = me.IntField(default=0)
total_followers = me.IntField(default=0)
followers = me.EmbeddedDocumentListField(FollowerConnections)
top_words_positive = me.EmbeddedDocumentListField(Top_Word)
top_words_negative = me.EmbeddedDocumentListField(Top_Word)
tweets = me.EmbeddedDocumentListField(Tweet)
tweets_context = me.EmbeddedDocumentListField(Context)
favorite_tweets = me.EmbeddedDocumentListField(Tweet)
favorite_context = me.EmbeddedDocumentListField(Context)
requested = me.IntField(default=0)
class Female(Member):
nickName = me.StringField()
birthDate = me.DateField()
personality = me.StringField()
hobit = me.StringField(max_length=20)
job = me.StringField()
pictUri = me.URLField()
email = me.StringField()
phone = me.StringField()
userId = me.StringField(unique=True)
status = me.IntField()
meta = {'collection': 'Female'}
def createDate(self):
"""發起約會"""
replyT = "上班在哪一區呀？"
Date(femaleId=self.userId, status=1).save()
self.status += 10
self.save()
return replyT
def readInvList(self, token, userId, client):
"""觀看邀請名單"""
colLis = []
date = Member.getDate(self.userId)
for invId in date.invList:
user = Member.getUser(invId)
text = f'個性{user.personality}喜歡{user.hobit}的{user.getConstellation()}男孩'
action = actions.PostbackAction(data=invId,
label="選他",
display_text="選他")
column = template.CarouselColumn(title=user.nickName,
text=text,
thumbnail_image_url=user.pictUri,
actions=[action])
colLis.append(column)
carouse = template.CarouselTemplate(columns=colLis)
if token != userId:
client.reply_message(token, [
template.TemplateSendMessage(template=carouse,
alt_text="broke")
])
return
class Male(Member):
nickName = me.StringField()
birthDate = me.DateField()
personality = me.StringField()
hobit = me.StringField(max_length=20)
job = me.StringField()
pictUri = me.URLField()
email = me.StringField()
phone = me.StringField()
userId = me.StringField(unique=True)
status = me.IntField()
meta = {'collection': 'Male'}
def readDate(self, token, userId, client):
"""觀看約會"""
colLis = []
for dating in Date.objects(status=10):
girl = Member.getUser(dating.femaleId)
action = actions.PostbackAction(data=dating.femaleId,
label="邀請她",
display_text="邀請她")
column = template.CarouselColumn(
actions=[action],
title=f'{girl.calculate_age()},{girl.nickName}',
text=
f'我在{dating.workDist}上班，喜歡吃{dating.eatype}，禮拜{str(dating.dateDate.isoweekday())}有空嗎？',
thumbnail_image_url=girl.pictUri,
)
colLis.append(column)
if colLis == []:
if token != userId:
client.reply_message(token, TextSendMessage(text='目前無約會'))
return
carouse = template.CarouselTemplate(columns=colLis)
if token != userId:
client.reply_message(token, [
template.TemplateSendMessage(template=carouse,
alt_text="broke")
])
return
class Products(me.Document):
title = me.StringField(min_length=1, max_length=512)
description = me.StringField(min_length=2 ,max_length=4096)
created = me.DateField(default=datetime.datetime.now())
price = me.DecimalField(required=True)
in_stock = me.BooleanField(default=True)
discount = me.IntField(min_value=0, max_value=100, default=0)
image = me.FileField(required=False, default=None)
category = me.ObjectIdField(required=True)
@property
def extended_price(self):
return self.price * (100 - self.discount) / 100
@classmethod
def get_discount_products(cls):
return cls.objects(discount__ne=0, in_stock=True)
@classmethod
def get_category_products(cls, category):
return cls.objects(category=category)
class Orders(me.Document):
created_dt = me.DateField(default=datetime.datetime.now(), required=True)
updated_dt = me.DateTimeField(default=datetime.datetime.now(),
required=True)
order_type = me.StringField(required=True, max_length=50)
description = me.StringField(max_length=200)
status = me.StringField(max_length=50)
serial_no = me.IntField(max_value=999)
creator_id = me.IntField()
order_id = me.IntField(min_value=1, max_value=1000)
def __str__(self):
return f'ID: {self.pk}' \
f'\nCreated_dt: {self.created_dt}' \
f'\nUpdated_dt: {self.updated_dt}' \
f'\nOrder_type: {self.order_type}' \
f'\nDescription: {self.description}' \
f'\nStatus: {self.status}' \
f'\nSerial_no: {self.serial_no}' \
f'\nCreator_id: {self.creator_id}' \
f'\nOrder_id: {self.order_id}'
class Chats(mongoengine.Document):
creator_id = mongoengine.IntField()
invited_users = mongoengine.ListField()
connected_users = mongoengine.ListField()
book_id = mongoengine.StringField()
smiles = mongoengine.DictField() # associate id with emodzi
creation_date = mongoengine.DateField(default=datetime.datetime.now())
visited = mongoengine.BooleanField(default=False)
out_of_time = mongoengine.BooleanField(default=False)
def close(self):
for user in self.invited_users:
user.disconnect_chat()
self.delete()
def disconnect_user(self, user):
user.disconnect_chat()
if user in self.connected_users:
self.connected_users.remove(user)
self.save()
def get_emodzi(self):
smile_list = random.sample(emodzi_list, k=len(self.invited_users) + 1)
for ind, user in enumerate(self.invited_users):
self.smiles[str(user.user_id)] = smile_list[ind]
self.smiles[str(self.creator_id)] = smile_list[-1]
self.save()
return self.smiles
def time_out(self):
self.out_of_time = True
self.save()
@queryset_manager
def get_not_visited(doc_cls, queryset):
return queryset.filter(visited=False, out_of_time=True)
class User(CommonDocument, SearchableMixin):
"""Basic user model
"""
# 基础字段
username = mongo.StringField(required=True, max_length=100, unique=True)
email = mongo.StringField(required=False, max_length=80, default='')
password = mongo.StringField(required=True, max_length=255)
active = mongo.BooleanField(default=True)
phone = mongo.StringField(max_length=16, required=False, default='')
# roles = mongo.ListField()
gender = mongo.StringField(choices=['F', 'M', ''], default='')
avatar = mongo.StringField(default='', max_length=512)
weixin = mongo.StringField(default='', max_length=64)
qq = mongo.StringField(default='', max_length=64)
birthday = mongo.DateField(required=False, default=date(1, 1, 1))
country = mongo.StringField(required=False, max_length=128,
default='') # 国家
city = mongo.StringField(required=False, max_length=128, default='') # 城市
graduated_school = mongo.StringField(required=False,
max_length=128,
default='') # 毕业学校
company = mongo.StringField(required=False, max_length=128,
default='') # 就职公司
title = mongo.StringField(required=False, max_length=64, default='') # 职位
brief = mongo.StringField(required=False, max_length=1024, default='')
# permissions = mongo.ListField(required=True, default=[])
# __searchable__ = ['username', 'email'] # 定义需要es搜索的字段，不定义则不需要es搜索功能
# 扩展字段
def clean(self, **kwargs):
self.password = pwd_context.hash(self.password)
def __repr__(self):
return "<User %s>" % self.username
class BookInfo(mongoengine.Document):
rid = mongoengine.StringField(max_length=30)
bid = mongoengine.StringField(max_length=30)
used = mongoengine.BooleanField()
lend_date = mongoengine.DateField()
class Manufacturer(me.Document):
name = me.StringField(min_length=2, max_length=128, required=True)
created = me.DateField()
def __str__(self):
return str(self.id)
class DrivesSleepingTime(me.Document):
date = me.DateField()
drivers = me.ListField()
class Drivers(me.Document):
mac = me.StringField()
ID = me.StringField()
name = me.StringField()
date_birth = me.DateField()
data_drivers_sleeping = me.EmbeddedDocumentField(DataDriversSleeping)
class Tweet(me.EmbeddedDocument):
id = me.StringField(primary_key=True)
created_at = me.DateField()
text = me.StringField()
class BookingDates(me.EmbeddedDocument):
checkIn = me.DateField(required=True)
checkOut = me.DateField(required=True)
class User(UserMixin, me.Document):
meta = {"collection": "user"}
# User permissions in ascending order
USER_PERMS = {
"certification": 0, # Can also receive certificates
"data": 1, # Has access to data dashboard and report generation
"admin": 2 # Full set of permissions
}
email = me.StringField(max_length=db_str_len, required=True)
first_name = me.StringField(max_length=db_str_len,
required=True) # Or names
paternal_last_name = me.StringField(max_length=db_str_len, required=True)
maternal_last_name = me.StringField(max_length=db_str_len, required=True)
birth_date = me.DateField(required=True)
gender = me.StringField(required=True)
occupation = me.StringField(required=True)
password_hash = me.StringField(max_length=db_hash_len, required=True)
registered_on = me.DateTimeField(required=True)
quiz_data = me.DictField()
certified_on = me.DateTimeField()
perm_level = me.IntField(default=USER_PERMS["certification"])
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def has_perm(self, perm_tag):
"""Returns wether of not the user has at least the specified permission level
identified by the given permission level tag.
Returns None if the tag is invalid."""
if perm_tag not in User.USER_PERMS:
return None
return self.perm_level >= User.USER_PERMS[perm_tag]
def update_perm(self, perm_tag):
"""Changes the user's permissions given the matchin permission label string
Has no effect if no matching tag is provided"""
if perm_tag in User.USER_PERMS:
self.perm_level = User.USER_PERMS[perm_tag]
def has_passed_quiz(self, quiz_code):
"""Tells if the user has completed succesfully the spefied quiz given a code
Returns None if invalid quiz code"""
if quiz_code not in QUIZ_CODES:
return None
return self.quiz_data[quiz_code]["is_passed"]
def set_passed_quiz(self, quiz_code, is_passed=True, date=None):
"""Takes a quiz code and updates the user's passing status and datetime.
Fail silently if given an invalid quiz code."""
if quiz_code in QUIZ_CODES:
quiz_field = self.quiz_data[quiz_code]
quiz_field["is_passed"] = is_passed
if is_passed:
quiz_field["passed_on"] = date or datetime.now()
else:
quiz_field["passed_on"] = ""
# Checks if the user has passed the needed tests to be certified.
def can_be_certified(self):
for qc in QUIZ_CODES:
if QUIZ_CODES[qc][
"is_obligatory"] and not self.quiz_data[qc]["is_passed"]:
return False
return True
# Gets user document instance from me. Returns None if it does not exist.
@staticmethod
def get_user(email):
return User.objects(email=email).first()
# Creates user without saving it the database.
@staticmethod
def create_new_user(email,
first_name,
paternal_last_name,
maternal_last_name,
birth_date,
gender,
occupation,
password,
registered_on=datetime.now()):
return User(email=email,
first_name=first_name,
paternal_last_name=paternal_last_name,
maternal_last_name=maternal_last_name,
birth_date=birth_date,
gender=gender,
occupation=occupation,
password_hash=generate_password_hash(password),
registered_on=registered_on,
quiz_data=USER_QUIZ_DATA)
# Print function
def __repr__(self):
return "<User email:{}>".format(self.email)
def generate_reset_token(self, expiration=3600):
s = Serializer(current_app.config["SECRET_KEY"], expiration)
return s.dumps({"reset": self.email}).decode("utf-8")
@staticmethod
def reset_password(token, new_password):
s = Serializer(current_app.config["SECRET_KEY"])
try:
data = s.loads(token.encode("utf-8"))
except:
return False
user = User.objects(email=data.get("reset")).first()
if user is None:
return False
user.password_hash = generate_password_hash(new_password)
user.save()
return True
class PowResult(ModelMixin, mg.Document):
meta = {"collection": "zil_pow_results"}
header = mg.StringField(max_length=128, required=True)
seed = mg.StringField(max_length=128, required=True)
boundary = mg.StringField(max_length=128, required=True)
pub_key = mg.StringField(max_length=128, required=True)
mix_digest = mg.StringField(max_length=128, required=True)
nonce = mg.StringField(max_length=128, required=True)
hash_result = mg.StringField(max_length=128, required=True)
block_num = mg.IntField(default=0)
pow_fee = mg.FloatField(default=0.0)
finished_date = mg.DateField()
finished_time = mg.DateTimeField()
verified_time = mg.DateTimeField()
verified = mg.BooleanField(default=False)
miner_wallet = mg.StringField(max_length=128)
worker_name = mg.StringField(max_length=64, default="")
def __str__(self):
return f"[PowResult: {self.pub_key}, {self.header}]"
@classmethod
def get_pow_result(cls,
header,
boundary,
pub_key=None,
order="-finished_time"):
query = Q(header=header) & Q(boundary=boundary)
if pub_key is not None:
query = query & Q(pub_key=pub_key)
cursor = cls.objects(query).order_by(
order) # default to get latest one
return cursor.first()
@classmethod
def epoch_rewards(cls,
block_num=None,
miner_wallet=None,
worker_name=None):
match = {}
if block_num is not None:
if isinstance(block_num, int):
match = {
"block_num": {
"$eq": block_num,
}
}
else:
start, end = block_num
match = {
"block_num": {
"$gte": start,
"$lte": end,
}
}
if miner_wallet is not None:
match.update({"miner_wallet": {
"$eq": miner_wallet,
}})
if worker_name is not None:
match.update({"worker_name": {
"$eq": worker_name,
}})
group = {
"_id": None,
"rewards": {
"$sum": "$pow_fee"
},
"count": {
"$sum": 1
},
"verified": {
"$sum": {
"$cond": ["$verified", 1, 0]
}
},
"first_work_at": {
"$min": "$finished_time"
},
"last_work_at": {
"$max": "$finished_time"
}
}
pipeline = [
{
"$match": match
},
{
"$group": group
},
]
res = list(cls.objects.aggregate(*pipeline))
if res:
rewards = res[0]
rewards.pop("_id", None)
return rewards
return {
"rewards": None,
"count": 0,
"verified": 0,
"first_work_at": None,
"last_work_at": None
}
@classmethod
def rewards_by_miners(cls, block_num):
if block_num is None:
block_num = PowWork.get_latest_block_num()
match = {
"block_num": {
"$eq": block_num,
}
}
group = {
"_id": "$miner_wallet",
"block_num": {
"$first": "$block_num"
},
"date": {
"$first": "$finished_date"
},
"date_time": {
"$first": "$finished_time"
},
"rewards": {
"$sum": "$pow_fee"
},
"finished": {
"$sum": 1
},
"verified": {
"$sum": {
"$cond": ["$verified", 1, 0]
}
},
}
project = {
"_id": 0,
"miner_wallet": "$_id",
"block_num": 1,
"date": 1,
"date_time": 1,
"rewards": 1,
"finished": 1,
"verified": 1,
}
pipeline = [{
"$match": match
}, {
"$group": group
}, {
"$project": project
}]
return list(cls.objects.aggregate(*pipeline))
def get_worker(self):
return miner.Worker.get_or_create(self.miner_wallet, self.worker_name)
class Treatment(mongoengine.EmbeddedDocument):
treatment_date = mongoengine.DateField(required=True)
category = mongoengine.StringField()
medication = mongoengine.StringField()
dosage = mongoengine.StringField()
class TrackStatus(me.EmbeddedDocument):
kickoffDate = me.DateField()
dueDate = me.DateField()
