def project(request, slug, template_name="projects/project.html"):
project = get_object_or_404(Project, slug=slug)
if project.deleted:
raise Http404
photos = project.photos.all()
if request.user.is_authenticated() and request.method == "POST" and request.user == project.creator:
if request.POST["action"] == "update":
user_file_form = UserFileForm(Account.objects.get(user = request.user))
adduser_form = AddUserForm(project=project)
project_form = ProjectUpdateForm(request.POST, instance=project)
file_form = UploadFileForm()
if project_form.is_valid():
project = project_form.save()
elif request.POST["action"] == "add":
user_file_form = UserFileForm(Account.objects.get(user = request.user))
project_form = ProjectUpdateForm(instance=project)
adduser_form = AddUserForm(project, request.POST)
file_form = UploadFileForm()
if adduser_form.is_valid():
adduser_form.save(project, request.user)
adduser_form = AddUserForm(project=project) # @@@ is this the right way to clear it?
elif request.POST["action"] == "upload":
user_file_form = UserFileForm(Account.objects.get(user = request.user))
adduser_form = AddUserForm(project=project)
project_form = ProjectUpdateForm(instance=project)
file_form = UploadFileForm(request.POST, request.FILES)
if file_form.is_valid():
uFile = handle_uploaded_file(request.FILES['file'], request.user)
project.files.add(uFile)
project.save()
request.user.message_set.create(message="uploaded %(file)s"%{'file':request.FILES['file'].name})
elif request.POST["action"] == "remove":
user_file_form = UserFileForm(Account.objects.get(user = request.user))
adduser_form = AddUserForm(project=project)
project_form = ProjectUpdateForm(instance=project)
file_form = UploadFileForm()
fname = request.POST['file']
remove_uploaded_file(fname, project)
request.user.message_set.create(message="removed %(file)s from project"%{'file':fname})
elif request.POST["action"] == "userfile":
adduser_form = AddUserForm(project=project)
project_form = ProjectUpdateForm(instance=project)
file_form = UploadFileForm()
user_file_form = UserFileForm(Account.objects.get(user = request.user))
#if user_file_form.is_valid():
acc = Account.objects.get(user = request.user)
uFile = acc.files.get(name = request.POST['files'])
project.files.add(uFile)
project.save()
request.user.message_set.create(message="added %(file)s to project"%{'file':uFile.name})
else:
user_file_form = UserFileForm(Account.objects.get(user = request.user))
file_form = UploadFileForm()
project_form = ProjectUpdateForm(instance=project)
adduser_form = AddUserForm(project=project)
elif request.user.is_authenticated() and request.user == project.creator:
user_file_form = UserFileForm(Account.objects.get(user = request.user))
file_form = UploadFileForm()
adduser_form = AddUserForm(project=project)
project_form = ProjectUpdateForm(instance=project)
else:
user_file_form = UserFileForm(None)
file_form = UploadFileForm()
adduser_form = AddUserForm(project=project)
project_form = ProjectUpdateForm(instance=project)
topics = project.topics.all()[:5]
articles = Article.objects.filter(
content_type=get_ct(project),
object_id=project.id).order_by('-last_update')
total_articles = articles.count()
articles = articles[:5]
total_tasks = project.tasks.count()
tasks = project.tasks.order_by("-modified")[:10]
# tweets = TweetInstance.objects.tweets_for(project).order_by("-sent")
are_member = project.has_member(request.user)
return render_to_response(template_name, {
"project_form": project_form,
"adduser_form": adduser_form,
"project": project,
"photos": photos,
"topics": topics,
"articles": articles,
"total_tasks": total_tasks,
"tasks": tasks,
"total_articles": total_articles,
"are_member": are_member,
"file_form": file_form,
"user_file_form":user_file_form,
}, context_instance=RequestContext(request))
def profile(request, username, template_name="profiles/profile.html"):
other_user = get_object_or_404(User, username=username)
if request.user.is_authenticated():
is_friend = Friendship.objects.are_friends(request.user, other_user)
is_following = Following.objects.is_following(request.user, other_user)
other_friends = Friendship.objects.friends_for_user(other_user)
if request.user == other_user:
is_me = True
else:
is_me = False
else:
other_friends = []
is_friend = False
is_me = False
is_following = False
if request.user.is_authenticated() and request.method == "POST" and not is_me:
# @@@ some of this should go in zwitschern itself
if request.POST["action"] == "follow":
Following.objects.follow(request.user, other_user)
is_following = True
request.user.message_set.create(message=_("You are now following %(other_user)s") % {'other_user': other_user})
if notification:
notification.send([other_user], "tweet_follow", {"user": request.user})
elif request.POST["action"] == "unfollow":
Following.objects.unfollow(request.user, other_user)
is_following = False
request.user.message_set.create(message=_("You have stopped following %(other_user)s") % {'other_user': other_user})
if is_friend:
invite_form = None
previous_invitations_to = None
previous_invitations_from = None
else:
if request.user.is_authenticated() and request.method == "POST":
if request.POST["action"] == "delete":
file_form = UploadFileForm()
fname = request.POST['file']
delete_uploaded_file(fname, request.user)
invite_form = InviteFriendForm(request.user, {
'to_user': username,
'message': ugettext("Let's be friends!"),
})
request.user.message_set.create(message=_("You have deleted %(file)s") % {'file': fname})
elif request.POST["action"] == "upload":
invite_form = InviteFriendForm(request.user, {
'to_user': username,
'message': ugettext("Let's be friends!"),
})
file_form = UploadFileForm(request.POST, request.FILES)
if file_form.is_valid():
uFile = handle_uploaded_file(request.FILES['file'], request.user)
myAccount = Account.objects.get(user = request.user)
myAccount.files.add(uFile)
myAccount.save()
request.user.message_set.create(message="uploaded %(file)s"%{'file':request.FILES['file'].name})
elif request.POST["action"] == "invite":
file_form = UploadFileForm()
invite_form = InviteFriendForm(request.user, request.POST)
if invite_form.is_valid():
invite_form.save()
else:
file_form = UploadFileForm()
invite_form = InviteFriendForm(request.user, {
'to_user': username,
'message': ugettext("Let's be friends!"),
})
if request.POST["action"] == "accept": # @@@ perhaps the form should just post to friends and be redirected here
invitation_id = request.POST["invitation"]
try:
invitation = FriendshipInvitation.objects.get(id=invitation_id)
if invitation.to_user == request.user:
invitation.accept()
request.user.message_set.create(message=_("You have accepted the friendship request from %(from_user)s") % {'from_user': invitation.from_user})
is_friend = True
other_friends = Friendship.objects.friends_for_user(other_user)
except FriendshipInvitation.DoesNotExist:
pass
else:
file_form = UploadFileForm()
invite_form = InviteFriendForm(request.user, {
'to_user': username,
'message': ugettext("Let's be friends!"),
})
previous_invitations_to = FriendshipInvitation.objects.filter(to_user=other_user, from_user=request.user)
previous_invitations_from = FriendshipInvitation.objects.filter(to_user=request.user, from_user=other_user)
if is_me:
file_form = UploadFileForm()
myAccount = Account.objects.get(user = request.user)
file_list = myAccount.files.all()
if request.method == "POST":
if request.POST["action"] == "update":
profile_form = ProfileForm(request.POST, instance=other_user.get_profile())
if profile_form.is_valid():
profile = profile_form.save(commit=False)
profile.user = other_user
profile.save()
else:
profile_form = ProfileForm(instance=other_user.get_profile())
else:
profile_form = ProfileForm(instance=other_user.get_profile())
else:
file_form = None
file_list = None
profile_form = None
return render_to_response(template_name, {
"profile_form": profile_form,
"is_me": is_me,
"is_friend": is_friend,
"is_following": is_following,
"other_user": other_user,
"other_friends": other_friends,
"invite_form": invite_form,
"previous_invitations_to": previous_invitations_to,
"previous_invitations_from": previous_invitations_from,
"file_list":file_list,
"file_form":file_form
}, context_instance=RequestContext(request))
def task(request, id, template_name="projects/task.html"):
task = get_object_or_404(Task, id=id)
project = task.project
if project.deleted:
raise Http404
is_member = project.has_member(request.user)
if is_member and request.method == "POST":
if request.POST["action"] == "assign":
#dependency_form = TaskDependencyForm(project.tasks.all())
user_file_form = UserFileForm(Account.objects.get(user = request.user))
status_form = StatusForm(instance=task)
assign_form = AssignForm(project, request.POST, instance=task)
file_form = UploadFileForm()
if assign_form.is_valid():
task = assign_form.save()
request.user.message_set.create(message="assigned task to '%s'" % task.assignee)
if notification:
notification.send(project.member_users.all(), "projects_task_assignment", {"user": request.user, "task": task, "project": project, "assignee": task.assignee})
elif request.POST["action"] == "update_status":
#dependency_form = TaskDependencyForm(project.tasks.all())
user_file_form = UserFileForm(Account.objects.get(user = request.user))
assign_form = AssignForm(project, instance=task)
status_form = StatusForm(request.POST, instance=task)
file_form = UploadFileForm()
if status_form.is_valid():
task = status_form.save()
request.user.message_set.create(message="updated your status on the task")
if notification:
notification.send(project.member_users.all(), "projects_task_status", {"user": request.user, "task": task, "project": project})
elif request.POST["action"] == "upload":
#dependency_form = TaskDependencyForm(project.tasks.all())
user_file_form = UserFileForm(Account.objects.get(user = request.user))
assign_form = AssignForm(project, instance=task)
status_form = StatusForm(instance=task)
file_form = UploadFileForm(request.POST, request.FILES)
if file_form.is_valid():
uFile = handle_uploaded_file(request.FILES['file'], request.user)
task.files.add(uFile)
task.save()
request.user.message_set.create(message="uploaded %(file)s"%{'file':request.FILES['file'].name})
elif request.POST["action"] == "remove":
#dependency_form = TaskDependencyForm(project.tasks.all())
user_file_form = UserFileForm(Account.objects.get(user = request.user))
assign_form = AssignForm(project, instance=task)
status_form = StatusForm(instance=task)
file_form = UploadFileForm()
fname = request.POST['file']
remove_uploaded_file(fname, task)
request.user.message_set.create(message="removed %(file)s from task"%{'file':fname})
elif request.POST["action"] == "userfile":
#dependency_form = TaskDependencyForm(project.tasks.all())
assign_form = AssignForm(project, instance=task)
status_form = StatusForm(instance=task)
file_form = UploadFileForm()
user_file_form = UserFileForm(Account.objects.get(user = request.user))
#if user_file_form.is_valid():
acc = Account.objects.get(user = request.user)
uFile = acc.files.get(name = request.POST['files'])
task.files.add(uFile)
task.save()
request.user.message_set.create(message="added %(file)s to task"%{'file':uFile.name})
## elif request.POST["action"] == "dependency":
## dependency_form = TaskDependencyForm(project.tasks.all())
## assign_form = AssignForm(project, instance=task)
## status_form = StatusForm(instance=task)
## file_form = UploadFileForm()
## user_file_form = UserFileForm(Account.objects.get(user = request.user))
## #if user_file_form.is_valid():
## dependency = Task.objects.get(summary = request.POST['tasks'])
## task.dependencies.add(dependency)
## task.save()
## generate_graph(project, project.tasks.all())
## request.user.message_set.create(message="added %(task)s as dependency"%{'task':dependency.summary})
else:
if is_member:
user_file_form = UserFileForm(Account.objects.get(user = request.user))
#dependency_form = TaskDependencyForm(project.tasks.all())
else:
user_file_form = UserFileForm(None)
#dependency_form = TaskDependencyForm(None)
assign_form = AssignForm(project, instance=task)
status_form = StatusForm(instance=task)
file_form = UploadFileForm()
if request.POST["action"] == "mark_resolved" and request.user == task.assignee:
task.state = '2'
task.save()
request.user.message_set.create(message="task marked resolved")
if notification:
notification.send(project.member_users.all(), "projects_task_change", {"user": request.user, "task": task, "project": project, "new_state": "resolved"})
elif request.POST["action"] == "mark_closed" and request.user == task.creator:
task.state = '3'
task.save()
request.user.message_set.create(message="task marked closed")
if notification:
notification.send(project.member_users.all(), "projects_task_change", {"user": request.user, "task": task, "project": project, "new_state": "closed"})
elif request.POST["action"] == "reopen" and is_member:
task.state = '1'
task.save()
request.user.message_set.create(message="task reopened")
if notification:
notification.send(project.member_users.all(), "projects_task_change", {"user": request.user, "task": task, "project": project, "new_state": "reopened"})
else:
if is_member:
user_file_form = UserFileForm(Account.objects.get(user = request.user))
#dependency_form = TaskDependencyForm(project.tasks.all())
else:
user_file_form = UserFileForm(None)
#dependency_form = TaskDependencyForm(None)
assign_form = AssignForm(project, instance=task)
status_form = StatusForm(instance=task)
file_form = UploadFileForm()
return render_to_response(template_name, {
"task": task,
"is_member": is_member,
"assign_form": assign_form,
"status_form": status_form,
"file_form": file_form,
"user_file_form": user_file_form,
#"dependency_form":dependency_form,
}, context_instance=RequestContext(request))