class PlayerSeasonDate(EmbeddedDocument):
""" A given day over the course of a season for a specific player.
Includes:
- basic things about the day such as date, game, opposing team, officials
- traditional stats going into that game (per/game, per/min, per/poss)
- advanced stats going into that game
"""
game_id = StringField()
date = StringField()
season_index = IntField()
home = BooleanField()
team_id = StringField()
opposing_team_id = StringField()
officials = ListField(StringField())
per_game_stats = EmbeddedDocumentField(GameTraditionalStats)
per_minute_stats = EmbeddedDocumentField(GameTraditionalStats)
per_possession_stats = EmbeddedDocumentField(GameTraditionalStats)
advanced_stats_per_game = EmbeddedDocumentField(PlayerAdvancedStatsPerGame)
results = EmbeddedDocumentField(PlayerResults)
class Company(DbModelMixin, Document):
meta = {"db_alias": Database.backend, "strict": strict}
id = StringField(primary_key=True)
name = StrippedStringField(unique=True, min_length=3)
defaults = EmbeddedDocumentField(CompanyDefaults, default=CompanyDefaults)
@classmethod
def _prepare_perm_query(cls, company, allow_public=False):
""" Override default behavior since a 'company' constraint is not supported for this document... """
return Q()
class OfficialSeasonDate(EmbeddedDocument):
""" A given day over the course of a season for a specific official.
Includes:
- basic things about the day such as date and game
- stats going into that game
"""
game_id = StringField()
date = StringField()
season_index = IntField()
stats_per_game = EmbeddedDocumentField(OfficialStatsPerGame)
class DimensionAttr(Attr):
x = EmbeddedDocumentField(ValueAttr)
y = EmbeddedDocumentField(ValueAttr)
z = EmbeddedDocumentField(ValueAttr)
units = StringField()
def __unicode__(self):
string = (self.attrname + ": " + unicode(self.x.value) + " " +
self.units + " by " + unicode(self.y.value) + " " +
self.units)
if self.z:
string += unicode(self.z.value) + " " + self.units
return string
def getKeywords(self):
values = [self.x.value, self.y.value]
if self.z:
values.append(self.z.value)
values.sort()
return ["x".join(values)]
class Blog(Document):
category = ReferenceField(Category, required=True)
title = StringField(required=True)
likes = LongField()
dislikes = LongField()
viewed_numbers = LongField()
content = StringField(required=True)
published_dateTime = DateTimeField(required=True)
last_modified_dateTime = DateTimeField()
tags = ListField(StringField())
comments = ListField(EmbeddedDocumentField(Comment))
class Farmer(db.Document):
"""
Represent a threefold Farmer
"""
iyo_organization = StringField(primary_key=True)
name = StringField()
wallet_addresses = ListField(StringField())
location = EmbeddedDocumentField(Location)
email = StringField(default="")
meta = {"indexes": ["name", "location"]}
class MethodSpecification(Document):
operation_id = StringField(required=True, min_length=3)
method = StringField(required=True)
summary = StringField(required=False)
description = StringField(required=False)
path = StringField(required=True)
produces = ListField(field=StringField(required=False), required=False)
parameters = ListField(field=EmbeddedDocumentField(Parameters,
required=False),
required=False)
created_at = DateTimeField(default=datetime.datetime.utcnow())
class Artifact(EmbeddedDocument):
key = StringField(required=True)
type = StringField(required=True)
mode = StringField(choices=("input", "output"), default="output")
uri = StringField()
hash = StringField()
content_size = LongField()
timestamp = LongField()
type_data = EmbeddedDocumentField(ArtifactTypeData)
display_data = SafeSortedListField(ListField(UnionField(
(int, float, str))))
class Users(Document):
"""
Template for a mongoengine document, which represents a user.
Password is automatically hashed before saving.
:param email: unique required email-string value
:param password: required string value, longer than 6 characters
:param access: Access object
:param fav_meals: List of Meal objects
:param name: option unique string username
:param phone: optional string phone-number, must be valid via regex
:Example:
>>> import mongoengine
>>> from app import default_config
>>> mongoengine.connect(**default_config['MONGODB_SETTINGS'])
MongoClient(host=['localhost:27017'], document_class=dict, tz_aware=False, connect=True, read_preference=Primary())
# Create test user
>>> new_user = Users(email="*****@*****.**", password="******", access={"admin": True})
>>> new_user.save()
>>> new_user.name = "spammy"
>>> new_user.save()
# Remove test user
>>> new_user.delete()
.. seealso:: :class:`Access`, :class:`Phone`, :class:`models.meals.Meals`
"""
email = EmailField(required=True, unique=True)
password = StringField(required=True, min_length=6, regex=None)
access = EmbeddedDocumentField(Access, default=Access(user=True, admin=False))
fav_meals = ListField(ReferenceField(Meals))
name = StringField(unique=False)
phone = PhoneField()
def generate_pw_hash(self):
self.password = generate_password_hash(password=self.password).decode('utf-8')
# Use documentation from BCrypt for password hashing
generate_pw_hash.__doc__ = generate_password_hash.__doc__
def check_pw_hash(self, password: str) -> bool:
return check_password_hash(pw_hash=self.password, password=password)
# Use documentation from BCrypt for password hashing
check_pw_hash.__doc__ = check_password_hash.__doc__
def save(self, *args, **kwargs):
# Overwrite Document save method to generate password hash prior to saving
if self._created:
self.generate_pw_hash()
super(Users, self).save(*args, **kwargs)
class Execution(EmbeddedDocument, ProperDictMixin):
meta = {"strict": strict}
test_split = IntField(default=0)
parameters = SafeDictField(default=dict)
model_desc = SafeMapField(StringField(default=""))
model_labels = ModelLabels()
framework = StringField()
artifacts: Dict[str, Artifact] = SafeMapField(
field=EmbeddedDocumentField(Artifact))
queue = StringField(reference_field="Queue")
""" Queue ID where task was queued """
class TrainingDataGenerator(Document):
bot = StringField(required=True)
user = StringField(required=True)
document_path = StringField(default=None)
status = StringField(default=TRAINING_DATA_GENERATOR_STATUS.INITIATED)
start_timestamp = DateTimeField(default=None)
last_update_timestamp = DateTimeField(default=None)
end_timestamp = DateTimeField(default=None)
response = ListField(EmbeddedDocumentField(TrainingDataGeneratorResponse),
default=None)
exception = StringField(default=None)
class ResponseText(EmbeddedDocument):
text = StringField(required=True)
image = StringField()
channel = StringField()
buttons = ListField(EmbeddedDocumentField(ResponseButton), default=None)
def validate(self, clean=True):
if Utility.check_empty_string(self.text):
raise ValidationError(
"Response text cannot be empty or blank spaces")
Utility.validate_document_list(self.buttons)
class MongoDocument(Document): # Document or EmbeddedDocument)
# id = StringField(primary_key=True) # autogenerated
mobile = IntField(required=True, unique=True)
barcode = StringField(required=True)
description = StringField(default='...')
registration_date = DateTimeField()
aggregation = ReferenceField(Aggregation) # One to One
aggregations = ListField(ReferenceField(Aggregation)) # One to Many
composition = EmbeddedDocumentField(Composition)
compositions = ListField(EmbeddedDocumentField(Composition))
def __repr__(self):
return str(self.dict())
def dict(self):
return {
'id': str(self.id), 'mobile': self.mobile, 'barcode': self.barcode, 'description': self.description,
'registration_date': self.registration_date, 'aggregation': self.aggregation,
'aggregations': self.aggregations, 'composition': self.composition, 'compositions': self.compositions
}
class ShopOrderInvoice(DynamicDocument):
user_id = StringField()
ware_house = StringField()
shop_name = StringField()
shop_id = StringField()
dealer_id = StringField()
shop_purchaseorderno = StringField()
shopinvoice_number = StringField()
invoice_date = StringField()
expected_date = StringField()
invoice = ListField(EmbeddedDocumentField(ShopInvoice))
othercharges = ListField(EmbeddedDocumentField(ShopCharges))
total_items = StringField()
total_quantity = StringField()
total_value = StringField()
status = StringField(default='Accept')
shipping_barcode = StringField()
created_date = DateTimeField("created_date",
format="%d/%m/%y",
default=datetime.datetime.now)
class PurchaseInvoice(DynamicDocument):
user_id=StringField()
ware_house=StringField()
supplier_id = StringField()
purchase_manager_id=StringField()
purchaseOrder_no=StringField()
supplier_gstno = StringField()
invoice_no=StringField()
invoice_date=StringField()
expected_date=StringField()
invoice=ListField(EmbeddedDocumentField(Invoice))
bankdetails= ListField(EmbeddedDocumentField(BankDetail))
#shipping_charges = StringField()
othercharges=ListField(EmbeddedDocumentField(Charges))
total_items= StringField()
total_qty = StringField()
total_value = StringField()
status = StringField(default='Process')
remarks=StringField()
shipping_barcode=StringField()
created_date = DateTimeField( "created_date",format="%d/%m/%y",default=datetime.datetime.now)
class ImageTask(Task):
'''
Image task model class.
'''
images = ListField(EmbeddedDocumentField(Image))
task_function = get_images
def to_json(self):
json_dict = super().to_json()
json_dict.update({'images': [img.to_json() for img in self.images]})
return json_dict
class Patient(db.Document):
username = StringField()
password = StringField()
name = StringField()
surname = StringField()
email = EmailField()
phone = StringField()
gender = StringField()
image = ImageField()
signup_date = DateTimeField(default=datetime.utcnow)
online = BooleanField(default=False)
address = EmbeddedDocumentField(Address)
class AzureVirtualMachine(DynamicEmbeddedDocument):
name = StringField(required=True)
label = StringField()
# AVMStatus in enum.py
dns = StringField()
public_ip = StringField()
private_ip = StringField()
deployment = EmbeddedDocumentField(AzureDeployment)
create_time = DateTimeField()
update_time = DateTimeField()
deletable = BooleanField() # F-cannot delete T-can be deleted
end_points = EmbeddedDocumentListField(AzureEndPoint, default=[])
class Macroindicador(Document):
# id = StringField(required=True, max_length=200)
nome = StringField(required=True, max_length=200)
descricao = StringField(required=True)
fonte = StringField(required=True, max_length=200)
unidade = StringField(required=True, max_length=200)
categoria = StringField(required=True, max_length=200)
localidade = ListField(ReferenceField(Localidade))
indicadores = ListField(EmbeddedDocumentField(Indicador))
def __repr__(self):
return '<Macroindicador(name={self.nome!r})>'.format(self=self)
class MicroBlog(Document):
mid = StringField(required=True)
uid = StringField(required=True)
omid = StringField()
created = DateTimeField()
tags = ListField(StringField())
links = ListField(URLField())
n_likes = IntField()
likes = ListField(EmbeddedDocumentField(Like))
n_forwards = IntField()
forwards = ListField(EmbeddedDocumentField(Forward))
n_comments = IntField()
comments = ListField(EmbeddedDocumentField(Comment))
meta = {
'indexes': [
{'fields': ['mid', 'uid']}
]
}
class User(Document):
# meta = {"allow_inheritance": True}
email_id = EmailField(primary_key=True)
first_name = StringField(required=True)
last_name = StringField(required=True)
password = StringField(required=True)
phone_num = LongField(required=True)
company_name = StringField()
date_modified = DateTimeField(default=datetime.utcnow)
otp = StringField()
trail = EmbeddedDocumentField(trailDetails)
verified = BooleanField(default=False)
class Series(Document, BaseModel):
title = StringField()
number_of_chapters = IntField()
active = BooleanField()
rating = FloatField()
info = EmbeddedDocumentField(DataSheet)
characters = ListField()
secret_code = StringField()
extras = StringField()
additional_info = DictField()
created_at = DateTimeField(default=datetime.now)
updated_at = ComplexDateTimeField(default=datetime.now)
class Post(gj.Document):
described = StringField(required=True)
like = IntField(required=True, default=0)
comment = IntField(required=True, default=0)
images = EmbeddedDocumentField(Images)
video = FileField(default=None)
owner = EmbeddedDocumentField(UserEmbedd)
state = StringField()
creation_date = DateTimeField()
modified_date = DateTimeField(default=pst_now)
def save(self, *args, **kwargs):
if not self.creation_date:
self.creation_date = pst_now
self.modified_date = pst_now
return super(Post, self).save(*args, **kwargs)
def is_like(self, user_id):
# like = Like.objects.get(post=self.id)
pass
class Marker(EmbeddedDocument):
name = StringField(max_length=256, required=True) # type: str
marker_type = IntField(required=True) # type: int
pose = EmbeddedDocumentField(Pose) # type: Pose
def get_msg(self):
# type: () -> MarkerMsg
return MarkerMsg(name=str(self.name),
marker_type=self.marker_type,
pose=self.pose.get_msg())
class AlloyStore(EmbeddedDocument):
alloy_option = StringField(required=True, choices=('single', 'mix'))
alloys = EmbeddedDocumentField(document_type=AlloyType, required=True)
def to_dict(self):
return {
'alloy_option': self.alloy_option,
'alloys': self.alloys.to_dict()
}
def __str__(self):
return self.to_json()
class Responses(Document):
name = StringField(required=True)
text = EmbeddedDocumentField(ResponseText)
custom = EmbeddedDocumentField(ResponseCustom)
bot = StringField(required=True)
user = StringField(required=True)
timestamp = DateTimeField(default=datetime.utcnow)
status = BooleanField(default=True)
def validate(self, clean=True):
if Utility.check_empty_string(self.name):
raise ValidationError(
"Response name cannot be empty or blank spaces")
elif not self.text and not self.custom:
raise ValidationError(
"Either Text or Custom response must be present!")
else:
if self.text:
self.text.validate()
elif self.custom:
self.custom.validate()
class Artifact(EmbeddedDocument):
key = StringField(required=True)
type = StringField(required=True)
mode = StringField(choices=get_options(ArtifactModes),
default=DEFAULT_ARTIFACT_MODE)
uri = StringField()
hash = StringField()
content_size = LongField()
timestamp = LongField()
type_data = EmbeddedDocumentField(ArtifactTypeData)
display_data = SafeSortedListField(ListField(UnionField(
(int, float, str))))
class Tasks(Document):
weibo_accounts = ListField(EmbeddedDocumentField(WeiboAccounts,
required=True),
required=False)
spider_user_ids = ListField(StringField(), required=True)
spider_keywords = ListField(StringField(), required=True)
spider_extra_keywords = ListField(StringField(), required=True)
mail_list = ListField(StringField(), required=True)
spider_interval = IntField(required=True)
switch_account_interval = IntField(required=True)
belong_user_id = StringField(required=True)
private_message = StringField(required=True)
class SharedSimulation(Document):
owner_email = EmailField(required=True)
created_date = DateTimeField(default=datetime.utcnow(), required=True)
configuration = EmbeddedDocumentField(document_type=Configuration,
required=True)
alloy_store = EmbeddedDocumentField(document_type=AlloyStore,
required=True)
simulation_results = EmbeddedDocumentField(document_type=SimulationResults,
required=True,
null=False)
meta = {'collection': 'shared_simulations'}
def to_dict(self):
return {
'owner_email': self.owner_email,
'created_date': str(self.created_date),
'configurations': self.configuration.to_dict(),
'alloy_store': self.alloy_store.to_dict(),
'simulation_results': self.simulation_results.to_dict()
}
class Nodes(Document):
user = ReferenceField(User, reverse_delete_rule=CASCADE)
supernode = ReferenceField(Supernodes, reverse_delete_rule=CASCADE)
label = StringField(max_length=28)
secretkey = StringField(required=True, max_length=16)
is_public = IntField(default=0)
pubsperday = IntField(default=0)
pubsperdayremain = IntField(default=0)
sensors = EmbeddedDocumentListField(document_type=Sensors)
coordinates = EmbeddedDocumentField(document_type=Coordinates,
required=False,
null=True)
