def project_edit(request, project_id):
context = RequestContext(request)
project = get_object_or_404(Project, pk=project_id)
if not project.can_admin(request.user):
raise Http404()
if request.method == 'POST':
form = ProjectForm(request.POST, instance=project)
if form.is_valid():
project.set_change_user(request.user)
with transaction.atomic(), reversion.create_revision():
reversion.set_user(request.user)
form.save()
# перебросить пользователя на просмотр изделия
messages.success(request, "You successfully updated this project!")
return HttpResponseRedirect(project.get_absolute_url())
else:
print(form.errors)
else:
form = ProjectForm(instance=project)
return render(request, 'project/project_form.html', {
'form': form,
'project': project
}, context)
def update_project_details(request, **kwargs):
"""
update project details
"""
# set variables
pk = int(kwargs.get('pk'))
current_project = get_object_or_404(Project, pk=pk)
if request.method == "POST":
# populate the project form
project_form = ProjectForm(request.POST, instance=current_project)
# validate then save form
if project_form.is_valid():
project_form.save()
messages.success(
request, 'Success! Your project details have been updated.')
return redirect(reverse('projects:projectList'))
else:
messages.error(
request,
'An unexpected error occurred. Project details NOT saved.')
else:
project_form = ProjectForm(instance=current_project)
# add the requested project and form to the context
context = {
'project': current_project,
'project_form': project_form,
}
return render(request, 'project/project_update_details.html', context)
def edit_project(request, project_id):
project = get_object_or_404(Project, id=project_id, owner=request.user)
form = ProjectForm(request.POST or None, instance=project)
if form.is_valid():
form.save()
return redirect(project.ide_url())
return render_to_response("projects/edit_project_form.html",
RequestContext(request, {'form': form}))
def new_project(request):
project_form = ProjectForm()
if request.method == 'POST':
project_form = ProjectForm(request.POST)
if project_form.is_valid():
project_form.save()
return redirect('projects')
context = {'project_form': project_form}
return render(request, 'new_project.html', context)
def post(self, request, *args, **kwargs):
project = Project(author=request.user)
id = kwargs.get('id')
if id:
project = Project.objects.get(id=id)
form_data = ProjectForm(request.POST, instance=project)
if form_data.is_valid():
form_data.save()
response = {'success': 'true'}
else:
response = {'success': 'false'}
return HttpResponse(json.dumps(response))
def update_project(request, pk):
""" Update a specific project. """
instance = Project.objects.get(id_project=pk)
form = ProjectForm(request.POST or None, instance=instance)
if request.method == 'POST':
if form.is_valid():
form.save()
return redirect('/projects')
else:
context = {
'form': form,
'update': True,
}
return render(request, 'project/project_form.html', context)
def backstage_content_form(request, project):
project = get_project(request, project, 'manage_content')
if request.POST:
form = ProjectForm(request.POST, instance=project)
if form.is_valid():
form.save()
message_object_updated(request, project)
else:
form = ProjectForm(instance=project)
return render(request, 'project/content-form.html',
get_context_backstage_project(request, project, 'bs-content',
{'project': project, 'form': form}))
def create_project(request):
nav_options = get_nav_options(request)
if request.method == 'POST':
user = request.user
form = ProjectForm(user=user, data=request.POST)
if form.is_valid():
project = form.save()
viewers_group = project.create_viewers_group()
collaborators_group = project.create_collaborators_group()
# set groups permissions
project.set_permissions(viewers_group)
project.set_permissions(collaborators_group)
return redirect('/project/%d' % project.ID)
else:
form = ProjectForm()
return render(request, 'project/create-project.html',
{'form': form,
'nav_options': nav_options})
def project_create_or_edit(request, id=None):
if id:
title = _('Edit a project')
project = get_object_or_404(Project, pk=id, owner=request.user)
else:
title = _('Add a project')
project = None
contacts = Contact.objects.filter(owner=request.user)
if request.method == 'POST':
projectForm = ProjectForm(request.POST, instance=project, prefix="project")
projectForm.fields['customer'].queryset = contacts
if projectForm.is_valid():
user = request.user
project = projectForm.save(commit=False)
project.save(user=user)
projectForm.save_m2m()
messages.success(request, _('The project has been saved successfully'))
return redirect(reverse('project_detail', kwargs={'id': project.id}))
else:
messages.error(request, _('Data provided are invalid'))
else:
projectForm = ProjectForm(instance=project, prefix="project")
projectForm.fields['customer'].queryset = contacts
return render_to_response('project/edit.html',
{'active': 'business',
'title': title,
'projectForm': projectForm},
context_instance=RequestContext(request))
def add_project(request):
"""
Add project for own team
:param request: Django Request
:return: Rendered HTML
"""
if not request.user.is_authenticated():
return redirect('/')
if not request.user.team:
return redirect('/')
project = request.user.team.project
if request.method == 'POST':
# handle post
form = ProjectForm(request.POST, instance=project)
if form.is_valid():
project = form.save(commit=True)
team = request.user.team
team.project = project
team.save()
return redirect('project-view', pk=project.pk)
form = ProjectForm(instance=project)
data = {
'form': form,
'user': request.user,
'error': None
}
return render(request, 'web/add_project.html', data)
def create_project(request):
""" Create new project. """
if request.method == 'POST':
form = ProjectForm(request.POST)
if form.is_valid():
project = form.save(commit=False)
form.save()
project.collaborators.add(request.user)
return redirect('/projects')
else:
form = ProjectForm()
context = {
'form': form,
'update': False,
}
return render(request, 'project/project_form.html',
context) # project_form
def update_project(request, **kwargs):
"""
update draft project
"""
# set variables
pk = int(kwargs.get('pk'))
current_project = get_object_or_404(Project, pk=pk)
#create the formset, specifying the form you want to repeat and the baseformset that holds the validation rules
if request.method == "POST":
# populate the project form and the formset
project_form = ProjectForm(request.POST, instance=current_project)
team_formset = ProjectTeamFormSet(request.POST,
instance=current_project,
prefix="team")
task_formset = TaskFormSet(request.POST,
instance=current_project,
prefix="task")
# validate then save each form in the formset
if project_form.is_valid() and team_formset.is_valid(
) and task_formset.is_valid():
team_formset.save()
task_formset.save()
project_form.save()
current_project.update_totals()
messages.success(
request, 'You have updated successfully updated your project.')
return redirect(reverse('projects:projectList'))
else:
messages.error(
request,
'An unexpected error occurred. Your project was NOT saved.')
else:
project_form = ProjectForm(instance=current_project)
team_formset = ProjectTeamFormSet(instance=current_project,
prefix="team")
task_formset = TaskFormSet(instance=current_project, prefix="task")
context = {
'project': current_project,
'project_form': project_form,
'team_formset': team_formset,
'task_formset': task_formset,
}
return render(request, 'project/project_update_form.html', context)
def project_add(request):
temp_name = "headers/project-header.html"
if request.method == "POST":
print "post"
project_form = ProjectForm(request.POST)
if project_form.is_valid():
project_form.save()
tips = u"增加成功！"
display_control = ""
else:
tips = u"增加失败！"
display_control = ""
return render(request, "project/project_add.html", locals())
else:
print "get"
display_control = "none"
project_form = ProjectForm()
return render(request, "project/project_add.html", locals())
def edit(request, project_id):
project = get_object_or_404(Project, pk=project_id)
if not project.is_admin(request.user):
return render_to_response('project/no_permission.html')
if request.method == "POST":
project_form = ProjectForm(request.POST, instance=project)
if project_form.is_valid():
project_form.save()
return HttpResponseRedirect('/projects/' + str(project_id) + '/')
else:
project_form = ProjectForm(instance=project)
return render_to_response('project/edit.html', {
'form': project_form,
'project': project
},
context_instance=RequestContext(request))
def post(self, request, *args, **kwargs):
form_data = ProjectForm(request.POST)
form_data.author = request.user
if form_data.is_valid():
form_data.save()
response = {'success': 'true'}
# project = Project.objects().create(title=form_data.title,summary=form_data.summary,
# description=form_data.description, author=request.user, goal=form_data.goal,
# period=form_data.period,video_url=form_data.video_url,
# risks_and_challenges=form_data.risks_and_challenges, ordering = 0,
# start_date=form_data.start_date, status=UNAPPROVED)
else:
response = {'success': 'false'}
print form_data.non_field_errors
for field in form_data:
print field.label
print field.errors
return HttpResponse(json.dumps(response))
def edit(request, project_id):
project = get_object_or_404(Project, pk=project_id)
if not project.is_admin(request.user):
return render_to_response('project/no_permission.html')
if request.method == "POST":
project_form = ProjectForm(request.POST, instance=project)
if project_form.is_valid():
project_form.save()
return HttpResponseRedirect('/projects/' + str(project_id) + '/')
else:
project_form = ProjectForm(instance=project)
return render_to_response('project/edit.html',
{ 'form' : project_form,
'project' : project
},
context_instance=RequestContext(request))
def project_create(request):
year = Year.objects.last()
today = datetime.date.today()
difference = year.date_closed - today
if request.method == 'POST':
form = ProjectForm(request.POST)
if form.is_valid():
project = form.save(commit=False)
project.budget_year = year
project.submittedBy = request.user
# form.post_project()
form.save()
return redirect('project:project_detail', pk=project.pk)
else:
form = ProjectForm()
context = {'difference': difference, 'form': form}
return render(request, 'project/project_form.html', context)
def add_project(request):
if request.POST:
form = ProjectForm(request.POST)
args = {}
args['name'] = request.POST.get('name')
if form.is_valid():
project = form.save(commit=False)
project.user = auth.get_user(request)
project.name = args['name']
project.save()
args['id'] = project.id
return render_to_response( 'project.html', args)
def add_project(request):
'''
Create a new project for the current user.
'''
if request.method == 'POST':
form = ProjectForm(request.POST)
if form.is_valid():
project = form.save(commit=False)
project.creator = request.user
project.save()
return render_to_response('account/my_account.html', RequestContext(request, locals()))
else:
form = ProjectForm()
return render_to_response('project/add_project.html', RequestContext(request, locals()))
def post(self, request, manager_id):
response = {'manager_id': manager_id}
response['clients'] = User.objects.filter(role="client",
createdby=manager_id)
form = ProjectForm(request.POST)
print form.errors
if form.is_valid():
f = form.save(commit=False)
f.createdby = manager_id
f.client_id = request.POST.get('client_id')
f.save()
return render(request, 'project/createproject.html')
else:
response['form'] = form
return render(request, 'project/createproject.html', response)
def create(request):
form = ProjectForm()
if request.method == "POST":
form = ProjectForm(request.POST)
if form.is_valid():
project = form.save(commit=False)
project.creator = request.user
project.save()
import md5
# project.token = md5.new(str(project.id + time.mktime(project.dateline.timetuple()))).hexdigest()
project.token = md5.new(str(project.id + 54321)).hexdigest()
project.participants.add(request.user)
project.save()
return HttpResponseRedirect(reverse('project_home', args=[project.id]))
return render(request, 'project/create.html', {'form': form})
def create(request):
form = ProjectForm()
if request.method == "POST":
form = ProjectForm(request.POST)
if form.is_valid():
project = form.save(commit=False)
project.creator = request.user
project.save()
import md5
# project.token = md5.new(str(project.id + time.mktime(project.dateline.timetuple()))).hexdigest()
project.token = md5.new(str(project.id + 54321)).hexdigest()
project.participants.add(request.user)
project.save()
return HttpResponseRedirect(
reverse('project_home', args=[project.id]))
return render(request, 'project/create.html', {'form': form})
def save_project(request,**kwargs):
if request.method == 'POST':
user=request.user
form = ProjectForm(request.POST, request.FILES)
print form.is_valid()
print form.errors
if form.is_valid():
project=form.save(commit=False)
project.user=user
link=project.video_link
video_code=re.findall(r'v\=([\-\w]+)', link )[0]
project.video_link="//www.youtube.com/v/"+str(video_code)
project.save()
messages.info(request,'Project has been successfully created')
return HttpResponseRedirect('/project')
else:
raise Http404
def save_project(request, **kwargs):
if request.method == 'POST':
user = request.user
form = ProjectForm(request.POST, request.FILES)
print form.is_valid()
print form.errors
if form.is_valid():
project = form.save(commit=False)
project.user = user
link = project.video_link
video_code = re.findall(r'v\=([\-\w]+)', link)[0]
project.video_link = "//www.youtube.com/v/" + str(video_code)
project.save()
messages.info(request, 'Project has been successfully created')
return HttpResponseRedirect('/project')
else:
raise Http404
def project_describe_view(request):
"""
Shows create project form if project_registered is false
Shows successfully created message if project_registered is True
"""
project_registered = False
initiator = request.user
if request.method == 'POST':
project_form = ProjectForm(data=request.POST)
if project_form.is_valid():
project_detail = project_form.save()
project_registered = True
project_detail.initiated_by = request.user
project_detail.save()
# Not a HTTP POST, so we render our form using two ModelForm instances.
# These forms will be blank, ready for user input.
else:
project_form = ProjectForm()
return render(request, 'project/start_project.html', {
'project_form': project_form,
'project_registered': project_registered
})
def add_project(request):
"""
Add project for own team
:param request: Django Request
:return: Rendered HTML
"""
if not request.user.is_authenticated():
return redirect('/')
if not request.user.team:
return redirect('/')
project = request.user.team.project
if request.method == 'POST':
# handle post
form = ProjectForm(request.POST, instance=project)
if form.is_valid():
project = form.save(commit=True)
team = request.user.team
team.project = project
team.save()
return redirect('project-view', pk=project.pk)
form = ProjectForm(instance=project)
data = {'form': form, 'user': request.user, 'error': None}
return render(request, 'web/add_project.html', data)
def save_project(request):
if request.method == "POST":
form = ProjectForm(request.POST, request.FILES)
if form.is_valid():
project = form.save(commit=False)
print 'pass'
#project.misc = request.POST['misc']
project.link_fb = request.POST['link_fb']
project.link_tw = request.POST['link_tw']
project.link_inst = request.POST['link_inst']
project.save()
form.save_m2m()
messages.info(request, 'Project has been successfully created and needs a review from website administrator.')
send_mail('MoolahForTheDoula', 'A new project has been submitted. Please login as admin to verify and approve this project.', '*****@*****.**',
['*****@*****.**'], fail_silently=False)
print 'passssssssss'
return HttpResponseRedirect('/doula')
else:
form = ProjectForm()
messages.info(request, 'Please check your entry.')
else:
form = ProjectForm()
return render_to_response("create.html", RequestContext(request, {'form': form}))
def project_update(request, id):
data = {}
project = Project.objects.get(id=id)
if request.method == 'POST':
form = ProjectForm(request.POST, request.FILES, instance=project)
if form.is_valid():
data['sms'] = "The project was successfully updated!"
project = form.save(commit=False)
d = project.endDate - project.startDate
if int(d.days) <= 0:
project.days = 0
else:
project.days = int(d.days)
team = Team.objects.all().filter(
Q(user=request.user) & Q(project=project))
new_Activity, created = Activity.objects.get_or_create(
user=request.user,
action='updated a project',
all_activity=project.name)
for t in team:
new_Activity.target.add(t.member)
project.save()
data['form_is_valid'] = True
p = Project.objects.all().filter(user=request.user)
data['project_list'] = render_to_string('project/ProjectList.html',
{'p': p},
request=request)
else:
data['form_is_valid'] = False
form = ProjectForm(instance=project)
data['html_form'] = render_to_string('project/project_update.html', {
'project': project,
'form': form
},
request=request)
return JsonResponse(data)
def project_metadata(request, docid, template="project_metadata.html"):
document = None
try:
document = _resolve_document_geo(request, docid, "base.change_resourcebase", _PERMISSION_MSG_METADATA)
except Http404:
return HttpResponse(loader.render_to_string("404.html", RequestContext(request, {})), status=404)
except PermissionDenied:
return HttpResponse(
loader.render_to_string(
"401.html", RequestContext(request, {"error_message": _("You are not allowed to edit this document.")})
),
status=403,
)
if document is None:
return HttpResponse("An unknown error has occured.", mimetype="text/plain", status=401)
else:
poc = document.poc
metadata_author = document.metadata_author
topic_category = document.category
external_person = document.external_person
if request.method == "POST":
document_form = ProjectForm(request.POST, instance=document, prefix="resource")
category_form = CategoryForm(
request.POST,
prefix="category_choice_field",
initial=int(request.POST["category_choice_field"]) if "category_choice_field" in request.POST else None,
)
else:
document_form = ProjectForm(instance=document, prefix="resource")
category_form = CategoryForm(
prefix="category_choice_field", initial=topic_category.id if topic_category else None
)
if request.method == "POST" and document_form.is_valid() and category_form.is_valid():
new_poc = document_form.cleaned_data["poc"]
# new_author = document_form.cleaned_data['metadata_author']
new_keywords = document_form.cleaned_data["keywords"]
new_ep = document_form.cleaned_data["external_person"]
new_category = TopicCategory.objects.get(id=category_form.cleaned_data["category_choice_field"])
if new_poc is None:
if poc.user is None:
poc_form = ProfileForm(request.POST, prefix="poc", instance=poc)
else:
poc_form = ProfileForm(request.POST, prefix="poc")
if poc_form.has_changed and poc_form.is_valid():
new_poc = poc_form.save()
if new_ep is None:
if external_person is None:
print "EP is None"
ep_form = ExternalPersonForm(request.POST, prefix="external_person", instance=external_person)
else:
ep_form = ExternalPersonForm(request.POST, prefix="external_person")
if ep_form.has_changed and ep_form.is_valid():
print "entro a salvar"
new_ep = ep_form.save()
"""
if new_author is None:
if metadata_author is None:
author_form = ProfileForm(request.POST, prefix="author",
instance=metadata_author)
else:
author_form = ProfileForm(request.POST, prefix="author")
if author_form.has_changed and author_form.is_valid():
new_author = author_form.save()
"""
if new_poc is not None and new_ep is not None:
the_document = document_form.save()
the_document.poc = new_poc
# the_document.metadata_author = new_author
the_document.keywords.add(*new_keywords)
Project.objects.filter(id=the_document.id).update(category=new_category, external_person=new_ep)
return HttpResponseRedirect(reverse("project_detail", args=(document.id,)))
if external_person is None:
ep_form = ExternalPersonForm(instance=external_person, prefix="external_person")
else:
document_form.fields["external_person"].initial = external_person
ep_form = ExternalPersonForm(prefix="external_person")
ep_form.hidden = True
if poc is None:
poc_form = ProfileForm(request.POST, prefix="poc")
else:
if poc is None:
poc_form = ProfileForm(instance=poc, prefix="poc")
else:
document_form.fields["poc"].initial = poc.id
poc_form = ProfileForm(prefix="poc")
poc_form.hidden = True
if metadata_author is None:
author_form = ProfileForm(request.POST, prefix="author")
else:
if metadata_author is None:
author_form = ProfileForm(instance=metadata_author, prefix="author")
else:
# document_form.fields[
# 'metadata_author'].initial = metadata_author.id
author_form = ProfileForm(prefix="author")
author_form.hidden = True
return render_to_response(
template,
RequestContext(
request,
{
"document": document,
"document_form": document_form,
"ep_form": ep_form,
"poc_form": poc_form,
"author_form": author_form,
"category_form": category_form,
},
),
)
