def follow(): follower = session["other_user"] following = session["username"] followerId = op.get("USERNAME", follower) followingId = op.get("USERNAME", following) val = users.addFollowers(followerId["uid"], followingId["uid"]) return redirect(url_for("get_userline"))
def user_exist(emailid,username): value1 = op.get('USERS',emailid) value2 = op.get('USERNAME',username) if 'status' in value1 or 'status' in value2: return str(1) else : return str(0)
def check_follow(follower,following): followerId = op.get('USERNAME',follower) followingId = op.get('USERNAME',following) val = op.get('FOLLOWING',followingId['uid']) l=val.keys() if followerId['uid'] in l: return 1 else: return 0
def followers(): other_uid = op.get("USERNAME", session["other_user"]) d = op.get("FOLLOWER", other_uid["uid"]) d1 = {} if not (d.has_key("status")): for uid in d.iterkeys(): val = op.get("USERS", uid) d1[uid] = val["username"] return render_template("followers.html", d=d1, username=session["username"], other_user=session["other_user"])
def check_follow(): follower = session["other_user"] following = session["username"] followerId = op.get("USERNAME", follower) followingId = op.get("USERNAME", following) val = op.get("FOLLOWING", followingId) l = val.keys() if followerId in l: return redirect(url_for("get_userline", follow_flag=1)) else: return redirect(url_for("get_userline", follow_flag=0))
def mark_as_favorite(uid,tid): val = is_favourite(uid,tid) if val: d = op.get('FAVORITE_IS', tid) t = d[uid] op.remove_column('FAVORITE_OF', uid,[t]) op.remove_column('FAVORITE_IS', tid,[uid]) else: val = op.get('TWEETS',tid) timestamp = long(time.time() * 1e6) timestamp = str(timestamp) op.insert('FAVORITE_OF', uid, {timestamp:tid}) op.insert('FAVORITE_IS', tid, {uid:timestamp})
def get_userline(): d = {} follow_flag = 0 if "username" not in session or session["username"] is None: return render_template("login.html") if request.method == "GET": if session["username"] != session["other_user"]: follow_flag = users.check_follow(session["other_user"], session["username"]) val = op.get("USERNAME", session["other_user"]) uid = val["uid"] else: uid = session["emailid"] if uid is not None: d, l = get.get_userline(uid) d1, l1 = get.get_favourite(session["emailid"]) d2 = get.get_retweets(session["emailid"]) return render_template( "tweets.html", follow_flag=follow_flag, d=d, l=l, f=l1, username=session["username"], other_user=session["other_user"], retweet=d2, ) else: return render_template("login.html")
def myfavourites(): user = session["other_user"] val = op.get("USERNAME", user) uid = val["uid"] d, l = get.get_favourite(uid) # session['other_user'] = session['username'] return render_template("favourite.html", d=d, l=l, username=session["username"], other_user=session["other_user"])
def checkUser(emailid,pwd): value = op.get('USERS',emailid) if 'status' in value: return str(0) if value['password']==pwd: return value['username'] else: return str(0)
def check_for_reference(body,t,timestamp): body = body.split("@"); body = body[1:] for text in body: text = text.split(" ") text = text[0] value = op.get('USERNAME',text) op.insert('TIMELINE',value['uid'],{timestamp:t})
def is_favourite(uid,tid): "check if tweet has already been marked as favourite" d = op.get('FAVORITE_OF', uid) values = d.values() if tid in values: return True else: return False
def parseNode(arr, ctr): label = int(arr[_n_label_idx]) opCode = int(arr[_n_code_idx]) node = None operation = operations.get(opCode) node = IGR.createOperationNode(environment.getSubGraph(), operation) environment.addNode(label, node)
def retweet(tid, uid): "retweet an existing tweet" timestamp = long(time.time() * 1e6) timestamp = str(timestamp) + ":" + str(uid) t = str(uuid.uuid4()) d = op.get('TWEETS',tid) value = {'body':d['body'], 'user':d['user'], 'timestamp':str(timestamp)} op.insert('TWEETS', t, value) op.insert('USERLINE', uid, {timestamp:t}) op.insert('RETWEET', uid, {tid:t}) print "retweeting" for followerID in op.get('FOLLOWER', uid): print followerID if 'status' != followerID: tweet=str(t)+"!"+str(uid) op.insert('TIMELINE', followerID, {timestamp:tweet}) #DO
class InfixCalculator(object): ops = operations.get() symbols_allowed = [op for op in ops.keys()] + ['(', ')'] def help(self) -> str: return 'Please provide a valid statement with '\ 'operators i.e. {} and positive integers'.format(self.symbols_allowed) def calculate(self, args) -> int: """ args support parentheses, operators {+, -, *, /} and integers """ if not len(args): raise InvalidInputError(self.help()) result = self.__transform(args) calc = PrefixCalculator.PrefixCalculator() return calc.calculate(result) def __transform(self, args) -> list: output = deque() operators = deque() while len(args): arg = args.pop() validation.validate(arg, self.symbols_allowed) if arg == ')': operators.append(arg) elif arg == '(': found = False while len(operators): val = operators.pop() if val == ')': found = True break output.append(val) if not found: raise InvalidInputError('Parentheses mismatch') elif arg in self.ops.keys(): operators.append(arg) else: output.append(arg) while len(operators): val = operators.pop() if not val in self.ops.keys(): raise InvalidInputError('Parentheses mismatch') output.append(val) output.reverse() return output
def untweet(tid, uid): "untweet a retweeted tweet" d = op.get('RETWEET',uid) print d for k in d.keys(): if d[k]==tid or k==tid: t1,t2 = k,d[k] op.remove_column('RETWEET', uid, [t1]) delete_tweet(t2,uid)
def login(uid, password) : "check if a user is valid" print "inside login" try: d = op.get('USERS', uid) if (d['password'] == password) : return 1 else : return 2 except: return 0 return 1
def post_reply(tid, uid, msg) : "reply to a tweet" t = str(uuid.uuid4()) timestamp = long(time.time() * 1e6) timestamp = str(timestamp) value = {'body':msg, 'user':uid, 'timestamp':timestamp} op.insert('TWEETS', t, value) timestamp = timestamp + ":" + uid op.insert('REPLY_TO_TWEET', tid, {timestamp:t}) op.insert('USERLINE',uid, {timestamp:t}) for followerID in op.get('FOLLOWER', uid): if 'status' != followerID: op.insert('TIMELINE', followerID, {timestamp:t}) #DO
def addFollowers(followerID, followingID) : "follower and following a user" t = str(long(time.time() * 1e6)) value = {followingID: t} try: op.insert('FOLLOWER', followerID, value) value = {followerID: t} op.insert('FOLLOWING', followingID, value) val = op.get('USERLINE',followerID) op.insert('TIMELINE',followingID,val) except: return 0 return 1
def delete_tweet(tweetid,uid) : "to delete a tweet" val = op.get('TWEETS',tweetid) op.remove_row('TWEETS', tweetid) key = str(val['timestamp']) + ":" + uid op.remove_column('USERLINE', uid, [key]) #delete from timeline and userline op.remove_column('TIMELINE', uid, [key]) print "during delete " + key for followerID in op.get('FOLLOWER', uid): print followerID if 'status' != followerID: op.remove_column('TIMELINE', followerID, [key]) #delete from followers timeline d = op.get('FAVORITE_IS', tweetid) #delete from favourites list op.remove_row('FAVORITE_IS', tweetid) for key in d: v = str(d[key]) op.remove_column('FAVORITE_OF',key,[v]) d = op.get_all('HASH_TAGS') for k,v in d: for key,val in v.items(): if 'status' != key: if str(tweetid) == str(val): op.remove_column('HASH_TAGS',k,[key])
def post_tweet(msg,uid): "post a tweet" t = str(uuid.uuid4()) timestamp = long(time.time() * 1e6) value = {'body':msg, 'user':uid, 'timestamp':str(timestamp)} op.insert('TWEETS', t, value) timestamp = str(timestamp) + ":" + str(uid) op.insert('USERLINE', uid, {timestamp:t}) # op.insert('TIMELINE', uid, {timestamp:t}) parse(t,uid) for followerID in op.get('FOLLOWER', uid): if 'status' != followerID: op.insert('TIMELINE', followerID, {timestamp:t}) #DO return jsonify({'tid':t,'body':msg,'user':uid})
def get_people(val,uid): "get people" d = op.get('FOLLOWING',uid) result1 = {} if 'status' not in d.keys(): e = op.multi_get('USERS',d.keys()) for k in e.keys(): if e[k]['username'].lower().find(val.lower()) != -1: result1[k] = e[k]['username'] d = op.get_all('USERNAME') result = {} for k,v in d: if k.lower().find(val.lower()) != -1: if v['uid'] not in result1: result[v['uid']] = k return result1,result
class PrefixCalculator(object): ops = operations.get() def __init__(self): self.stack = deque() def help(self) -> str: return 'Please provide a valid statement with '\ 'operators i.e. {} and positive integers'.format([ op for op in self.ops.keys()]) def calculate(self, args) -> int: """ args support operators {+, -, *, /} and integers """ if not len(args): raise InvalidInputError(self.help()) self.stack.clear() while len(args): arg = args.pop() validation.validate(arg, self.ops.keys()) self.__step(arg) if len(self.stack) > 1: raise InvalidInputError( 'Not enough operations to perform calculation') return self.stack.pop() def __step(self, arg) -> None: if not arg in self.ops.keys(): self.stack.append(int(arg)) return if len(self.stack) < 2: raise InvalidInputError('Too many operations for given operands') top = self.stack.pop() bottom = self.stack.pop() val = self.ops[arg](top, bottom) self.stack.append(val)
def unfollow(): "inside unfollow" follower = session["other_user"] following = session["username"] followerId = op.get("USERNAME", follower) followingId = op.get("USERNAME", following) d = op.get("FOLLOWING", followingId["uid"]) uid1 = followerId["uid"] uid2 = followingId["uid"] op.remove_column("FOLLOWING", followingId["uid"], [uid1]) t = op.get("FOLLOWER", followerId["uid"]) op.remove_column("FOLLOWER", followerId["uid"], [uid2]) d = op.get("TIMELINE", uid2) for key, value in d.iteritems(): val = op.get("TWEETS", value) if "status" not in val: if val["user"] == str(uid1): t = str(val["timestamp"]) + ":" + uid1 op.remove_column("TIMELINE", uid2, [t]) return redirect(url_for("get_userline"))
def get_retweets(uid): "get retweets of a user" d = op.get('RETWEET',uid) return d
def get_reply(tid): d = op.get('REPLY_TO_TWEET', tid) replies = d.values() tweets = op.multi_get('TWEETS',replies) original_tweet = op.get('TWEETS',tid) return tweets, replies, original_tweet
def parse(tid,uid): val = op.get('TWEETS',tid) timestamp = str(val['timestamp']) + ":" + str(val['user']) check_for_hashtag(val['body'],tid,timestamp) check_for_reference(val['body'],tid,timestamp)