def post(self, request, *args, **kwargs):
"""Process the post request with a new Project form filled out."""
form = ProjectForm(request.POST)
if form.is_valid():
form.save(commit=True)
return HttpResponseRedirect('/projects/projects/')
return render(request, "project_create.html", {'form': form})
def new_project(request):
names = ['Create New Project', 'OnGoing Projects', 'Completed Projects']
links = [
reverse('new_project'),
reverse('projects'),
reverse('old_projects')
]
submenus = create_sub(names, links)
context = {'proj_selected': 'current'}
if len(request.POST) <= 0:
form = ProjectForm()
context.update({
'form': form,
'entity': 'Project',
'submenus': submenus
})
return render(request, "new.html", context)
else:
form = ProjectForm(request.POST)
if form.is_valid():
form.save(commit=True)
url = reverse('projects')
return HttpResponseRedirect("%s?success=2" % (url))
else:
context.update({
'title':
'Create New Project',
'form':
form,
'entity':
'Project',
'errors':
'Invalid Entry or required fields not filled'
})
return render(request, "new.html", context)
def post(self, request):
context_dict = {}
form = ProjectForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('/api/projects?registerSuccess=true')
return self.get(request)
def project_edit(request, pk):
form = ProjectForm(request.POST or None, instance=Project.get(pk))
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse("projects-list"))
return direct_to_template(request, "project_edit.html", extra_context={
"form": form,
"nav": {"selected": "projects",},
})
def project_add(request):
form = ProjectForm(request.POST or None)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse("projects-list"))
return direct_to_template(request, "project_add.html", extra_context={
"form": form,
"nav": {"selected": "projects",},
})
def update_view(request, id):
project_form = ProjectForm(request.POST or None,
instance=Project.objects.get(id=id))
if project_form.is_valid():
project_form.save()
return redirect('project_index')
else:
return HttpResponse(
"""your form is wrong, reload on <a href = "{{ url : 'project_index'}}">reload</a>"""
)
def project_edit(request, pk):
form = ProjectForm(request.POST or None,
instance=Project.objects.get(pk=pk))
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse("projects-list"))
return direct_to_template(request, "project_edit.html", extra_context={
"form": form,
"nav": {"selected": "projects",},
})
def view_project(request, project_id):
project = get_object_or_404(Project, pk=project_id,
course=request.course)
space_owner = in_course_or_404(project.author.username, request.course)
if not project.collaboration(request).permission_to('edit',request):
#LEGACY: try again for legacy projects
if not project.collaboration(request, sync_group=True).permission_to('edit',request):
return HttpResponseRedirect(project.get_absolute_url())
if request.method == "GET":
if request.META.get('HTTP_ACCEPT','').find('json') >=0:
return project_json(request, project)
return project_workspace(request, space_owner, project)
if request.method == "DELETE":
project.delete()
return HttpResponseRedirect(
reverse('your-records', args=[request.user.username]))
if request.method == "POST":
projectform = ProjectForm(request, instance=project,data=request.POST)
if projectform.is_valid():
if "Preview" == request.POST.get('submit',None):
#doesn't send project.author, and other non-exposed fields
mock_project = projectform.cleaned_data.copy()
mock_project['attribution_list'] = mock_project['participants']
mock_project['assignment'] = projectform.instance.assignment()
mock_project['id'] = project_id
return project_preview(request, space_owner, mock_project,
is_participant=True, preview_num=request.GET.get('preview',1))
#legacy and for optimizing queries
projectform.instance.submitted = (request.POST.get('publish',None) != 'PrivateEditorsAreOwners')
#this changes for version-tracking purposes
projectform.instance.author = request.user
projectform.save()
projectform.instance.collaboration(request, sync_group=True)
if request.META.get('HTTP_ACCEPT','').find('json') >=0:
v_num = projectform.instance.get_latest_version()
return HttpResponse(simplejson.dumps(
{'status':'success',
'revision':{
'id':v_num,
'url':reverse('project_version_preview',args=[project_id, v_num]),
'public_url':projectform.instance.public_url(),
}
}, indent=2),
mimetype='application/json')
redirect_to = '.'
return HttpResponseRedirect(redirect_to)
def new_project(request):
"""The view which lets users create a new project without having to make a
new session."""
form = ProjectForm(user=request.user)
if request.method == "POST":
form = ProjectForm(user=request.user, data=request.POST)
if form.is_valid():
form.save()
return redirect("/projects/{}/".format(form.instance.id))
return render(request, "new-project.html", {"form": form})
def edit_project(request, id):
project = Project.objects.get(pk=id)
if request.method == 'POST':
form = ProjectForm(request.POST, instance=project)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('project_index'))
else:
return render(request, 'projects/edit_project.html', {'form': form})
else:
form = ProjectForm(instance=project)
return render(request, 'projects/edit_project.html', {'form': form})
def edit_project(request, slug):
if request.method == 'POST':
project = get_object_or_404(Project, slug=slug)
form = ProjectForm(request.POST, instance=project)
if form.is_valid():
form.save()
return HttpResponseRedirect(project.get_absolute_url())
else:
project = get_object_or_404(Project, slug=slug)
form = ProjectForm(instance=project)
return render_to_response('projects/new_project.html', {'form': form}, context_instance=RequestContext(request))
def edit_project(request, id):
project = Project.objects.get(pk=id)
if request.method == 'POST':
form = ProjectForm(request.POST, instance=project)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('project_index'))
else:
return render(request, 'projects/edit_project.html', {'form': form})
else:
form = ProjectForm(instance=project)
return render(request, 'projects/edit_project.html', {'form': form})
def edit_project(request, slug):
if request.method == 'POST':
project = get_object_or_404(Project, slug=slug)
form = ProjectForm(request.POST, instance=project)
if form.is_valid():
form.save()
return HttpResponseRedirect(project.get_absolute_url())
else:
project = get_object_or_404(Project, slug=slug)
form = ProjectForm(instance=project)
return render_to_response('projects/new_project.html', {'form': form},
context_instance=RequestContext(request))
def edit_project(request, project):
"""The view which lets users edit a project."""
project = get_object_or_404(Project, id=project, user=request.user)
form = ProjectForm(user=request.user, instance=project)
if request.method == "POST":
form = ProjectForm(user=request.user,
data=request.POST,
instance=project)
if form.is_valid():
form.save()
return redirect("/projects/{}/".format(form.instance.id))
return render(request, "edit-project.html", {"form": form})
def add_project(request, category_id=None):
if request.method == 'POST':
form = ProjectForm(request.POST)
if form.is_valid():
form.save()
return redirect(show_categories)
category = Category.objects.get(
id=category_id) if category_id else Category.objects.all()[:1].get()
form = ProjectForm(initial={'category': category})
form.fields['category'].queryset = request.user.categories.all()
return render(request, 'add_project.html', {
'form': form,
'title': 'Add project'
})
def create_view(request):
blank_project_form = ProjectForm()
if request.method == 'POST':
upload = ProjectForm(request.POST, request.FILES)
if upload.is_valid():
upload.save()
return redirect('project_index')
else:
return HttpResponse(
"""your form is wrong, reload on <a href = "{{ url : 'project_index'}}">reload</a>"""
)
else:
return render(request, 'projects/create_project.html',
{'upload_form': blank_project_form})
def project_save(request, project_id):
project = get_object_or_404(Project, pk=project_id, course=request.course)
if not project.can_edit(request) or not request.method == "POST":
return HttpResponseRedirect(project.get_absolute_url())
# verify user is in course
in_course_or_404(project.author.username, request.course)
projectform = ProjectForm(request, instance=project, data=request.POST)
if projectform.is_valid():
# legacy and for optimizing queries
projectform.instance.submitted = \
request.POST.get('publish', None) != 'PrivateEditorsAreOwners'
# this changes for version-tracking purposes
projectform.instance.author = request.user
projectform.save()
projectform.instance.collaboration(request, sync_group=True)
if request.META.get('HTTP_ACCEPT', '').find('json') >= 0:
v_num = projectform.instance.get_latest_version()
return HttpResponse(simplejson.dumps({
'status': 'success',
'is_assignment': projectform.instance.is_assignment(request),
'title': projectform.instance.title,
'revision': {
'id': v_num,
'public_url': projectform.instance.public_url(),
'visibility': project.visibility_short(),
'due_date': project.get_due_date()
}
}, indent=2), mimetype='application/json')
else:
ctx = {'status': 'error', 'msg': ""}
for key, value in projectform.errors.items():
if key == '__all__':
ctx['msg'] = ctx['msg'] + value[0] + "\n"
else:
ctx['msg'] = \
'%s "%s" is not valid for the %s field.\n Please %s\n' % \
(ctx['msg'], projectform.data[key],
projectform.fields[key].label,
value[0].lower())
return HttpResponse(simplejson.dumps(ctx, indent=2),
mimetype='application/json')
def submit_project(request):
form = ProjectForm()
add_tier_formset = inlineformset_factory(Project, Tier, extra=0, exclude=[])
project = form.save(commit=False)
if request.method == 'POST':
form = ProjectForm(request.POST, request.FILES)
if 'add_tier' in request.POST:
copy = request.POST.copy()
copy['tier-TOTAL_FORMS'] = int(copy['tier-TOTAL_FORMS'])+ 1
new_tier = add_tier_formset(copy, prefix='tier', instance=project)
elif 'submit' in request.POST:
project = form.save(commit=False)
if form.is_valid():
user = request.user
project.user = user
project.video = request.FILES['video']
project.save()
subject = "Project Submission Notice"
message = "This is to inform you that your project '" + project.name + "' has been submitted for vetting."
project_owner = request.user.email
to_owner_email = EmailMessage(subject, message, [project_owner])
to_owner_email.send()
subject = "Project Submission Notice"
message = "This is to inform you that " + user.userprofile.first_name + " " + user.userprofile.last_name + " has submitted a project named " + project.name + " with you listed as an adviser."
project_adviser = project.adviser_email
to_adviser_email = EmailMessage(subject, message, [project_adviser])
to_adviser_email.send()
new_tier = add_tier_formset(request.POST, prefix='tier', instance=project)
if new_tier.is_valid():
new_tier.save()
return redirect(project)
else:
new_tier = add_tier_formset(prefix='tier',instance=project)
return render_to_response('add_project.html',
{'form': form, 'tier': new_tier},
context_instance=RequestContext(request))
def new_project(request):
if request.method == 'POST':
project = Project()
form = ProjectForm(request.POST, instance=project)
if form.is_valid():
form.save(commit=False)
project.user = request.user
project.admingroup = request.organization.admingroup
project.save()
form.save_m2m()
return HttpResponseRedirect(project.get_absolute_url())
else:
project = Project()
form = ProjectForm(instance=project)
return render_to_response('projects/new_project.html', {'form': form}, context_instance=RequestContext(request))
def project_edit(request, pk):
if request.user.account.demo:
raise Http404
project = get_object_or_404(Project, pk=pk)
project_manager = project.project_manager
if project.archived:
raise Http404
elif not (request.user.account.role == 'admin'
or request.user.account.role == 'project_manager'):
raise Http404
elif request.user.account.role == 'project_manager' and request.user.account != project_manager:
raise Http404
if request.method == 'POST':
form = ProjectForm(request.POST, instance=project)
if form.is_valid():
new_project_manager = form.save().project_manager
if not project_manager == new_project_manager:
Notification.objects.create(
title=f'Project Edited',
text=
f'You have been removed as project manager from "{project.title}"',
recipient=project_manager)
Notification.objects.create(
title=f'Project Edited',
text=
f'You have been appointed as project manager for "{project.title}"',
recipient=new_project_manager)
return redirect('project_detail_ticket_open', pk)
return render(request, 'projects/project_edit.html',
{'form': ProjectForm(instance=project)})
def post(self, request):
var = ''
form = ProjectForm(request.POST, request.FILES)
form2 = ProfileForm(request.POST, request.FILES)
projects = request.user.projects.all()
template_name = 'capturista/home.html'
if form.is_valid():
pro = form.save(commit=False)
pro.user = request.user
pro.save()
messages.success(request, "Proyecto guardado con éxito")
context = {'section': 'alta', 'num_projects': projects.count()}
else:
context = {
'section': 'alta',
'form': form,
'form2': form2,
'num_projects': projects.count()
}
return render(request, template_name, context)
if form2.is_valid():
perf = form2.save(commit=False)
perf.uid = pro.uid
perf.save()
return redirect('projects:detail', id=pro.id)
def post(self, request, *args, **kwargs):
project_form = ProjectForm(request.POST)
if project_form.is_valid():
project_form.save()
return super(AddProjectView, self).post(request, *args, **kwargs)
else:
# Redisplay the create project form.
return render(
request,
"projects/project_form.html",
{
"form": ProjectForm,
#'error_message': project_form.errors,
"error_message": "All the fields are required.",
},
)
def edit_project(request, project_id):
# if freelancer is not working on the project return forbidden
if Freelancer.objects.filter(email=request.user.email).exists() and \
Freelancer.objects.get(email=request.user.email).current_project != project_id:
return HttpResponseForbidden()
# if user is not owner of the project return forbidden
elif not Freelancer.objects.filter(email=request.user.email).exists() and \
Appointment.objects.get(email=request.user.email).project_number != project_id:
return HttpResponseForbidden()
project_i = get_object_or_404(Project, project_number=project_id)
if request.method == 'POST':
form = ProjectForm(request.POST, instance=project_i)
if form.is_valid():
form = form.save()
messages.success(request, f'Details updated successfully!{form} ')
return redirect(reverse('freelancer'))
else:
messages.error(
request, 'There is something wrong with your form '
' Please check your input! ')
return render(request, 'freelancers/dashboard.html',
{'form': form})
def edit_project(request, project_id):
project = Project.objects.get(pk=project_id)
if request.method == 'POST':
form = ProjectForm(request.POST, instance=project)
if form.is_valid():
print(">>>>>>>>>>>>>>>>>>", form.cleaned_data)
project = form.save(commit=False)
project.save()
members_queryset = form.cleaned_data.get("members")
# ProjectMembers.objects.filter(project=project).delete()
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>", members_queryset.all().values_list('id', flat=True))
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>", Membership.objects.filter(project=project))
for id in Membership.objects.select_related().filter(project=project).values_list('user__id', flat=True):
if id not in members_queryset.all().values_list('id', flat=True):
Membership.objects.filter(project=project, user__id=id).delete()
for member in members_queryset.all():
if not Membership.objects.filter(project=project, user=member).exists():
Membership.objects.create(user=member, project=project)
return render(request, 'projects/includes/_project-card.html', {
'project': project,
})
else:
data = form.errors.as_json()
return JsonResponse(data, safe=False, status=400)
def submit_project(request):
form = ProjectForm(request.POST or None)
if form.is_valid():
project = form.save(commit=False)
project.user = request.user
project.save()
subject = "Project Submission Notice"
message = "This is to inform you that your project '" + project.name + "' has been submitted for vetting."
project_owner = request.user.email
to_owner_email = EmailMessage(subject, message, [project_owner])
to_owner_email.send()
subject = "Project Submission Notice"
message = "This is to inform you that " + request.user.userprofile.first_name + " " + request.userprofile.last_name " has submitted a project named " + project.name + " with you listed as an adviser."
project_adviser = project.adviser_email
to_adviser_email = EmailMessage(subject, message, [project_adviser])
to_adviser_email.send()
return redirect(project)
return render_to_response('add_project.html',
{'form': form},
context_instance=RequestContext(request))
def projectsubmit(request):
if request.method == 'POST':
form = ProjectForm(request.POST)
if form.is_valid():
pd = form.save(commit=False)
pd.sub_date = timezone.now()
pd.approved = False
# format the authors list
al = pd.authors.strip().replace('\r\n', '*').replace('\r', '*').replace('\n', '*').split('*')
print al
if len(al) > 1:
al[-1] = 'and ' + al[-1].strip()
if len(al) > 2:
pd.authors = ', '.join(al)
else:
pd.authors = ' '.join(al)
# make the thumbnail url a direct link if not already
if pd.thumbnail_url:
thumb = pd.thumbnail_url.strip()
if 'imgur' in thumb and 'i.' not in thumb:
pd.thumbnail_url = 'i.' + thumb.replace('https://', '').replace('http://', '')
if '.jpg' not in pd.thumbnail_url:
pd.thumbnail_url += '.jpg'
pd.save()
return render(request, 'projects/projectsubmit.html', {'submitted': True})
else:
form = ProjectForm()
return render(request, 'projects/projectsubmit.html', {'form': form, 'submitted': False})
def manage_group(request):
SecondaryObjectiveFormSet = inlineformset_factory(Project, SecondaryObjective, form=SecondaryObjectiveForm,
extra=3, can_delete=False)
if request.method == 'POST':
project_form = ProjectForm(request.POST)
objective_formset = SecondaryObjectiveFormSet(request.POST)
# objective_form = SecondaryObjectiveForm(request.POST)
if project_form.is_valid() and objective_formset.is_valid():
project = project_form.save(commit=False)
objective = objective_formset.save(commit=False)
print("is valid >>>>>>>", objective)
project.created_by = request.user
project.save()
for obj in objective:
obj.project = project
obj.save()
print("is valid >>>>>>>", obj.objective)
return redirect("portal:home")
else:
data = project_form.errors.as_json()
print("form is not valid", data)
return JsonResponse(data, safe=False, status=400)
else:
project_form = ProjectForm()
objective_formset = SecondaryObjectiveFormSet()
return render(request, 'projects/group-management.html', {
"projects": Project.objects.all(),
"project_form": project_form,
"objective_formset": objective_formset,
})
def createProject(request):
if request.user.is_authenticated:
if request.method == 'POST':
form = ProjectForm(request.POST)
if form.is_valid():
project_form = form.save(commit=False)
project_form.save()
form.save_m2m()
for _img in request.FILES.getlist('project_images[]'):
FileSystemStorage(location='/images')
photo = Images(project=project_form, path=_img)
photo.save()
for tag in request.POST["project_tags"].split(","):
tag = tag.strip()
Tags(project=project_form, tag_name=tag).save()
# user profile page
return redirect("project_details", project_form.id)
else:
return render(request, 'projects/create_project.html/',
{'project_form': form})
else:
project_form = ProjectForm(initial={"user": request.user})
return render(request, 'projects/create_project.html/',
{'project_form': project_form})
else:
return redirect('login')
def create(request):
if request.method == 'POST':
form = ProjectForm(request.POST)
if form.is_valid():
project = form.save(commit=False)
# On vérifie que le slug n'existe pas en bdd
i = 0
found = False
while not found:
if i > 0:
slug = slugify(form.cleaned_data['title']) + '-' + str(i)
else:
slug = slugify(form.cleaned_data['title'])
if Project.objects.filter(slug__iexact=slug).count() == 0:
project.slug = slug
found = True
i += 1
project.save()
project.author.add(request.user.id)
return redirect('projects_view', slug=slug)
else:
form = ProjectForm()
return render(request, 'projects/edit.html', {'form': form})
def edit_project(request):
c = get_common_context(request)
user = request.user
profile = user.get_profile()
proj = Participant.get_project(user)
c['slug'] = proj.slug
if request.method == 'GET':
c['form'] = ProjectForm(instance=proj)
else:
form = ProjectForm(request.POST, request.FILES, instance=proj)
if form.is_valid():
form.save()
return HttpResponseRedirect('/project/%s/' % Participant.get_project(user))
else:
pass
c['form'] = form
return render_to_response('edit_project.html', c, context_instance=RequestContext(request))
def new_project(request):
if request.method == 'POST':
project = Project()
form = ProjectForm(request.POST, instance=project)
if form.is_valid():
form.save(commit=False)
project.user = request.user
project.admingroup = request.organization.admingroup
project.save()
form.save_m2m()
return HttpResponseRedirect(project.get_absolute_url())
else:
project = Project()
form = ProjectForm(instance=project)
return render_to_response('projects/new_project.html', {'form': form},
context_instance=RequestContext(request))
def add_project(request):
"""
view to display the form to add a new project
"""
#make sure form was submitted via post
if request.method == "POST":
form = ProjectForm(request.POST)
if form.is_valid():
form.instance.user_id = request.user.id
form.save()
#redirect to home after successful save
return HttpResponseRedirect('/')
else:
context = {'form': form}
return render_to_response('add_project.html', context, context_instance=RequestContext(request))
else:
return render_to_response('add_project.html', {'form': ProjectForm()}, context_instance=RequestContext(request))
def post(self, request, *args, **kwargs):
try:
# Explicitly setting the request.post to be mutable so that we can add additional values to it.
#once done, reset the mutable property. dont need to do this if a form is a multi-part form.
mutable = request.POST._mutable
request.POST._mutable = True
#Set added by updated by user on form post data
self.set_added_by_update_by_users_on_view(request, GlobalConstants.ADD_ACTION)
request.POST._mutable = mutable
projectform = ProjectForm(request.POST)
project_members_response = {}
project_members_list = [project_member for project_member in request.POST.getlist('project_members') if
project_member != ""]
project_members_values_list = [int(project_member_value) for project_member_value in
request.POST.getlist('project_members_value') if project_member_value != ""]
if projectform.is_valid():
#First check if the project resources has no freely typed internal user name
if len(project_members_list) != len(project_members_values_list):
if project_members_values_list:
actual_project_members = InternalResource.objects.filter(id__in=project_members_values_list)
for member in project_members_list:
if member not in actual_project_members:
project_members_response[str(project_members_list[member])] = str(
project_members_list[member] + " is not a valid Internal Resource")
# else:
# project_members_response[member]
else:
project_members_response[str(project_members_list[0])] = str(
project_members_list[0] + " is not a valid Internal Resource")
context = self.get_context_data()
context['project_members_response'] = project_members_response
context['form'] = projectform
return self.render_to_response(context)
else:
self.object = projectform.save()
super(AddProject, self).form_valid(projectform)
for member in project_members_values_list:
member = InternalResource.objects.get(id=int(member))
project_resource = ProjectResources(project_id=self.object, resource_id=member,
addedBy=request.user,
updatedBy=request.user,
is_active=True)
project_resource.save()
return HttpResponseRedirect(self.get_success_url())
else:
actual_project_members = InternalResource.objects.filter(id__in=project_members_values_list)
for member in project_members_list:
if member not in actual_project_members:
project_members_response[member] = ["0", member + "-"]
else:
project_members_response[member] = [actual_project_members[member].id, ""]
return self.form_invalid(form=projectform, project_members_response=project_members_response)
except Exception as e:
logger.error("Exception while adding Project: " + str(e))
def add_project(request):
architects = Architect.objects.values('architect__username', 'id')
owners = Owner.objects.values('first_name', 'last_name', 'id')
if request.method == 'POST':
form = ProjectForm(request.POST)
if form.is_valid():
form.save()
return redirect('list_projects')
else:
form = ProjectForm()
return render(
request, 'projects/add_project.html', {
'form': form,
'architects': architects,
'owners': owners,
'types': Project.BUILDING_TYPES
})
def new_project(request):
names= ['Create New Project','OnGoing Projects','Completed Projects']
links = [reverse('new_project'),reverse('projects'),reverse('old_projects')]
submenus = create_sub(names,links)
context = {'proj_selected':'current'}
if len(request.POST) <= 0:
form = ProjectForm()
context.update({'form':form,'entity':'Project','submenus':submenus})
return render(request , "new.html", context)
else :
form = ProjectForm(request.POST)
if form.is_valid() :
form.save(commit=True)
url = reverse('projects')
return HttpResponseRedirect("%s?success=2"%(url))
else :
context.update({'title':'Create New Project','form': form,'entity':'Project','errors':'Invalid Entry or required fields not filled'})
return render(request, "new.html", context )
def post(self, request):
form = ProjectForm(request.POST)
if form.is_valid():
project = form.save()
messages.success(request, 'Project \'' + project.name + '\' was successfully created.')
return redirect('/projects')
else:
messages.error(request, 'Sorry, but there was a problem with the information you supplied.')
return render_create(request, form)
def new_project(request):
if request.method == "POST":
form = ProjectForm(request.POST or None)
if form.is_valid():
if form.save():
return redirect("/projects")
else:
form = ProjectForm()
data = {"form": form}
return render(request, "projects/new_project.html", data)
def submit_project(request):
form = ProjectForm(request.POST or None)
if form.is_valid():
project = form.save(commit=False)
project.user = request.user
project.save()
return redirect(project)
return render_to_response('add_project.html',
{'form': form},
context_instance=RequestContext(request))
def add_project(request):
"""
View to add a project.
"""
form=ProjectForm(request.POST or None)
if form.is_valid():
project=form.save(commit=False)
project.save()
return redirect(project)
return render_to_response('projects/project_form.html', {'form': form}, context_instance=RequestContext(request))
def create_project(request):
if request.method == 'POST':
form = ProjectForm(request.POST)
if form.is_valid():
project = form.save()
return redirect('projects:project', project.id)
else:
form = ProjectForm()
return render(request, 'projects/edit_project.html', {
'form': form,
})
def edit_project(request, project_id):
project = Project.objects.get(id=project_id)
if request.method == "POST":
form = ProjectForm(request.POST, instance=project)
if form.is_valid():
if form.save():
return redirect("/projects/{}".format(project_id))
else:
form = ProjectForm(instance=project)
data = {"project": project, "form": form}
return render(request, "projects/edit_project.html", data)
def project_create(request):
if request.method == 'POST' and request.is_ajax():
form = ProjectForm(request.POST, request.FILES)
if form.is_valid():
project = form.save(commit=False)
project.owner = request.user
project.save()
return HttpResponse(status=201)
else:
return render(request, 'projects/includes/_project_form.html', {'form': form})
return HttpResponse(status=201)
def add_project(request):
"""
view to display the form to add a new project
"""
#make sure form was submitted via post
if request.method == "POST":
form = ProjectForm(request.POST)
if form.is_valid():
form.instance.user_id = request.user.id
form.save()
#redirect to home after successful save
return HttpResponseRedirect('/')
else:
context = {'form': form}
return render_to_response('add_project.html',
context,
context_instance=RequestContext(request))
else:
return render_to_response('add_project.html', {'form': ProjectForm()},
context_instance=RequestContext(request))
def test_form_valid(self):
user = UserFactory()
form = ProjectForm(data={'name': 'Hello World!'})
self.assertTrue(form.is_valid())
project = form.save(commit=False)
project.owner = user
project.save()
self.assertEqual(project.name, 'Hello World!')
self.assertEqual(project.owner, user)
self.assertIsNotNone(project.created)
self.assertIsNotNone(project.modified)
def view_project(request, project_id):
project = get_object_or_404(Project, pk=project_id,
course=request.course)
space_owner = in_course_or_404(project.author.username, request.course)
if project not in Project.get_user_projects(space_owner,request.course):
return HttpResponseForbidden("forbidden")
if request.META['HTTP_ACCEPT'].find('json') >=0:
return project_json(request, project)
if request.method == "DELETE":
project.delete()
return HttpResponseRedirect(
reverse('your-space-records', args=[request.user.username]))
if not project.is_participant(request.user):
return project_readonly_view(request, project.id)
#ok, now we know is_participant
if request.method == "GET":
return project_workspace(request, space_owner, project)
if request.method == "POST":
projectform = ProjectForm(request, instance=project,data=request.POST)
redirect_to = '.'
if projectform.is_valid():
if "Submit"== request.POST.get('submit',None):
projectform.instance.submitted = True
redirect_to = reverse('your-space-records', args=[request.user.username])
redirect_to += "?show=%d" % project.pk
#this changes for version-tracking purposes
projectform.instance.author = request.user
projectform.save()
if "Preview" == request.POST.get('submit',None):
return project_preview(request, space_owner, project)
return HttpResponseRedirect(redirect_to)
def project_save(request, project_id):
project = get_object_or_404(Project, pk=project_id, course=request.course)
if not project.can_edit(request) or not request.method == "POST":
return HttpResponseRedirect(project.get_absolute_url())
space_owner = in_course_or_404(project.author.username, request.course)
if request.method == "POST":
projectform = ProjectForm(request, instance=project, data=request.POST)
if projectform.is_valid():
# legacy and for optimizing queries
projectform.instance.submitted = request.POST.get("publish", None) != "PrivateEditorsAreOwners"
# this changes for version-tracking purposes
projectform.instance.author = request.user
projectform.save()
projectform.instance.collaboration(request, sync_group=True)
if request.META.get("HTTP_ACCEPT", "").find("json") >= 0:
v_num = projectform.instance.get_latest_version()
return HttpResponse(
simplejson.dumps(
{
"status": "success",
"is_assignment": projectform.instance.is_assignment(request),
"revision": {
"id": v_num,
"public_url": projectform.instance.public_url(),
"visibility": project.visibility_short(),
},
},
indent=2,
),
mimetype="application/json",
)
redirect_to = "."
return HttpResponseRedirect(redirect_to)
def post(self, request, project_id):
project = Project.objects.get(pk = project_id)
form = ProjectForm(request.POST, instance = project)
if form.is_valid():
project = form.save()
messages.success(request, 'Project \'' + project.name + '\' was successfully updated.')
return redirect('/projects/update/' + project_id)
else:
messages.error(request, 'Sorry, but there was a problem with the information you supplied.')
return render_update(request, form, project_id)
def prj_create(request):
if request.method == 'POST':
form = ProjectForm(request.POST, request.FILES)
if form.is_valid():
prj = form.save(user=request.user)
return HttpResponseRedirect(prj.get_absolute_url())
else:
form = ProjectForm()
var = RequestContext(request, {'form': form})
return render_to_response('projects/prj_create.html', var)
def project_create(request):
if request.method == 'POST':
form = ProjectForm(request.POST)
if form.is_valid():
project = form.save(commit=False)
project.create_by = request.user
project.update_by = request.user
project.save()
return redirect(reverse("project_setting"))
else:
form = ProjectForm()
return render(request, 'projects/project_edit.html', locals())
def prj_create(request):
if request.method == 'POST':
form = ProjectForm(request.POST, request.FILES)
if form.is_valid():
prj = form.save(user=request.user)
return HttpResponseRedirect(prj.get_absolute_url())
else:
form = ProjectForm()
var = RequestContext(request, {'form': form})
return render_to_response('projects/prj_create.html', var)
def edit_project(request, project_id):
try:
project_id = Project.objects.get(id=project_id)
except User.DoesNotExist:
raise Http404
if request.method == 'POST':
form = ProjectForm(request.POST, instance=project_id)
if form.is_valid():
project_id = form.save()
return HttpResponseRedirect('/profile/')
else:
form = ProjectForm(instance=project_id)
return render_to_response('update_project.html', {'form': form}, context_instance=RequestContext(request))
def project_save(request, project_id):
project = get_object_or_404(Project, pk=project_id, course=request.course)
if not project.can_edit(request) or not request.method == "POST":
return HttpResponseRedirect(project.get_absolute_url())
# verify user is in course
in_course_or_404(project.author.username, request.course)
if request.method == "POST":
projectform = ProjectForm(request, instance=project, data=request.POST)
if projectform.is_valid():
# legacy and for optimizing queries
projectform.instance.submitted = \
request.POST.get('publish', None) != 'PrivateEditorsAreOwners'
# this changes for version-tracking purposes
projectform.instance.author = request.user
projectform.save()
projectform.instance.collaboration(request, sync_group=True)
if request.META.get('HTTP_ACCEPT', '').find('json') >= 0:
v_num = projectform.instance.get_latest_version()
return HttpResponse(simplejson.dumps({
'status': 'success',
'is_assignment':
projectform.instance.is_assignment(request),
'revision': {
'id': v_num,
'public_url': projectform.instance.public_url(),
'visibility': project.visibility_short(),
'due_date': project.get_due_date()
}
}, indent=2), mimetype='application/json')
redirect_to = '.'
return HttpResponseRedirect(redirect_to)
def edit_project(request, project=project):
project = get_object_or_404(Project, id=project)
if request.method == 'POST':
form = ProjectForm(request.POST, instance=project)
if form.is_valid():
project = form.save()
return redirect('projects:project', project.id)
else:
form = ProjectForm(instance=project)
return render(request, 'projects/edit_project.html', {
'form': form,
'project': project,
})
def edit(request, id):
try:
id = int(id)
if id > 0:
project = Project.objects.get(id=id)
if not request.user.has_perm('projects.change_project'):
return HttpResponseForbidden()
else:
if not request.user.has_perm('projects.add_project'):
return HttpResponseForbidden()
project = False
if request.POST:
if project:
form = ProjectForm(request.POST, instance=project)
else:
form = ProjectForm(request.POST)
if form.is_valid():
form.save()
return redirect('project-list')
else:
if project:
form = ProjectForm(instance=project)
else:
form = ProjectForm()
except:
project = False
form = False
c = RequestContext(request, {
'project': project,
'form': form,
'id': id,
})
return render_to_response("projects/edit.html", c)
def edit(request, slug):
if not request.user.is_superuser:
project = get_object_or_404(Project, slug__iexact=slug, author=request.user)
else:
project = get_object_or_404(Project, slug__iexact=slug)
if request.method == 'POST':
form = ProjectForm(request.POST or None, instance=project)
if form.is_valid():
form.save()
# Si il n'y a plus d'auteurs dans le formulaire on ne met pas à jour
authors_form = request.POST.getlist('authors')
if len(authors_form) > 0:
authors_project = []
for author in project.author.all():
authors_project.append(author.username)
toAdd = listDiff(authors_form, authors_project)
toRemove = listDiff(authors_project, authors_form)
# On ajoute les auteurs manquants
for item in toAdd:
user = User.objects.filter(username=item)[0]
if user:
project.author.add(user.id)
# On supprime les autres auteurs
for item in toRemove:
user = User.objects.filter(username=item)[0]
if user:
project.author.remove(user.id)
return redirect('projects_view', slug=slug)
else:
form = ProjectForm(instance=project)
return render(request, 'projects/edit.html', {'form': form, 'project': project})
def add_project(request):
if request.method == 'POST':
form = ProjectForm(request.POST)
if form.is_valid():
form.instance.token = str(uuid4())
instance = form.save()
instance.user.add(request.user)
return HttpResponseRedirect('/panel/projects/%d' % form.instance.id)
else:
form = ProjectForm()
return TemplateResponse(request, 'panel/project_form.html', {'form': form})
def edit_project(request, project_id):
try:
project_id = Project.objects.get(id=project_id)
except User.DoesNotExist:
raise Http404
if request.method == 'POST':
form = ProjectForm(request.POST, instance=project_id)
if form.is_valid():
project_id = form.save()
return HttpResponseRedirect('/profile/')
else:
form = ProjectForm(instance=project_id)
return render_to_response('update_project.html', {'form': form},
context_instance=RequestContext(request))
def create_project(request):
if request.method == 'POST':
project_form = ProjectForm(request.POST)
if project_form.is_valid():
project = project_form.save()
return HttpResponseRedirect(reverse('project_join', args=[project.id]))
else:
return render(request, 'projects/create_project.html',
{'project_form': project_form})
else:
project_form = ProjectForm(initial={'widgets': {'owner': forms.HiddenInput},
'owner': request.user})
return render(request, 'projects/create_project.html',
{'project_form': project_form})
def add_project(request):
if request.method == 'POST':
form = ProjectForm(request.POST)
if form.is_valid():
form.instance.token = str(uuid4())
instance = form.save()
instance.user.add(request.user)
return HttpResponseRedirect('/panel/projects/%d' %
form.instance.id)
else:
form = ProjectForm()
return TemplateResponse(request, 'panel/project_form.html', {'form': form})
def new_project(request):
from django.contrib.sites.shortcuts import get_current_site
current_site = get_current_site(request)
if request.method == 'POST':
form = ProjectForm(request.POST)
if form.is_valid():
project = form.save(commit=False)
project.user = request.user.profile
category = get_object_or_404(ProjectCategory, id=request.POST.get('category_id'))
project.category = category
tags = request.POST.get('tags').split(",")
for tag in tags:
category.tags.add(tag.replace(" ", ""))
project.save()
# Without this next line the tags won't be saved
form.save_m2m()
people = Profile.objects.filter(categories__id=project.category.id)
from django.core import mail
for person in people:
if person.user.email:
try:
with mail.get_connection() as connection:
mail.EmailMessage(
"New Project: " + project.title , "A new project you might be interested in was created and can be viwed at " + current_site.domain + '/projects/' + str(project.id), "Agreelancer", [person.user.email],
connection=connection,
).send()
except Exception as e:
from django.contrib import messages
messages.success(request, 'Sending of email to ' + person.user.email + " failed: " + str(e))
task_title = request.POST.getlist('task_title')
task_description = request.POST.getlist('task_description')
task_budget = request.POST.getlist('task_budget')
for i in range(0, len(task_title)):
Task.objects.create(
title = task_title[i],
description = task_description[i],
budget = task_budget[i],
project = project,
)
return redirect('project_view', project_id=project.id)
else:
form = ProjectForm()
return render(request, 'projects/new_project.html', {'form': form})
