class Save_valuation(db.Document):
stock_id = db.StringField(max_length=10, required=True)
form_data = db.DictField()
from_user = db.ReferenceField(User, reverse_delete_rule=CASCADE)
created = db.IntField(default=now())
meta = {'indexes': ['stock_id', ('stock_id', 'from_user')]}
class Message(db.Document):
from_user = db.ReferenceField(User, db_field="fu", reverse_delete_rule=CASCADE)
to_user = db.ReferenceField(User, db_field="tu", default=None, reverse_delete_rule=CASCADE)
text = db.StringField(db_field="t", max_length=1024)
live = db.BooleanField(db_field="l", default=None)
create_date = db.IntField(db_field="c", default=now())
parent = db.ObjectIdField(db_field="p", default=None)
images = db.ListField(db_field="ii")
message_type = db.IntField(db_field='mt', default=POST, choices=MESSAGE_TYPE)
@property
def text_linkified(self):
return linkify(self.text)
@property
def human_timestamp(self):
return ms_stamp_humanize(self.create_date)
@property
def comments(self):
return Message.objects.filter(parent=self.id, message_type=COMMENT).order_by('create_date')
@property
def likes(self):
return Message.objects.filter(parent=self.id, message_type=LIKE).order_by('-create_date')
def post_imgsrc(self, image_ts, size):
if AWS_BUCKET:
return os.path.join(AWS_CONTENT_URL, AWS_BUCKET, 'posts', '%s.%s.%s.png' % (self.id, image_ts, size))
else:
return url_for('static', filename=os.path.join(STATIC_IMAGE_URL, 'posts', '%s.%s.%s.png' % (self.id, image_ts, size)))
meta = {
'indexes': [('from_user', 'to_user', '-create_date', 'parent', 'live')]
}
class Feed(db.Document): # Representation of messages per user
user = db.ReferenceField(User, db_field="u", reverse_delete_rule=CASCADE)
message = db.ReferenceField(Message,
db_field="m",
reverse_delete_rule=CASCADE)
create_date = db.LongField(db_field="c", default=now())
meta = {"indexes": [("user", "-create_date")]}
class Feed(db.Document):
user = db.ReferenceField(User, db_field="u", reverse_delete_rule=CASCADE)
message = db.ReferenceField(Message,
db_field="m",
reverse_delete_rule=CASCADE)
create_date = db.LongField(db_field="c", default=now())
meta = {'indexes': [('user', '-create_date')]}
def thumbnail_process(file,
content_type,
content_id,
sizes=[("sm", 50), ("lg", 75), ("xlg", 200)]):
image_id = now()
filename_template = content_id + '.%s.%s.png'
#Original image
with Image(filename=file) as img:
crop_center(img)
img.format = 'png'
img.save(filename=os.path.join(UPLOAD_FOLDER, content_type,
filename_template % (image_id, 'raw')))
#go through 3 sizes in array
for (name, size) in sizes:
with Image(filename=file) as img:
crop_center(img)
img.sample(size, size)
img.format = 'png'
img.save(filename=os.path.join(
UPLOAD_FOLDER, content_type, filename_template %
(image_id, name)))
# after setting sizes, assign Amazon settings
if AWS_BUCKET:
s3 = boto3.client('s3')
transfer = S3Transfer(s3)
transfer.upload_file(
os.path.join(UPLOAD_FOLDER, content_type,
filename_template % (image_id, 'raw')),
AWS_BUCKET,
os.path.join(content_type, filename_template % (image_id, 'raw')),
extra_args={
'ACL': 'public-read',
'ContentType': 'image/png'
})
os.remove(
os.path.join(UPLOAD_FOLDER, content_type,
filename_template % (image_id, 'raw')))
for (name, size) in sizes:
transfer.upload_file(
os.path.join(UPLOAD_FOLDER, content_type,
filename_template % (image_id, name)),
AWS_BUCKET,
os.path.join(content_type,
filename_template % (image_id, name)),
extra_args={
'ACL': 'public-read',
'ContentType': 'image/png'
})
os.remove(
os.path.join(UPLOAD_FOLDER, content_type,
filename_template % (image_id, name)))
os.remove(file)
return image_id
class Feed(db.Document):
user = db.ReferenceField(User, db_field="u", reverse_delete_rule=CASCADE)
message = db.ReferenceField(Message, db_field="m", reverse_delete_rule=CASCADE)
parent = db.ObjectIdField(db_field="p", default=None)
create_date = db.IntField(db_field="cd", default=now())
meta = {
'indexes': [('user', 'parent', '-create_date')]
}
class User(db.Document):
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=now())
bio = db.StringField(db_field="b", max_length=160)
meta = {'indexes': ['username', 'email', '-created']}
def attime_record(name, object_id, total, sale):
rec = SendNumber(name=name,
for_who=object_id,
number_time=total,
date_time=now(),
readable_date=f'{human_date(now())}',
sale=sale)
rec.save()
return rec
class BestProduct(db.DynamicDocument):
meta = {'collection': 'best_product', 'indexes': ['t']}
asin = db.StringField(db_field="asin", required=True)
avgOverall = db.FloatField(db_field="ao")
title = db.StringField(db_field="t", required=True)
price = db.FloatField(db_field="p")
imageUrl = db.StringField(db_field="iu")
description = db.StringField(db_field="d")
cnt = db.IntField(db_field="cnt")
created = db.IntField(db_field="dc", default=now())
class Relationship(db.Document):
FRIENDS = 1
BLOCKED = -1
RELATIONSHIP_TYPE = (
(FRIENDS, 'Friends'),
(BLOCKED, 'Blocked'),
)
PENDING = 0
APPROVED = 1
STATUS_TYPE = (
(PENDING, 'Pending'),
(APPROVED, 'Approved'),
)
from_user = db.ReferenceField(User,
db_field='fu',
reverse_delete_rule=CASCADE)
to_user = db.ReferenceField(User,
db_field='tu',
reverse_delete_rule=CASCADE)
rel_type = db.IntField(db_field='rt', choices=RELATIONSHIP_TYPE)
status = db.IntField(db_field='s', choices=STATUS_TYPE)
req_date = db.IntField(db_field='rd', default=now())
approved_date = db.IntField(db_field='ad', default=0)
@staticmethod
def get_relationship(from_user, to_user):
rel = Relationship.objects.filter(from_user=from_user,
to_user=to_user).first()
if rel and rel.rel_type == Relationship.FRIENDS:
if rel.status == Relationship.PENDING:
return "FRIENDS_PENDING"
if rel.status == Relationship.APPROVED:
return "FRIENDS_APPROVED"
elif rel and rel.rel_type == Relationship.BLOCKED:
return "BLOCKED"
else:
reverse_rel = Relationship.objects.filter(
from_user=to_user, to_user=from_user).first()
if reverse_rel and reverse_rel.rel_type == Relationship.FRIENDS:
if reverse_rel.status == Relationship.PENDING:
return "REVERSE_FRIENDS_PENDING"
elif reverse_rel and reverse_rel.rel_type == Relationship.BLOCKED:
return "REVERSE_BLOCKED"
return None
# compound index
meta = {
'indexes': [('from_user', 'to_user'),
('from_user', 'to_user', 'rel_type', 'status')]
}
class Message(db.Document):
from_user = db.ReferenceField(User,
db_field="fu",
reverse_delete_rule=CASCADE)
to_user = db.ReferenceField(User,
db_field="tu",
default=None,
reverse_delete_rule=CASCADE)
text = db.StringField(db_field="t", max_length=1024)
live = db.BooleanField(db_field="l", default=None)
create_date = db.LongField(db_field="c", default=now())
parent = db.ObjectIdField(db_field="p", default=None)
images = db.ListField(db_field="ii")
message_type = db.IntField(db_field="mt",
default=POST,
choices=MESSAGE_TYPE)
@property
def text_linkify(self):
return linkify(self.text)
@property
def human_timestamp(self):
return ms_stamp_humanize(self.create_date)
@property
def comments(self):
return Message.objects.filter(
parent=self.id, message_type=COMMENT).order_by("create_date")
@property
def likes(self):
return Message.objects.filter(
parent=self.id, message_type=LIKE).order_by("-create_date")
def post_imgsrc(self, image_ts, size):
if AWS_BUCKET:
return os.path.join(
AWS_CONTENT_URL, AWS_BUCKET, "posts",
"{0}{1}.{2}.png".format(self.id, image_ts, size))
else:
return url_for("static",
filename=os.path.join(
STATIC_IMAGE_URL, "posts",
"{0}{1}.{2}.png".format(self.id, image_ts,
size)))
meta = {
"indexes": [("from_user", "to_user", "-create_date", "parent",
"message_type", "live")]
}
class Message(db.Document):
from_user = db.ReferenceField(User, db_field="fu", reverse_delete_rule=CASCADE)
#optional, if not set, from_user is broadcasting. If set message sent to specific person
to_user = db.ReferenceField(User, db_field="tu", default=None, reverse_delete_rule=CASCADE)
text = db.StringField(db_field="t", max_length=300)
live = db.BooleanField(db_field="l", default=None)
create_date = db.IntField(db_field="cd", default=now())
parent = db.ObjectIdField(db_field="p", default=None)
image = db.StringField(db_field="i", default=None)
meta = {
'indexes': [('from_user', 'to_user', '-create_date', 'parent', 'live')]
}
class User(db.Document):
username = db.StringField(db_field='u', unique=True)
password = db.StringField(db_field='pwd')
email = db.EmailField(db_field='em', required=True, unique=True)
first_name = db.StringField(db_field="fn", max_length=50, default=None)
last_name = db.StringField(db_field="ln", max_length=50, default=None)
created = db.IntField(db_field='c', default=now())
email_confirmed = db.BooleanField(db_field="ecf", default=False)
change_configuration = db.DictField(db_field="cc")
profile_image = db.StringField(db_field="i", default=None)
facebook_link = db.StringField(db_field="fb")
tel = db.StringField(db_field="tl")
provider = db.StringField(db_field="pv", default='local')
@classmethod
def pre_save(cls, sender, document, **kwargs): #don't understand
if document.username:
document.username = document.username.lower()
document.email = document.email.lower()
def user_imgsrc(self, size):
if self.profile_image:
if AWS_BUCKET:
return os.path.join(
AWS_CONTENT_URL, AWS_BUCKET, 'user',
'%s.%s.%s.png' % (self.id, self.profile_image, size))
else:
return url_for(
'static',
filename=os.path.join(
STATIC_IMAGE_URL, 'user', '%s.%s.%s.jpg' %
(self.id, self.profile_image, size))).replace(
"%5C", "/")
else:
return url_for('static',
filename=os.path.join(
'assets', 'default_image',
'default-profile.png')).replace('%5C', '/')
#Class method to add Notification delete old one
def add_notification(self, name, data):
Notification.objects.filter(name=name, user_id=self.id).delete()
n = Notification(name=name,
payload_json=json.dumps(data),
user_id=self.id)
n.save()
return n
meta = {'indexes': ['username', 'email', '-created']}
class User(db.Document):
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=now())
bio = db.StringField(db_field='b', max_length=160)
@classmethod
def pre_save(cls, sender, document, **kwargs):
document.username = document.username.lower()
document.email = document.email.lower()
meta = {'indexes': ['username', 'email', '-created']}
class User(db.Document):
username = db.StringField(db_field='u', required=True)
password = db.StringField(db_field='p', required=True)
email = db.EmailField(db_field='e', required=True)
first_name = db.StringField(db_field='fn', max_length=20)
last_name = db.StringField(db_field='ln', max_length=20)
created = db.IntField(db_field='cr', default=now())
bio = db.StringField(db_field='b', max_length=160)
# @classmethod # decorator used to save the credentials in lowercase
# def pre_save(cls, sender, document, **kwargs):
# document.username = document.username.lower()
# email.username = email.username.lower()
# signals.pre_save.connect(User.pre_save, sender = User)
class Links(db.Document):
l_id = db.IntField(db_field="l_id", required=True, unique=True)
project = db.StringField(db_field="p", required=True)
sa = db.IntField(db_field="sa", required=True)
ss = db.StringField(db_field="ss", required=True)
sp = db.StringField(db_field="sp", required=True)
sip = db.StringField(db_field="sip", required=True)
sm = db.IntField(db_field="sm", required=True)
sn = db.StringField(db_field="sn", required=True)
la = db.IntField(db_field="la", required=True)
ls = db.StringField(db_field="ls", required=True)
lp = db.StringField(db_field="lp", required=True)
lip = db.StringField(db_field="lip", required=True)
lm = db.IntField(db_field="lm", required=True)
ln = db.StringField(db_field="ln", required=True)
created = db.IntField(db_field="c", default=now())
class Review(db.DynamicDocument):
meta = {
'collection': 'reviews',
'indexes': ['asin', 'reviewerID', 'pI', '-unixReviewTime', 'rI'],
'shard_key': ('asin', 'reviewerID'),
}
userid = db.StringField(db_field="reviewerID", required=True)
reviewerIntId = db.IntField(db_field="rI")
productIntId = db.IntField(db_field="pI")
productid = db.StringField(db_field="asin", required=True)
username = db.StringField(db_field="reviewerName")
helpful = db.ListField(db_field="helpful")
created = db.IntField(db_field="unixReviewTime", default=now())
review = db.StringField(db_field="reviewText")
overall = db.FloatField(db_field="overall")
title = db.StringField(db_fiedl="summary")
def request_veri(storecode):
ref = request.referrer
store = Store.objects.filter(storecode=storecode).first()
logged_user = User.objects.filter(email=session.get('email')).first()
if store:
rel = Relationship.objects.filter(what_user=logged_user,
what_store=store).first()
rel.verify = Relationship.PENDING
rel.request_date = now()
rel.save()
if ref:
return redirect(ref)
else:
return redirect(url_for('core.store_end', storecode=storecode))
else:
abort(404)
def make_recommendation_model(self):
self.create_spark_app()
reviews = self.return_col(col_name="reviews")
users = self.return_col(col_name="user")
selectedDf = reviews\
.select("rI", "pI", "overall")
# Develop Model
als = ALS(maxIter=10,
regParam=0.01,
userCol="rI",
itemCol="pI",
ratingCol="overall",
coldStartStrategy="nan")
alsModel = als.fit(selectedDf)
# Only make recommendation for active users
activeUsers = [x.rI for x in users.select("rI").collect()]
selectedData = selectedDf[selectedDf.rI.isin(activeUsers)]
# make reverse tarnsform to productID and userID
num_recommends = 10
recommendationData = alsModel.recommendForUserSubset(
selectedData, num_recommends)
recommendations = F.array(*[
F.struct(
F.col("recommendations")[i]["pI"].alias("pI"),
F.col("recommendations")[i]["rating"].cast("double").alias(
"rating")) for i in range(num_recommends)
])
recommendationData = recommendationData\
.withColumn("recommendations", recommendations)
createdDate = now()
recommendationData = recommendationData.withColumn(
"dc", F.lit(createdDate))
# Save data to mongodb
col_name = self.MONGO_URI + ".recommendation_table"
recommendationData.write\
.format("com.mongodb.spark.sql.DefaultSource")\
.mode("append")\
.option("uri", col_name)\
.save()
self.spark.catalog.clearCache()
self.spark.stop()
class User(db.Document):
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=now())
bio = db.StringField(db_field="b", max_length=160)
email_confirmed = db.BooleanField(db_field="ecf", default=False)
change_configuration = db.DictField(db_field="cc")
@classmethod
def pre_save(cls, sender, document, **kwargs):
document.username = document.username.lower()
document.email = document.email.lower()
meta = {'indexes': ['username', 'email', '-created']}
class User(db.Document):
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=now())
bio = db.StringField(db_field="b", max_length=160)
email_confirmed = db.BooleanField(db_field="ecf", default=False)
change_configuration = db.DictField(db_field="cc")
profile_image = db.StringField(db_field="i", default=None)
# Make username and email all lowercase
# This method is called before object is written to the database
@classmethod
# Do any manipulations you need to do within pre_save
def pre_save(cls, sender, document, **kwargs):
document.username = document.username.lower()
document.email = document.email.lower()
def profile_imgsrc(self, size):
# return os.path.join(IMAGE_URL, "user", "%s%s.%s.png" % (self.id,
# self.profile_image, size))
if self.profile_image:
if AWS_BUCKET:
return os.path.join(
AWS_CONTENT_URL, AWS_BUCKET, "user",
"{0}{1}.{2}.png".format(self.id, self.profile_image, size))
else:
return url_for("static",
filename=os.path.join(
STATIC_IMAGE_URL, "user",
"{0}{1}.{2}.png".format(
self.id, self.profile_image, size)))
else:
return url_for("static",
filename=os.path.join(
STATIC_IMAGE_URL, "user",
"no-profile.{0}.png".format(size)))
# Add indexes
meta = {
"indexes": ["username", "email", "-created"]
# -created means sort order reversed to get most recent members
}
class Message(db.Document):
fromUser = db.ReferenceField(User, db_field="fu", reverse_delete_rule=CASCADE)
toUser = db.ReferenceField(User, db_field="tu", default=None, reverse_delete_rule=CASCADE)
text = db.StringField(db_field="t", max_length=1024)
live = db.BooleanField(db_field="l", default=True)
createDate = db.LongField(db_field="c", default=now())
parent = db.ObjectIdField(db_field="p", default=None)
image = db.StringField(db_field="i", default=None)
messageType = db.IntField(db_field="mt", default=POST, choices=messageType)
@property
def comments(self):
return Message.objects.filter(parent=self.id, messageType=COMMENT).order_by('createDate')
@property
def likes(self):
return Message.objects.filter(parent=self.id, messageType=LIKE).order_by('-createDate')
@property
def linkifyText(self):
return linkify(self.text)
@property
def humanTimestamp(self):
return ms_stamp_humanize(self.createDate)
def post_imgsrc(self, size):
if self.image:
return self.image
else:
return 'no-post.%s.png'
meta = {'indexes' :
[
{
'fields' : ['$text', '$createDate', '$fromUser', '$toUser'],
'default_language': 'english',
'weights' : {'text' : 10, 'createDate' : 8, 'fromUser' : 6, 'toUser' : 4}
}
]}
class User(db.Document):
username = db.StringField(db_field="u", required=True, unique=True)
# db_field is used incase of high traffic app. Reference to username as u, to save lot of characters.
password = db.StringField(db_field="p", required=True)
email = db.StringField(db_field="e", required=True, unique=True)
firstname = db.StringField(db_field='fn', required=True, max_length=50)
lastname = db.StringField(db_field='ln', required=True, max_length=50)
created = db.IntField(db_field='c', default=now())
bio = db.StringField(db_field='b', max_length=160)
@classmethod # buildin mongoengine method , its always called before object is writen to db
def pre_save(cls, sender, document, **kwarge):
document.username = document.username.lower()
document.email = document.email.lower()
meta = { # Creating index to make seach quicker
'indexes': [
'username', 'email', '-created'
] # -created : Sort Order should be reversed! Most recent created first
}
def thumbnail_process(file, content_type, content_id, sizes=[("sm", 50), ("lg", 75), ("xlg", 200)]):
image_id = now()
filename_template = content_id + '.%s.%s.png'
# original
with Image(filename=file) as img:
crop_center(img)
img.format = 'png'
img.save(filename=os.path.join(UPLOAD_FOLDER, content_type, filename_template % (image_id, 'raw')))
# sizes
for (name, size) in sizes:
with Image(filename=file) as img:
crop_center(img)
img.sample(size, size)
img.format = 'png'
img.save(filename=os.path.join(UPLOAD_FOLDER, content_type, filename_template % (image_id, name)))
if AWS_BUCKET:
s3 = boto3.client('s3')
transfer = S3Transfer(s3)
transfer.upload_file(
os.path.join(UPLOAD_FOLDER, content_type, filename_template % (image_id, 'raw')),
AWS_BUCKET,
os.path.join(content_type, filename_template % (image_id, 'raw')),
extra_args={'ACL': 'public-read', 'ContentType': 'image/png'}
)
os.remove(os.path.join(UPLOAD_FOLDER, content_type, filename_template % (image_id, 'raw')))
for (name, size) in sizes:
transfer.upload_file(
os.path.join(UPLOAD_FOLDER, content_type, filename_template % (image_id, name)),
AWS_BUCKET,
os.path.join(content_type, filename_template % (image_id, name)),
extra_args={'ACL': 'public-read', 'ContentType': 'image/png'}
)
os.remove(os.path.join(UPLOAD_FOLDER, content_type, filename_template % (image_id, name)))
os.remove(file)
return image_id
class User(db.Document):
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, required=True)
last_name = db.StringField(db_field="ln", max_length=50, required=True)
bio = db.StringField(db_field="b", max_length=128)
created = db.IntField(db_field="c", default=now())
meta = {"indexes": ["username", "email", "-created"]}
@property
def serialize(self):
return {
"bio": self.bio,
"id": str(self.id),
"email": self.email,
"created": self.created,
"username": self.username,
"last_name": self.last_name,
"first_name": self.first_name,
}
class User(db.Document):
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=now())
bio = db.StringField(db_field="b", max_length=160)
email_confirmed = db.BooleanField(db_field="ecf", default=False)
change_configuration = db.DictField(db_field="cc")
profile_image = db.StringField(db_field="i", 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):
return os.path.join(
STATIC_IMAGE_URL, 'user',
'%s.%s.%s.png' % (self.id, self.profile_image, size))
meta = {'indexes': ['username', 'email', '-created']}
def return_best_books(self, minimum_count=10, limit_count=10):
self.create_spark_app()
products = self.return_col(col_name="products")
reviews = self.return_col(col_name="reviews")
grouped = reviews\
.groupBy("asin")\
.agg(F.count("asin").alias("cnt"), F.avg("overall").alias("avgOverall"))\
.sort(F.desc("avgOverall"), F.desc("cnt"))\
.select("asin", "avgOverall", "cnt")\
.filter(F.col("cnt") >= minimum_count)\
.limit(limit_count)
grouped.cache()
bestReviews = grouped.alias('g')\
.join(
products.alias('p'),
F.col("g.asin") == F.col("p.asin")
)\
.select(
F.col("g.asin").alias("asin"),
F.col("g.avgOverall").alias("ao"),
F.col("p.title").alias("t"),
F.col("p.price").alias("p"),
F.col("p.imUrl").alias("iu"),
F.col("p.description").alias("d"),
F.col("g.cnt").alias("cnt"),
)
createdDate = now()
bestReviews_with_dates = bestReviews.withColumn(
"cd", F.lit(createdDate))
best_product_uri = self.MONGO_URI + ".best_product"
bestReviews_with_dates.write\
.format("com.mongodb.spark.sql.DefaultSource")\
.mode("append")\
.option("uri", best_product_uri)\
.save()
self.spark.catalog.clearCache()
self.spark.stop()
class RecommendTable(db.DynamicDocument):
meta = {'collection': 'recommendation_table', 'indexes': ['t']}
userIntId = db.IntField(db_field="rI")
recommendList = db.ListField(db_field="recommendations", required=True)
created = db.IntField(db_field="dc", default=now())
class Relationship(db.Document):
FRIENDS = 1
BLOCKED = -1
RELATIONSHIP_TYPE = (
(FRIENDS, 'Friends'),
(BLOCKED, 'Blocked'),
)
PENDING = 0
APPROVED = 1
STATUS_TYPE = (
(PENDING, 'Pending'),
(APPROVED, 'Approved'),
)
fromUser = db.ReferenceField(User,
db_field="fu",
reverse_delete_rule=CASCADE)
toUser = db.ReferenceField(User,
db_field="tu",
reverse_delete_rule=CASCADE)
rel_type = db.IntField(db_field="rt", choices=RELATIONSHIP_TYPE)
status = db.IntField(db_field="s", choices=STATUS_TYPE)
req_date = db.IntField(db_field="rd", default=now())
approved_date = db.IntField(db_field="ad", default=0)
def is_friend(self, user):
if user:
return self.get_relationship(user, self.toUser)
else:
return None
@staticmethod
def get_relationship(fromUser, toUser):
if fromUser == toUser:
return 'SAME'
rel = Relationship.objects.filter(fromUser=fromUser,
toUser=toUser).first()
if rel and rel.rel_type == Relationship.FRIENDS:
if rel.status == Relationship.PENDING:
return "FRIENDS_PENDING"
if rel.status == Relationship.APPROVED:
return "FRIENDS_APPROVED"
elif rel and rel.rel_type == Relationship.BLOCKED:
return "BLOCKED"
else:
reverse_rel = Relationship.objects.filter(
fromUser=toUser,
toUser=fromUser,
).first()
if reverse_rel and reverse_rel.rel_type == Relationship.FRIENDS:
if reverse_rel.status == Relationship.PENDING:
return "REVERSE_FRIENDS_PENDING"
elif reverse_rel and reverse_rel.rel_type == Relationship.BLOCKED:
return "REVERSE_BLOCKED"
return None
meta = {
'indexes': [('fromUser', 'toUser'),
('fromUser', 'toUser', 'rel_type', 'status')]
}
class FireWalls(db.Document):
firewall_ip = db.StringField(db_field="f", required=True, unique=True)
ha_pair_id = db.StringField(db_field="h", required=True)
created = db.IntField(db_field="c", default=now())
class Relationship(db.Document):
# Set up some constants
FRIENDS = 1
BLOCKED = -1
# Set up choices; tuple of tuples
# Choices limit the number of options a field can have.
# Choices allows to provide a list to be associated with the field's values.
RELATIONSHIP_TYPE = (
(FRIENDS, "Friends"),
(BLOCKED, "Blocked"),
)
# Status choices
PENDING = 0
APPROVED = 1
STATUS_TYPE = (
(PENDING, "Pending"),
(APPROVED, "Approved"),
)
# Two records per relationship
# foreign key to a user
# With CASCADE, all relationships are deleted if user is deleted
from_user = db.ReferenceField(User,
db_field="fu",
reversed_delete_rule=CASCADE)
to_user = db.ReferenceField(User,
db_field="tu",
reversed_delete_rule=CASCADE)
rel_type = db.IntField(db_field="rt", choices=RELATIONSHIP_TYPE)
status = db.IntField(db_field="s", choices=STATUS_TYPE)
req_date = db.IntField(db_field="rd", default=now())
approved_date = db.IntField(db_field="ad", default=0)
def is_friend(self, user):
if user:
return self.get_relationship(user, self.to_user)
else:
return None
# A static method doesn't need an instance of the class to be used.
# A static method allows to use it globally on the class.
# Get relationship from two users
@staticmethod
def get_relationship(from_user, to_user):
if from_user == to_user:
return "SAME"
rel = Relationship.objects.filter(from_user=from_user,
to_user=to_user).first()
if rel and rel.rel_type == Relationship.FRIENDS:
if rel.status == Relationship.PENDING:
return "FRIENDS_PENDING"
if rel.status == Relationship.APPROVED:
return "FRIENDS_APPROVED"
elif rel and rel.rel_type == Relationship.BLOCKED:
return "BLOCKED"
else:
reverse_rel = Relationship.objects.filter(
from_user=to_user, to_user=from_user).first()
if reverse_rel and reverse_rel.rel_type == Relationship.FRIENDS:
if reverse_rel.status == Relationship.PENDING:
return "REVERSE_FRIENDS_PENDING"
elif reverse_rel and reverse_rel.rel_type == Relationship.BLOCKED:
return "REVERSE_BLOCKED"
return None
# Indexes; compound indexes which are in ()
meta = {
"indexes": [("from_user", "to_user"),
("from_user", "to_user", "rel_type", "status")]
}
