예제 #1
0
def follower_stream(request):
    context = dict()
    context['page_name'] = "Follower Stream"
    p = get_object_or_404(Profile, profile_user = request.user)

    if request.method == "POST":
        # create post
        new_post = Post()
        new_post_form = PostForm(request.POST, instance=new_post)
        new_post.post_date_time = timezone.now()
        new_post.post_profile = p

        if not new_post_form.is_valid():
            context['post_form'] = new_post_form
            return render(request, 'socialnetwork/follower_stream.html', context)

        new_post_form.save()
        context['message'] = "Post created"
    

    # display all posts
    context['post_form'] = PostForm()
    all_posts = Post.objects.order_by('post_date_time').reverse()
    # context['all_posts'] = all_posts.filter(post_profile__in = p.following.all())
    return render(request, 'socialnetwork/global_stream.html', context)
예제 #2
0
def add_post(request):
    context = {}
    if request.method == 'GET':
        context['form'] = PostForm()
        context['posts'] = Post.objects.all().order_by('-date')
        context['comments'] = Comment.objects.all().order_by('comment_date_time')
        # print(context['comments'])
        return render(request, 'socialnetwork/global_stream.html', context)
    new_post = Post()
    new_post.poster = request.user
    new_post.poster_name = new_post.poster.username
    new_post.poster_user_id = new_post.poster.id
    print("time_now: ", timezone.now())
    new_post.date = parse_datetime(timezone.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-4])
    # new_post.date = parse_datetime(timezone.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-4])
    print("NEW_POST_DATE:", new_post.date)
    new_form = PostForm(request.POST, instance=new_post)
    if not new_form.is_valid():
        context = {'form': new_form}
    else:
        new_form.save()
        context['form'] = PostForm()

    context['posts'] = Post.objects.all().order_by('-date')
    context['comments'] = Comment.objects.all().order_by('comment_date_time')
    return render(request, 'socialnetwork/global_stream.html', context)
예제 #3
0
def post_action(request):
    errors = []
    context = {}
    form = PostForm(request.POST)
    if not form.is_valid():
        context['form'] = form
    # if request.method =='GET':
    #     form = PostForm()
    #     context['forms'] = form

    #     return render(request,"socialnetwork/globalstream.html",context)
    # elif 'post' not in request.POST or not request.POST['post']:
    #     errors.append("You must enter an item to post.")
    else:

        new_post = Post(post_text=form.cleaned_data['post_text'],
                        user=request.user,
                        time=timezone.now())
        form = PostForm(request.POST, instance=new_post)
        form.save()
    context['forms'] = PostForm()
    # context['errors'] = errors
    posts = Post.objects.all().order_by('-time', 'id')
    context['posts'] = posts

    return render(request, "socialnetwork/globalstream.html", context)
예제 #4
0
def create_post(request):
    post = Post(user=request.user)
    postForm = PostForm(request.POST, instance=post)
    if not postForm.is_valid():
        context = {'form': postForm}
        return render(request, 'socialnetwork/global.html', context)

    post.post_text = postForm.cleaned_data['post_input_text']
    post.post_date_time = timezone.now()

    post.post_profile = Profile(user=request.user)
    postForm.save()
    context = {
        'form': PostForm(),
        'posts': reversed(Post.objects.all().order_by('post_date_time'))
    }
    return render(request, 'socialnetwork/global.html', context)
예제 #5
0
def post_action(request):

    errors =[]
    context = {}

    if request.method == 'GET':
        forms = PostForm()
        posts = Post.objects.all().order_by('-time', 'id')
        comments = Comment.objects.all().order_by('post_id', '-time')
        context = {'posts':posts,'comments':comments,"forms":forms}
        return render(request,"socialnetwork/globalstream.html",context)

    form = PostForm(request.POST)
    time_str = timezone.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
    if not form.is_valid():
        context['form'] = form
    # if request.method =='GET':
    #     form = PostForm()
    #     context['forms'] = form

    #     return render(request,"socialnetwork/globalstream.html",context)
    # elif 'post' not in request.POST or not request.POST['post']:
    #     errors.append("You must enter an item to post.")
    else:

        new_post = Post(post_text = form.cleaned_data['post_text'],
                        user = request.user,
                        time = time_str,
                        username = request.user.first_name+" "+request.user.last_name,
                        )
        new_post.save()
        context['last_time'] = new_post.time
    context['forms'] = PostForm()
    comments = Comment.objects.all().order_by('post_id', '-time')
    context['comments'] = comments
    context['errors'] = errors
    posts = Post.objects.all().order_by('-time', 'id')
    context['posts'] = posts


    return render(request,"socialnetwork/globalstream.html",context)
