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")] }