class GivePost(me.EmbeddedDocument):
_id = me.ObjectIdField(required=True)
postID = me.ObjectIdField(required=True)
#asking = me.BooleanField(required=True)
item = me.StringField(required=True)
created = me.DateTimeField(required=True)
explanation = me.StringField(required=True)
radius = me.IntField(required=True)
class LawDivision(moe.Document):
law_code = moe.StringField()
parent_id = moe.ObjectIdField()
version = moe.StringField()
division = moe.StringField()
title = moe.StringField()
source = moe.ObjectIdField()
leaf = moe.BooleanField()
class Booking(mongoengine.EmbeddedDocument):
guest_user_id = mongoengine.ObjectIdField()
guest_bird_id = mongoengine.ObjectIdField()
booked_date = mongoengine.DateTimeField()
checked_in = mongoengine.DateTimeField(required=True)
checked_out = mongoengine.DateTimeField(required=True)
ratings = mongoengine.IntField(default=0)
reviews = mongoengine.StringField()
class Reservation(mongoengine.Document):
therapist_id = mongoengine.ObjectIdField()
member_id = mongoengine.ObjectIdField()
total_price = mongoengine.IntField()
start_time = mongoengine.DateTimeField()
end_time = mongoengine.DateTimeField()
buffer_start = mongoengine.IntField(default=15)
buffer_end = mongoengine.IntField(default=15)
services_id = mongoengine.ListField()
address = mongoengine.DictField()
class Booking(mongoengine.EmbeddedDocument):
guest_owner_id = mongoengine.ObjectIdField(default=None, null=True)
guest_snake_id = mongoengine.ObjectIdField(default=None, null=True)
booked_date = mongoengine.DateTimeField()
check_in_date = mongoengine.DateTimeField(required=True)
check_out_date = mongoengine.DateTimeField(required=True)
review = mongoengine.StringField()
rating = mongoengine.IntField(default=0)
class Comment(gj.Document):
meta = {'queryset_class': fm.BaseQuerySet}
user = db.ReferenceField(User,
required=True,
reverse_delete_rule=db.CASCADE)
comment = db.StringField()
sub_comments = db.ListField(db.ReferenceField('self'),
reverse_delete_rule=db.CASCADE)
created_at = db.LongField(required=True)
thumb_up_user_ids = db.ListField(db.ObjectIdField())
thumb_down_user_ids = db.ListField(db.ObjectIdField())
class Booking(m.EmbeddedDocument): registered_date=m.DateTimeField(default=datetime.datetime.now) oid=m.ObjectIdField(required=True, default=lambda: ObjectId()) beds=m.IntField(required=True, choices=bed_options) hotel=m.StringField(required=True) customerid=m.ObjectIdField() check_in_date=m.DateTimeField(required=True) check_out_date=m.DateTimeField(required=True) cost=m.FloatField()
class ProductVariant(mongoengine.Document, SearchableMixin):
__tablename__ = 'variant_mongo'
__searchable__ = ['price']
price = mongoengine.StringField(max_length=60, required=True)
product_id = mongoengine.ObjectIdField(required=True)
store_id = mongoengine.ObjectIdField(required=True)
color_id = mongoengine.ObjectIdField(required=True)
meta = {'allow_inheritance': True}
def __repr__(self):
return '<ProductVariant %r>' % (self.price)
class Booking(mongoengine.EmbeddedDocument):
guest_owner_id = mongoengine.ObjectIdField()
guest_id = mongoengine.ObjectIdField()
booked_date = mongoengine.DateTimeField()
check_in_date = mongoengine.DateTimeField(required=True)
check_out_date = mongoengine.DateTimeField(required=True)
review = mongoengine.StringField()
rating = mongoengine.FloatField(min=0.0)
@property
def duration_in_days(self):
return (self.check_out_date - self.check_in_date).days
class Availability(mongoengine.EmbeddedDocument):
guest_owner_id = mongoengine.ObjectIdField()
guest_snake_id = mongoengine.ObjectIdField()
added_date = mongoengine.DateTimeField()
from_date = mongoengine.DateTimeField(required=True)
to_date = mongoengine.DateTimeField(required=True)
@property
def duration_in_days(self):
dt = self.from_date - self.to_date
return dt.days
class Booking(
mongoengine.EmbeddedDocument
): # here EmbeddedDocument because Booking belongs to another document
guest_owner_id = mongoengine.ObjectIdField(
) # this is a reference hece, the ObjectIdField
guest_snake_id = mongoengine.ObjectIdField()
booked_date = mongoengine.DateTimeField()
check_in_date = mongoengine.DateTimeField(required=True)
check_out_date = mongoengine.DateTimeField(required=True)
review = mongoengine.StringField()
rating = mongoengine.IntField(default=0)
class EmbeddedMessage(db.EmbeddedDocument):
meta = {
'strict': False,
'queryset_class': fm.BaseQuerySet,
}
# Document: _id, Embedded document: id.
id = db.ObjectIdField(required=True, default=lambda: ObjectId())
conversation_id = db.ObjectIdField()
category = db.StringField(choices=["MESSAGE", "VOICE", "IMAGE", "VIDEO", "SYSTEM"], default="MESSAGE")
url = db.StringField()
user_id = db.ObjectIdField()
message = db.StringField()
created_at = db.LongField(required=True)
class User(me.Document):
_id = me.ObjectIdField(required=True)
userID = me.ObjectIdField(required=True)
email = me.EmailField(required=True)
password = me.StringField(required=True)
username = me.StringField(required=True)
firstName = me.StringField(required=True)
lastName = me.StringField(requried=True)
phone = me.StringField(required=True)
created = me.DateTimeField(required=True)
location = me.EmbeddedDocumentField(Location)
rating = me.LongField()
askPosts = me.EmbeddedDocumentListField(AskPost)
givePosts = me.EmbeddedDocumentListField(GivePost)
class Booking(mongoengine.EmbeddedDocument):
guest_owner_id = mongoengine.ObjectIdField()
guest_snake_id = mongoengine.ObjectIdField()
booked_date = mongoengine.DateTimeField()
check_in_date = mongoengine.DateTimeField(required=True)
check_out_date = mongoengine.DateTimeField(required=False)
review = mongoengine.StringField()
rating = mongoengine.IntField(default=0)
@property
def duration_in_days(self) -> int:
date = self.check_out_date - self.check_in_date
return date.days
class Booking(
mongoengine.EmbeddedDocument
): # This class on the other hand is a subclass of an embedded document
# This is so we can embed it into our cages class.
# It means that this class is a not a top level item in mongodb basically,
# It's just put into a top level class (a document! :))
guest_owner_id = mongoengine.ObjectIdField()
guest_snake_id = mongoengine.ObjectIdField()
booked_date = mongoengine.DateTimeField()
check_in_date = mongoengine.DateTimeField(required=True)
check_out_date = mongoengine.DateTimeField(required=True)
review = mongoengine.StringField()
rating = mongoengine.IntField(default=0)
class Booking(mongoengine.EmbeddedDocument):
guest_booker_id = mongoengine.ObjectIdField()
guest_bitch_id = mongoengine.ObjectIdField()
booked_night = mongoengine.DateTimeField()
check_in_date = mongoengine.DateTimeField(required=True)
check_out_date = mongoengine.DateTimeField(required=True)
review = mongoengine.StringField()
rating = mongoengine.IntField(default=0)
@property
def duration_in_days(self):
dt = self.check_out_date - self.check_in_date
return dt.days
class Booking(mongoengine.EmbeddedDocument):
guest_owner_id = mongoengine.ObjectIdField()
guest_snake_id = mongoengine.ObjectIdField()
booked_date = mongoengine.DateTimeField()
check_in_date = mongoengine.DateTimeField(required=True)
check_out_date = mongoengine.DateTimeField(required=True)
review = mongoengine.StringField()
rating = mongoengine.IntField(default=0)
@property
def duration_in_days(self):
dt = self.check_out_date - self.check_in_date + datetime.timedelta(seconds=1)
return dt.days
class Tweet(mongoengine.Document):
""" this is the Tweet object that contains
#date of creation / tweet id / author info / hastags / symbols / urls / retweet / text
*args:
space: space
tweet_id: str
tweet_date: DateTime
author_info: {}
hashtag: []
symbols: []
user_mensions: []
urls: []
retweet: Int
text: str
text: {columnId : column}
hashtag_nodes: List[Node_id]
"""
space_id = mongoengine.ObjectIdField()
tweet_id = mongoengine.StringField(required=True)
registered_date = mongoengine.DateTimeField(default=datetime.datetime.now)
tweet_date = mongoengine.DateTimeField()
author_info = mongoengine.DictField()
hashtag = mongoengine.ListField()
symbols = mongoengine.ListField()
user_mensions = mongoengine.ListField()
urls = mongoengine.ListField()
retweet = mongoengine.IntField()
text = mongoengine.StringField()
hashtag_nodes = mongoengine.ListField()
meta = {'db_alias': 'core', 'collection': 'tweet'}
class Ref3(gj.Document):
ref = gj.FollowReferenceField(Ref2)
refs = db.ListField(gj.FollowReferenceField(Ref2))
emb = db.EmbeddedDocumentField(Ref25)
embs = db.EmbeddedDocumentListField(Ref25)
oids = db.ListField(db.ObjectIdField(),
default=[ObjectId for ignore in range(3)])
class Book(models.Document):
_id = models.ObjectIdField()
name = models.StringField(required=True, max_length=255)
content = models.StringField(required=True)
category = models.ReferenceField(Category)
dimention = models.EmbeddedDocumentField(Dimention)
addresses = models.EmbeddedDocumentListField(Address)
tags = models.ListField(models.ReferenceField(Tag))
meta = {'queryset_class': BaseQuerySet}
def __str__(self):
return self.name
def setByForm(self, form, addressForm):
self.name = form.name.data
self.content = form.content.data
self.category = form.category.data
#self.dimention = form.dimention.data
self.dimention = Dimention(x=form.dimention.x.data,
y=form.dimention.y.data,
z=form.dimention.z.data)
print(form.tags.data)
self.addresses.append(
Address(country=addressForm.country.data,
direction=addressForm.direction.data))
self.tags = form.tags.data
class Quote(mongoengine.Document):
quote = mongoengine.StringField(required=True)
author = mongoengine.StringField(required=True)
source = mongoengine.StringField()
ratings = mongoengine.EmbeddedDocumentListField(QuoteRating)
ratings_avg = mongoengine.FloatField(default=0.0)
added_by = mongoengine.ObjectIdField(required=True)
created_at = mongoengine.DateTimeField(default=datetime.utcnow)
processed_quote = mongoengine.StringField()
last_updated_at = mongoengine.DateTimeField(default=datetime.utcnow)
is_recommended = mongoengine.BooleanField()
meta = {'db_alias': 'core'}
def save(self, *args, **kwargs):
processed_quote = process_quote(self.quote)
self.processed_quote = processed_quote
self.ratings_avg = self.ratings_avg or 0
self.is_recommended = self.ratings_avg > 3
super(Quote, self).save(*args, **kwargs)
def delele(self, *args, **kwargs):
quotes_rated = QuotesRatedByUser.objects().filter(
user_id=self.added_by).first()
if quotes_rated:
quotes_rated.quotes = [
quote for quote in quotes_rated.quotes
if str(quote.id) != str(self.id)
]
quotes_rated.save()
super(Quote, self).delete(*args, **kwargs)
class Caretakers(mongoengine.Document):
created = mongoengine.DateTimeField(default=datetime.datetime.now)
caretaker_id = mongoengine.ObjectIdField(required=True)
name = mongoengine.StringField(required=True)
address = mongoengine.StringField()
phone = mongoengine.StringField()
patients = mongoengine.EmbeddedDocumentListField(Patients)
doctors = mongoengine.ListField()
meta = {
'db_alias':
'core',
'collection':
'caretakers',
'indexes': [
'created',
'caretaker_id',
'name',
'address',
'phone',
'patients',
'doctors',
],
'ordering': ['name']
}
class User(UserMixin, db.Document):
meta = {'collection': 'users'}
email = db.EmailField(unique=True)
confirmed = db.BooleanField(default=False)
username = db.StringField(max_length=100, required=True, unique=True)
pwhash = db.StringField(max_length=128, required=True)
role_id = db.ObjectIdField()
def set_password(self, password):
self.pwhash = generate_password_hash(password)
def verify_password(self, password):
return check_password_hash(self.pwhash, password)
def generate_confirmation_token(self, expiration=3600):
s = Serializer(current_app.config['SECRET_KEY'], expiration)
return s.dumps({'confirm': self.get_id()}).decode('utf-8')
def confirm(self, token):
s = Serializer(current_app['SECRET_KEY'])
try:
data = s.loads(token.encode('utf-8'))
except:
return False
if data.get('confirm') != self.get_id():
return False
self.confirmed = True
self.save()
return True
class Package(mongoengine.Document):
id = mongoengine.StringField(primary_key=True)
created_date = mongoengine.DateTimeField(default=datetime.datetime.now)
summary = mongoengine.StringField()
description = mongoengine.StringField()
home_page = mongoengine.StringField()
docs_url = mongoengine.StringField()
package_url = mongoengine.StringField()
author = mongoengine.StringField()
author_email = mongoengine.StringField()
license = mongoengine.StringField()
maintainers = mongoengine.ListField(mongoengine.ObjectIdField())
meta = {
'db_alias': 'core',
'collection': 'packages',
'indexes': [
'created_date',
'author_email',
'license',
]
}
def __repr__(self):
return '<Package {}>'.format(self.id)
class StudentUser(mongoengine.Document, UserMixin):
meta = {'collection': 'students'}
userID = mongoengine.StringField(required=True)
# profile information -- server/users/students/forms.py
# -- server/users/students/routes.py (createProfile)
username = mongoengine.StringField(required=True)
password = mongoengine.StringField(required=True)
imageFile = mongoengine.ImageField()
# contact information -- server/users/parents/forms.py
# -- server/users/parents/routes.py (register)
firstName = mongoengine.StringField(required=True)
lastName = mongoengine.StringField(required=True)
email = mongoengine.EmailField()
# acquired from parents collection
parent = mongoengine.ObjectIdField()
def getResetToken(self, expiresSec=1800):
s = Serializer(current_app.config['SECRET_KEY'], expiresSec)
return s.dumps({'userID': self.userID}).decode('utf-8')
@staticmethod
def verifyResetToken(token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
userID = s.loads(token)['userID']
except:
return None
return db.students.find_one({"userID": userID})
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.imageFile}')"
class ConsumedItem(mongoengine.EmbeddedDocument):
calories = mongoengine.IntField()
img_url = mongoengine.StringField()
name = mongoengine.StringField()
date = mongoengine.DateTimeField()
quantity = mongoengine.StringField()
item_type = mongoengine.StringField(choices=['food', 'exercise'])
id = mongoengine.ObjectIdField()
def as_dict(self):
return {
'calories': self.calories,
'img_url': self.img_url,
'name': self.name,
'date': self.format_date(),
'quantity': self.quantity,
'item_type': self.item_type,
'id': str(self.id),
}
def format_date(self):
if isinstance(self.date, basestring):
return self.date
else:
return time.mktime(self.date.timetuple()) * 1000
class Comment(me.EmbeddedDocument):
id = me.ObjectIdField(required=True, default=bson.ObjectId)
message = me.StringField(required=True)
replies = me.ListField(me.EmbeddedDocumentField("Comment"))
created_date = me.DateTimeField(required=True,
default=datetime.datetime.now)
updated_date = me.DateTimeField(required=True,
default=datetime.datetime.now)
published_date = me.DateTimeField(required=True,
default=datetime.datetime.now)
status = me.StringField(required=True,
default='draft',
choices=TOPIC_STATUS)
""" status: draft, publish, delete """
ip_address = me.StringField(max_length=100,
required=True,
default='0.0.0.0')
author = me.ReferenceField("User", dbref=True)
def get_topic(self):
topic = Topic.objects(comments__id=self.id).first()
if topic is None:
topic = Topic.objects(comments__replies__id=self.id).first()
if topic is None:
topic = Topic.objects(
comments__replies__replies__id=self.id).first()
return topic
class OrganizationDTO(mongo.Document):
"""A DTO wrapper for Organization documents."""
name = mongo.StringField(db_field='n')
address = mongo.StringField(db_field='a')
latlng = mongo.ListField(db_field='l')
types = mongo.ListField(mongo.IntField(), db_field='ts')
phone_numbers = mongo.ListField(db_field='ns')
email_key = mongo.EmailField(db_field='ek')
emails = mongo.ListField(db_field='es')
contacts = mongo.ListField(mongo.ReferenceField(ContactDTO), db_field='cs')
user_contacts = mongo.ListField(mongo.ReferenceField('UserDTO'),
db_field='us')
organization_url = mongo.StringField(db_field='u')
partners = mongo.ListField(mongo.ReferenceField('self'), db_field='ps')
facebook = mongo.URLField(db_field='f')
twitter = mongo.URLField(db_field='t')
keywords = mongo.StringField(db_field='ks')
valid = mongo.BooleanField(db_field='v', default=True)
last_updated = mongo.DateTimeField(db_field='lu')
updated_by = mongo.ObjectIdField(db_field='ub')
page_rank_info = mongo.EmbeddedDocumentField(document_type=PageRankInfoDTO,
db_field='r')
page_rank = mongo.LongField(min_value=0, db_field='pr')
page_rank_weight = mongo.FloatField(min_value=0.0,
max_value=1.0,
db_field='w')
content_weight = mongo.FloatField(min_value=0.0, db_field='c')
combined_weight = mongo.FloatField(min_value=0.0, db_field='cw')
class Fan(mclient.DynamicDocument):
_id = mclient.ObjectIdField()
user = mclient.StringField(max_length=255)
currentPosition = mclient.PointField()
friends = mclient.ListField(mclient.StringField(max_length=100))
posts = mclient.EmbeddedDocumentListField(document_type=Post)
meta = {'collection': 'Fans'}
class StormFoundationDB(me.Document):
"""
Base abstraction for a model entity. This foundation class should only be directly
inherited from the application domain models.
"""
# ObjectIdField should be not have any constraints like required,
# unique etc for it to be auto-generated.
# TODO: Work out how we can mark this as a unique primary key.
id = me.ObjectIdField()
# see http://docs.mongoengine.org/guide/defining-documents.html#abstract-classes
meta = {'abstract': True}
def __str__(self):
attrs = list()
for k in sorted(self._fields.keys()):
v = getattr(self, k)
v = '"%s"' % str(v) if type(v) in [
str, unicode, datetime.datetime
] else str(v)
attrs.append('%s=%s' % (k, v))
return '%s(%s)' % (self.__class__.__name__, ', '.join(attrs))
def to_serializable_dict(self):
serializable_dict = {}
for k in sorted(six.iterkeys(self._fields)):
v = getattr(self, k)
v = str(v) if isinstance(v, JSON_UNFRIENDLY_TYPES) else v
serializable_dict[k] = v
return serializable_dict
