class Comment(db.Document):
content = db.StringField(required=True)
tweet = db.ReferenceField("Tweet")
create_date = db.DateTimeField(default=dt.now)
commenter = db.ReferenceField(User, dbref=True)
@classmethod
def add(cls, content, tweet, commenter):
c = Comment(content=content, tweet=tweet, commenter=commenter)
c.save()
from message import NotifyMessage
nicknames = find_all_at_users(c.content)
for nickname in nicknames:
receiver = User.get_user_by_nickname(nickname)
NotifyMessage.add(c.notify_render(), c.commenter, receiver)
return c
def notify_render(self):
return render_template("include/comment_notify.html",
sender=self.commenter,
tweet=self.tweet)
@classmethod
def get_comments_bytweetid(cls, tweetid, offset=0, limit=20):
comment_list = []
start = offset * limit
end = offset * limit + limit
comment_list = cls.objects(
tweet=tweetid).order_by('-create_date')[start:end]
return comment_list
class PrivateMessage(db.Document):
content = db.StringField(required = True)
sender = db.ReferenceField(User)
receiver = db.ReferenceField(User)
create_date = db.DateTimeField(default=dt.now)
has_read = db.BooleanField(default=False)
meta = {
'allow_inheritance': False,
'index_types': False,
}
@classmethod
def get_private_message_by_id(cls,id):
return cls.objects(id=id).first()
@classmethod
def add(cls,content,sender,receiver):
pm = cls(content=content,sender=sender,receiver=receiver).save()
notify_user(receiver)
return pm
def safe_delete(self):
self.delete()
@classmethod
def get_user_private_message_counter(cls,user):
return len(cls.objects(receiver=user,has_read=False))
@classmethod
def get_private_message_for_user(cls,user):
return cls.objects(receiver=user).order_by("-create_date")
def read(self,user):
if user != self.receiver:
return False
self.has_read = True
self.save()
return True
class DocItem(db.EmbeddedDocument):
doc = db.ReferenceField(Tweet, required=True)
score = db.FloatField(required=True)
meta = {
'index_types': False,
}
def __hash__(self):
if self.doc is None:
# For new object
return super(BaseDocument, self).__hash__()
else:
return hash(self.doc)
class Follow(db.Document):
follower = db.ReferenceField(User)
followed_user = db.ReferenceField(User)
meta = {
'allow_inheritance': False,
'index_types': False,
'indexes': [
{
'fields': ['follower', 'followed_user'],
'unique': True
},
]
}
@classmethod
def toggle_follow(cls, followerid, followeduserid):
result = cls.objects(follower=followerid,
followed_user=followeduserid).first()
if result:
result.delete()
else:
cls(follower=followerid, followed_user=followeduserid).save()
@classmethod
def get_followers_by_user(cls, user):
return [
x.follower
for x in cls.objects(followed_user=user).only("follower")
]
@classmethod
def get_followed_users_by_user(cls, user):
return [
x.followed_user
for x in cls.objects(follower=user).only("followed_user")
]
class Tweet(db.Document):
content = db.StringField(required = True)
type = db.StringField(default = "text")
originalid = db.StringField(default = "")
retweetid = db.StringField(default = "")
retweet_comment = db.StringField()
create_date = db.DateTimeField(default = dt.now)
extra_pic = db.StringField(default = "")
poster = db.ReferenceField(User, dbref=True)
meta = {
'allow_inheritance': False,
'index_types': False,
}
def __ini__(self):
self._comments = None
def tweet(self):
from message import NotifyMessage
nicknames = find_all_at_users(self.content)
self.save()
for nickname in nicknames:
receiver = User.get_user_by_nickname(nickname)
if receiver is not None:
NotifyMessage.add(self.notify_render(),self.poster,receiver)
def notify_render(self):
return render_template("include/tweet_notify.html",
sender=self.poster,
tweet=self)
@classmethod
def retweetit(cls, originalid, comment, poster):
t = cls.get_tweet_byid(originalid)
ret = cls(content = t.content,
originalid = t.originalid or originalid,
retweetid = originalid,
retweet_comment = comment,
poster = poster).save()
return ret
def is_retweet(self):
return self.originalid!=""
@property
def original_tweet(self):
if not self.originalid:
return None
return Tweet.objects(id=self.originalid).first()
@property
def retweet_tweet(self):
return Tweet.objects(id=self.retweetid).first()
@classmethod
def get_tweets_foruser(cls,user, limit=15, offset=0):
start = offset*limit
end = offset*limit+limit
following_users = user.get_following_users()
tweets = cls.objects(poster__in=[x.id for x in following_users]+[user.id])\
.order_by("-create_date")[start:end]
return tweets
@classmethod
def get_users_tweets(cls, user, limit=15, offset=0):
start = offset*limit
end = offset*limit+limit
tweets = cls.objects(poster=user)\
.order_by("-create_date")[start:end]
return tweets
@classmethod
def get_newest_tweets(cls,limit = 20, offset =0):
start = offset*limit
end = offset*limit+limit
return cls.objects().order_by("-create_date")[start:end]
@classmethod
def get_tweet_byid(cls, id):
tweet = cls.objects(id=id).first()
return tweet
def comment_on(self, commenter, content):
pass
@property
def retweet_counter(self):
return len(Tweet.objects(retweetid=str(self.id)))
@property
def comment_counter(self):
return len(Comment.objects(tweet=self.id))
@property
def comments(self):
self._comments = Comment.get_comments_bytweetid(self.id)
return self._comments