def feed(request):
# calling http://ditto-test.herokuapp.com/api/author/posts?id=ASKING_USERS_ID
# SHOULD just return all posts hosted by OUR server that the dude is supposed to see
# so you can hopefully cut away all the manual parsing done here so far and do something like
# url = http://ditto-test.herokuapp.com/api/author/posts?id=ASKING_USERS_ID
# req = urllib2.Request(url)
# base64string = base64.encodestring('%s:%s' % ("admin", "pass")).replace('\n', '')
# req.add_header("Authorization", "Basic %s" % base64string)
# response = urllib2.urlopen(req).read()
# loaded = json.loads(response)
# loaded['posts'] <- should be a list of all the posts
# or try loaded.get('posts')
# assuming that happens, and that the other servers return the same thing all we have to do is call
# this url once on every server and we are good to go, maybe parsing out duplicates
user_object = User.objects.get(username=request.user.username)
author_object = Author.objects.get(email=user_object)
public_post_list = []
their_post_list = []
try:
foreign_hosts = ForeignHost.objects.filter()
their_post_list, public_post_list = getOurPosts(request, author_object)
for i in foreign_hosts:
# might = authors
if "mighty" in i.url:
url = i.url + "api/author/posts?id=" + str(author_object.id) + "&size=100"
else:
#url = i.url + "api/author/posts?id=" + str(author_object.id) + "&size=100"
url = i.url + "api/posts"
print url
#url = i.url + "api/posts?size=100"
req = urllib2.Request(url)
base64string = base64.encodestring('%s:%s' % (i.username, i.password)).replace('\n', '')
req.add_header("Authorization", "Basic %s" % base64string)
response = urllib2.urlopen(req).read()
loaded = json.loads(response)
their_posts = loaded.get('posts')
print "beep"
for post in their_posts:
comments = []
description = post.get("description")
title = post.get("title")
content = post.get("content")
published_raw = post.get("published")
origin = post.get("origin")
id = post.get("id")
visibility = post.get("visibility")
try:
published = datetime.strptime(published_raw, '%Y-%m-%dT%H:%M:%S.%fZ')
published = published.replace(tzinfo=None)
except Exception as e:
print e
their_comments = post.get("comments")
if len(their_comments) > 0:
for comment1 in their_comments:
comment_body = comment1.get('comment')
comment_author = str(comment1.get('author').get('displayName'))
new_comment = Comment(author_name = comment_author, comment = comment_body)
comments.append(new_comment)
new_post = Post( id = id, description = description, title = title, content = content, published = published, origin = origin, visibility = visibility)
new_post.comments = comments
new_post.magic_author = post.get("author").get("id")
if post.get("visibility"):
public_post_list.append(new_post)
their_post_list.append(new_post)
# print "Main:" + en(their_post_list) + " Pub: " + len(public_post_list)
except Exception as e:
print e
print "couldn't get other hosts posts"
# user_object = User.objects.get(username=request.user.username)
# author_object = Author.objects.get(email=user_object)
github_name = "".join((author_object.github).split())
public_posts = public_post_list
for x in public_posts:
x.published= x.published.replace(tzinfo=None)
public_posts.sort(key=lambda x: x.published, reverse=True)
# # My feed, access all posts that I can see
self_posts = Post.objects.filter(author_id=author_object)
all_comments = Comment.objects.all()
self_posts_list=[]
# Begin My Posts
# self_posts was already created for use
for post in self_posts:
comment_list = []
# print post.id
if (str(author_object.id) == str(post.author)):
post.flag = True
else:
post.flag = False
for comment in all_comments:
if (str(comment.post_id) == str(post.id)):
comment_list.append(comment)
post.comments = comment_list
self_posts_list.append(post)
for x in self_posts_list:
x.published= x.published.replace(tzinfo=None)
self_posts_list.sort(key=lambda x: x.published, reverse=True)
# end of self feed
# start of github feed
github_posts = create_github_post(github_name)
# end of github feed
main_posts = their_post_list
return_main_posts = []
friends = Friend.objects.filter(follower_id=author_object.id)
friends_list = []
for friend in friends:
friends_list.append(str(friend.followed_id))
for post in main_posts:
if str(author_object.id) == str(post.magic_author):
return_main_posts.append(post)
elif str(post.magic_author) in friends_list:
return_main_posts.append(post)
for x in return_main_posts:
x.published= x.published.replace(tzinfo=None)
return_main_posts.sort(key=lambda x: x.published, reverse=True)
context = {
'main_posts': return_main_posts,
'public_posts': public_posts,
'my_posts': self_posts_list,
"github_posts": github_posts,
}
return render(request, 'feed.html', context)
def get_profile(request, pk):
user_object = User.objects.get(username=request.user.username)
us_object = Author.objects.get(email=user_object)
them_object = Author.objects.filter(id=pk)
if len(them_object) == 0:
# this means this profile we want to access is a foreign host
try:
foreign_hosts = ForeignHost.objects.filter()
for i in foreign_hosts:
if 'project' in i.url:
url = i.url + "/api/author"
else:
url = i.url + "/api/authors"
r = requests.get(url, auth=(i.username, i.password))
foreign_authors = json.loads(r.text)
if 'project' in i.url:
for each in foreign_authors:
if each['id'] == pk:
them_object = each
them_id = them_object.get('id')
them_host = them_object.get('host')
break
else:
for each in foreign_authors['authors']:
if each['id'] == pk:
them_object = each
them_id = them_object.get('id')
them_host = them_object.get('host')
break
# get the posts from that user
print them_host
if 'project' in them_host:
them_host = "http://project-c404.rhcloud.com/"
foreign_host = ForeignHost.objects.get(url=them_host)
if "project" not in them_host:
url = them_host + "api/author/" + them_id + "/posts?id=" + str(us_object.id)
else:
url = them_host + "api/author/" + them_id + "/posts/?id=" + str(us_object.id)
print url
req = urllib2.Request(url)
base64string = base64.encodestring('%s:%s' % (foreign_host.username, foreign_host.password)).replace('\n', '')
req.add_header("Authorization", "Basic %s" % base64string)
response = urllib2.urlopen(req).read()
loaded = json.loads(response)
their_posts = loaded.get('posts')
their_post_list = []
for post in their_posts:
comments = []
description = post.get("description")
title = post.get("title")
content = post.get("content")
published_raw = post.get("published")
origin = post.get("origin")
id = post.get("id")
published = datetime.strptime(published_raw, '%Y-%m-%dT%H:%M:%S.%fZ')
published = published.replace(tzinfo=None)
their_comments = post.get("comments")
if len(their_comments) > 0:
for comment1 in their_comments:
comment_body = comment1.get('comment')
comment_author = str(comment1.get('author').get('displayName'))
new_comment = Comment(author_name = comment_author, comment = comment_body)
comments.append(new_comment)
new_post = Post( id = id, description = description, title = title, content = content, published = published, origin = origin)
new_post.comments = comments
their_post_list.append(new_post)
return_posts = their_post_list
for x in return_posts:
x.published= x.published.replace(tzinfo=None)
return_posts.sort(key=lambda x: x.published, reverse=True)
context = {
"sender": us_object,
"them": them_object,
"main_posts": return_posts
}
except Exception as e:
print e
# do something maybe
context = {
"sender": us_object,
"them": them_object,
"main_posts": []
}
else:
them_object = them_object[0]
them_id = str(them_object.id)
them_host = them_object.host
try:
author_object = Author.objects.get(id=pk)
except:
print "Author is offhost and is causing errors later in this code"
asker_host = request.META.get("HTTP_HOST")
try:
asker_object = Author.objects.get(email=request.user)
asker_id = str(asker_object.id)
except:
asker_id = request.GET.get('id', default=None)
if asker_id == None:
return Response({"details": "give and ?id=xxxx"}, status=status.HTTP_400_BAD_REQUEST)
else:
asker_id = str(asker_id)
public_posts = Post.objects.filter(author=author_object, visibility="PUBLIC")
return_posts = public_posts
# the asker is the user itself, return everything
if (pk == asker_id):
all_posts = Post.objects.filter(author=author_object)
return_posts = all_posts
for a in return_posts:
current_post_id = a.id
comments_list = Comment.objects.filter(post_id=current_post_id)
posts_comments = []
for com in comments_list:
comment_body = com.comment
comment_author = com.author_name
new_comment = Comment(author_name=comment_author, comment=comment_body)
posts_comments.append(new_comment)
a.comments = posts_comments
context = {
'sender': us_object,
'them': them_object,
'main_posts': return_posts,
}
return render(request, 'profile.html', context)
# if the asker is a friend
friend_to_author = Friend.objects.filter(follower_id=pk, followed_id=asker_id)
author_to_friend = Friend.objects.filter(follower_id=asker_id, followed_id=pk)
if (len(friend_to_author) == 1) and (len(author_to_friend) == 1):
#then they are friends, because the relationship is mutual
friend_posts = Post.objects.filter(author=author_object, visibility="FRIENDS")
return_posts = return_posts | friend_posts
# if the asker is on our server, and a friend
if (len(Author.objects.filter(id=asker_id)) > 0) and (len(friend_to_author) == 1) and (len(author_to_friend) == 1):
server_friends_posts = Post.objects.filter(author=author_object, visibility="SERVERONLY")
return_posts = return_posts | server_friends_posts
# TODO: Look at FOAF stuff
# asker_id is person A
# as ditto, we need to ask person A's host who A is friends with
# fetch list of A's friends
url = "http://" + asker_host + "/api/friends/" + asker_id
req = urllib2.Request(url)
# assume we are sending to ourselves to begin with, if we are getting this from
# another host then we will update after
base64string = base64.encodestring('%s:%s' % ("admin", "pass")).replace('\n', '')
req.add_header("Authorization", "Basic %s" % base64string)
foreign_hosts = ForeignHost.objects.filter()
for host in foreign_hosts:
# if the sender host, which is a clipped version of the full host path, is part of it, then that host
# is the correct one we're looking for
if asker_host in host.url:
base64string = base64.encodestring('%s:%s' % (host.username, host.password)).replace('\n', '')
req.add_header("Authorization", "Basic %s" % base64string)
response = urllib2.urlopen(req).read()
loaded = json.loads(response)
# we now have a list of authors who are friends with the asker
# if we are friends with any of them then we can give them our FOAF marked posts
# or if we were friends to begin with they can also see FOAF marked posts
for author in loaded['authors']:
# if we are directly friends lets just give it to them
if (len(friend_to_author) == 1) and (len(author_to_friend) == 1):
foaf_posts = Post.objects.filter(author=author_object, visibility="FOAF")
return_posts = return_posts | foaf_posts
break
else:
# we should check if we are friends of any of A's friends
#author is a string of a uuid
a_to_b = Friend.objects.filter(follower_id=pk, followed_id=author)
b_to_a = Friend.objects.filter(follower_id=author, followed_id=pk)
if (len(a_to_b) == 1) and (len(b_to_a) == 1):
# we are friends with one of their friends
foaf_posts = Post.objects.filter(author=author_object, visibility="FOAF")
return_posts = return_posts | foaf_posts
break
for a in return_posts:
current_post_id = a.id
comments_list = Comment.objects.filter(post_id=current_post_id)
posts_comments = []
for com in comments_list:
comment_body = com.comment
comment_author = com.author_name
new_comment = Comment(author_name=comment_author, comment=comment_body)
posts_comments.append(new_comment)
print comment_body
a.comments = posts_comments
context = {
'sender': us_object,
'them': them_object,
'main_posts': return_posts,
}
return render(request, 'profile.html', context)
def getOurPosts(request, author_object):
asker_host = request.META.get("HTTP_HOST")
try:
asker_object = Author.objects.get(email=request.user)
asker_id = str(asker_object.id)
except:
asker_id = request.GET.get('id', default=None)
asker_id = asker_id.strip("/")
if asker_id == None:
return Response({"details": "give and ?id=xxxx"}, status=status.HTTP_400_BAD_REQUEST)
else:
asker_id = str(asker_id)
public_posts = Post.objects.filter(visibility="PUBLIC")
return_posts = public_posts
all_authors = Author.objects.filter()
for each in all_authors:
each_id = str(each.id)
# the asker is the user itself, add in what only they could see
if (each_id == asker_id):
own_posts = Post.objects.filter(author=asker_object)
return_posts = return_posts | own_posts
continue
# if the asker is a friend
friend_to_author = Friend.objects.filter(follower_id=each_id, followed_id=asker_id)
author_to_friend = Friend.objects.filter(follower_id=asker_id, followed_id=each_id)
if (len(friend_to_author) == 1) and (len(author_to_friend) == 1):
#then they are friends, because the relationship is mutual
friend_posts = Post.objects.filter(author=each, visibility="FRIENDS")
return_posts = return_posts | friend_posts
# if the asker is on our server, and a friend
if (len(Author.objects.filter(id=asker_id)) > 0) and (len(friend_to_author) == 1) and (len(author_to_friend) == 1):
server_friends_posts = Post.objects.filter(author=each, visibility="SERVERONLY")
return_posts = return_posts | server_friends_posts
# asker_id is person A
# as ditto, we need to ask person A's host who A is friends with
# fetch list of A's friends
url = "http://" + asker_host + "/api/friends/" + asker_id + "?size=100"
req = urllib2.Request(url)
# assume we are sending to ourselves to begin with, if we are getting this from
# another host then we will update after
base64string = base64.encodestring('%s:%s' % ("admin", "pass")).replace('\n', '')
req.add_header("Authorization", "Basic %s" % base64string)
foreign_hosts = ForeignHost.objects.filter()
for host in foreign_hosts:
# if the sender host, which is a clipped version of the full host path, is part of it, then that host
# is the correct one we're looking for
if asker_host in host.url:
base64string = base64.encodestring('%s:%s' % (host.username, host.password)).replace('\n', '')
req.add_header("Authorization", "Basic %s" % base64string)
response = urllib2.urlopen(req).read()
loaded = json.loads(response)
# we now have a list of authors who are friends with the asker
# if we are friends with any of them then we can give them our FOAF marked posts
# or if we were friends to begin with they can also see FOAF marked posts
for author in loaded['authors']:
# if we are directly friends lets just give it to them
if ((len(friend_to_author) == 1) and (len(author_to_friend) == 1)) or (each_id == asker_id):
foaf_posts = Post.objects.filter(author=each, visibility="FOAF")
return_posts = return_posts | foaf_posts
break
else:
# we should check if we are friends of any of A's friends
#author is a string of a uuid
a_to_b = Friend.objects.filter(follower_id=asker_id, followed_id=author)
b_to_a = Friend.objects.filter(follower_id=author, followed_id=asker_id)
if (len(a_to_b) == 1) and (len(b_to_a) == 1):
# we are friends with one of their friends
foaf_posts = Post.objects.filter(author=each, visibility="FOAF")
return_posts = return_posts | foaf_posts
break
response = PostSerializer(return_posts, many=True)
beep = {"query": "posts", "count": len(return_posts), "size": "10", "next": "http://nextpageurlhere",
"previous": "http://previouspageurlhere", "posts": response.data}
boop = json.dumps(beep)
loaded = json.loads(boop)
our_posts = loaded.get('posts')
return_public_posts = []
return_main_posts = []
for post in our_posts:
comments = []
description = post.get("description")
title = post.get("title")
content = post.get("content")
published_raw = post.get("published")
origin = post.get("origin")
id = post.get("id")
visibility = post.get("visibility")
published = datetime.strptime(published_raw, '%Y-%m-%dT%H:%M:%S.%fZ')
published = published.replace(tzinfo=None)
their_comments = post.get("comments")
if len(their_comments) > 0:
for comment1 in their_comments:
comment_body = comment1.get('comment')
comment_author = str(comment1.get('author').get('displayName'))
new_comment = Comment(author_name = comment_author, comment = comment_body)
comments.append(new_comment)
new_post = Post( id = id, description = description, title = title, content = content, published = published, origin = origin, visibility = visibility)
new_post.comments = comments
new_post.magic_author = post.get("author").get("id")
if (str(author_object.id) == str(post.get('author').get('id'))):
new_post.flag = True
else:
new_post.flag = False
if post.get("visibility") == "PUBLIC":
return_public_posts.append(new_post)
return_main_posts.append(new_post)
return return_main_posts, return_public_posts