def post(request):
    context={}
    if request.method == 'GET':
        context['posts'] = Post.objects.all().order_by('-id')
        context['post_form'] = PostForm()
        return render(request, 'socialnetwork/stream.html',context)

    form = PostForm(request.POST)
    context['form']=form

    if not form.is_valid():
        context['posts'] = Post.objects.all().order_by('-id')
        return render(request, 'socialnetwork/stream.html',context) 

    new_post = Post(content=form.cleaned_data['content'], user=request.user)
    new_post.save()

    on_post(new_post)

    context['post_form'] = PostForm()
    context['posts'] = Post.objects.all().order_by('-id')
    return render(request, 'socialnetwork/stream.html', context)
예제 #7
0
def new_post(request):
    errors = []
    if not request.method == 'POST':
        errors.append('New Post should use POST method')
        globalpost = Post.objects.all().order_by('-post_time')
        context = {'errors':errors, 'globalpost': globalpost, 'form': PostForm()}
        return render(request, 'socialnetwork/globalstream.html', context)

    post = Post(post_by=request.user, post_time=timezone.now())
    create_post = PostForm(request.POST, instance=post)
    if not create_post.is_valid():
        errors.append('Post not valid')
        globalpost = Post.objects.all().order_by('-post_time')
        context = {'errors': errors, 'globalpost': globalpost, 'form': PostForm()}
        return render(request, 'socialnetwork/globalstream.html', context)

    create_post.save()
    # message = 'Post created'
    # Show by reverse-chronological order
    # globalpost = Post.objects.all().order_by('-post_time')
    # context = {'message': message, 'globalpost': globalpost, 'form': PostForm()}
    # return render(request, 'socialnetwork/globalstream.html', context)
    return redirect('globalstream')
예제 #8
0
def home(request):
    entries = Post.objects.order_by('-creation_time')
    comment_form = CommentForm()
    post_form = PostForm()
    if request.method == "POST":
        if request.POST.get("wall_post"):
            new_post = Post(user_profile=request.user.profile, creation_time=timezone.now())
            post_form = PostForm(request.POST, instance=new_post)
            if not post_form.is_valid():
                messages.error(request, "Your post has errors")
            else:
                post_form.save()
                messages.success(request, "Your post has been made")
                return redirect(reverse('home'))
        elif request.POST.get("comment"):
            comment_form = CommentForm(request.POST)
            if not comment_form.is_valid():
                messages.error(request, "Your comment has errors")
            else:
                messages.success(request, "Your comment has been made")
                return redirect(reverse('home'))
    context = {'entries': entries, 'form': comment_form, 'post_form': post_form}
    return render(request, 'socialnetwork/stream.html', context)
def handle_response(response, user, errorlogger):

	if 'data' in response:

		new_data = response['data']
		script = user.userprofile.script
		script.data = new_data
		script.save()


	if 'posts' in response:
		for post_info in response['posts']:
			if 'content' not in post_info:
				errorlogger.log_error("Error: Invalid post: "+json.dumps(post_info))
				break

			content = post_info['content']

			post_form = PostForm({'content':content})
			if not post_form.is_valid():
				errorlogger.log_error("Error: Invalid post: "+json.dumps(post_info))
				break

			new_post = Post(content=post_form.cleaned_data['content'], user=user)
			new_post.save()
	
	if 'comments' in response:
		for comment_info in response['comments']:
			if ('content' not in comment_info) or ('post_id' not in comment_info):
				errorlogger.log_error("Error: Invalid comment: "+json.dumps(comment_info))
				break

			post_id = comment_info['post_id']
			content = comment_info['content']
			comment_form = CommentForm({'post':post_id,'content':content})
			if not comment_form.is_valid():
				errorlogger.log_error("Error: Invalid comment: "+json.dumps(comment_info))
				break

			new_comment = Comment(content=comment_form.cleaned_data['content'],
									post=comment_form.cleaned_data['post'],
									user=user)
			new_comment.save()

	if 'follow' in response:
		for followee_username in response['follow']:
			follow_form = FollowForm({'username':followee_username})
			if not follow_form.is_valid():
				errorlogger.log_error("Error: Invalid followee: "+str(followee_username))
				break

			followee = User.objects.get(username=follow_form.cleaned_data['username'])
			user.userprofile.following.add(followee)

			user.userprofile.save()

	if 'unfollow' in response:
		for target in response['unfollow']:
			unfollow_form = UnfollowForm({'username':target})
			if not unfollow_form.is_valid():
				errorlogger.log_error("Error: Invalid unfollow target: "+str(target))
				break

			target_user = User.objects.get(username=unfollow_form.cleaned_data['username'])
			user.userprofile.following.remove(target_user)

			user.userprofile.save()

	if 'log' in response:
		for entry in response['log']:
			errorlogger.log_error(str(entry))