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 update_project(request, project_id):
global message
project = get_object_or_404(Project, pk=project_id)
form = ProjectForm()
if request.method == 'POST':
form = ProjectForm(request.POST, request.FILES)
if form.is_valid():
project.title = form.cleaned_data.get('title')
project.details = form.cleaned_data.get('details')
project.total_target = form.cleaned_data.get('total_target')
project.start_date = form.cleaned_data.get('start_date')
project.end_date = form.cleaned_data.get('end_date')
# get category object then update
project.category = Category.objects.filter(
title=form.cleaned_data.get('category')).first()
# if uplade new image , clear old images
if request.FILES.getlist('images'):
ProjectPicture.objects.filter(project=project).delete()
# store new image
for image in request.FILES.getlist('images'):
ProjectPicture.objects.create(project=project, image=image)
project.save()
message = {
'status': "alert-success",
'message': "Update Successfully"
}
else:
print("form error")
message = {'status': 'alert-danger', 'message': 'Update Failure'}
return redirect('profile_page')
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 edit_project(request, pid):
"""
编辑项目
:param request:
:return:
"""
if request.method == "GET":
if pid:
p = Project.objects.get(id=pid)
print("编辑的id:", pid, p.name)
# 把p对象的数据赋值给表单
form = ProjectForm(instance=p)
return render(request, "project.html", {
"type": "edit",
"form": form,
"id": pid
})
elif request.method == "POST":
form = ProjectForm(request.POST)
p = Project.objects.get(id=pid)
print("编辑post的id:", pid, p.name)
if form.is_valid():
name = form.cleaned_data['name']
describe = form.cleaned_data['describe']
status = form.cleaned_data['status']
p = Project.objects.get(id=pid)
p.name = name
p.describe = describe
p.status = status
p.save()
return HttpResponseRedirect("/project/")
def get_context_data(self, **kwargs):
context = TemplateView.get_context_data(self, **kwargs)
project = Project.objects.get(id=kwargs.get('id'))
if project and self.request.user == project.author:
context['form'] = ProjectForm(instance=project)
context['mode'] = 'edit'
context['id'] = project.id
elif not project:
context['form'] = ProjectForm()
context['mode'] = 'create'
else:
raise Http404
return context
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 profile(request):
user = get_object_or_404(MyUser, pk=request.user.id)
projects = Project.objects.filter(user=user)
donations = Denote.objects.filter(user=user)
category = Category.objects.all()
projectform = ProjectForm()
donationform = DenoteForm()
userform = UserForm()
projects_nums = projects.count()
last_project = 'No Projects'
if projects:
last_project = projects.order_by('-start_date').first().title #
last_donation = '-------'
if donations.count():
last_donation = donations.order_by('-created_at').first().created_at #
context = {
'user': user,
'projects': projects,
'donations': donations,
'category': category,
'projectform': projectform,
'donationform': donationform,
'userform': userform,
'message': message,
'user_activaties': { #
'projects_nums': projects_nums,
'last_project': last_project,
'total_donation': get_total_donotations(user),
'last_donation': last_donation
},
}
# print(context)
# return HttpResponse("asdasd")
return render(request, 'account/profile.html', context)
def get_context_data(self, **kwargs):
logger.debug('Hello just testing logs')
context = super(GeneralContextMixin, self).get_context_data(**kwargs)
context["username"] = self.request.user.username
context['projects'] = Project.objects.filter(
account__user=self.request.user)
context['project_form'] = ProjectForm()
return context
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 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 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 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 get(self, request, manager_id):
response = {'manager_id': manager_id}
date = datetime.datetime.now()
response['month'] = date.month
response['year'] = date.year
response['clients'] = User.objects.filter(role="client",
createdby=manager_id)
response['form'] = ProjectForm()
response['form'].fields['status'].widget = forms.HiddenInput()
response['projects'] = Project.objects.filter(createdby=manager_id)
return render(request, 'project/project.html', 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_new(request):
if request.method == 'POST':
form = ProjectForm(request.POST)
if form.is_valid():
project = Project()
project.author = request.user
project.first_name = form.cleaned_data['first_name']
project.last_name = form.cleaned_data['last_name']
project.email = form.cleaned_data['email']
project.project_name = form.cleaned_data['project_name']
project.project_description = form.cleaned_data[
'project_description']
project.project_notes = form.cleaned_data['project_notes']
project.published_date = timezone.now()
project.lang_choices = form.cleaned_data['select_lang']
project.save()
return redirect('projects')
else:
form = ProjectForm()
return render(request, 'blog/project_new.html', {'form': form})
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 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 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 project_update(request, pk):
project = get_object_or_404(Project, pk=pk)
form = ProjectForm(request.POST or None,
initial={
'first_name': project.first_name,
'last_name': project.last_name,
'email': project.email,
'project_name': project.project_name,
'project_description': project.project_description,
'project_notes': project.project_notes,
'select_langs': project.select_langs,
})
return render(request, 'blog/project_new.html', {'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 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 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 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 editOrCreateStuff(project, request, creating):
## Note: if creating == true this is a post being created.
#Because there are so many similarities in creating a post vs editing a post we are using this method, and using creating when we need to do something different for editing vs creating.
## postmode! We are getting pretty post data from the user!!!
if request.method == 'POST':
## get the forms and check that they are valid
formValid = False
if creating:
form = createForm(request.POST, project)
form2 = defaulttag(request.POST)
if form.is_valid() and form2.is_valid(
) and request.user.is_authenticated():
formValid = True
# If we are creating the post we need to set the author and title.
project.author = request.user
project.title = form.cleaned_data["title"]
else:
form = ProjectForm(request.POST, project)
if form.is_valid() and str(project.author) == str(request.user):
formValid = True
## if the form is valid make the changes to the project!
if formValid:
# Editing the Readme.md file stuff.
if not creating:
# Delete the old body text file... cause I'm a bad person and I don't know how to just open and write to the old one easily.
readme = project.bodyFile
try:
readme = project.bodyFile
readmename = path.split(str(readme.filename))[1]
readme.delete()
except:
pass
# Save body as file
bodyText = fileobject()
bodyText.parent = project
from django.core.files.uploadedfile import UploadedFile
import base64
from io import BytesIO
from io import TextIOWrapper
from io import StringIO
#io = TextIOWrapper(TextIOBase(form.cleaned_data["body"]))
io = StringIO(form.cleaned_data["body"])
txfl = UploadedFile(io)
#editfield may be renaming your readme to readme.md every time. That's not good.
try:
bodyText.filename.save(readmename, txfl)
except:
bodyText.filename.save('README.md', txfl)
txfl.close()
io.close()
bodyText.save()
#### this did not appear to be happening in the create.... but I think it should have been?
project.bodyFile = bodyText
# Done with editing the README.md textfile.
#
list_to_tags(form.cleaned_data["tags"], project.tags)
if creating:
list_to_tags(form2.cleaned_data["categories"], project.tags,
False)
# This may be redundant, but either way, this post is not a draft past this point.
project.draft = False
project.save()
return HttpResponseRedirect('/project/' + str(project.pk))
#### If the form data was NOT valid
else:
if creating:
return render_to_response(
'create.html',
dict(user=request.user,
form=form,
form2=form2,
project=project))
else:
if str(project.author) == str(request.user):
return render_to_response(
'edit.html',
dict(
project=project,
user=request.user,
form=form,
))
else:
return HttpResponse(status=403)
#### Not POSTmode! We are setting up the form for the user to fill in. We are not getting form data from the user.
##### CREATE
elif creating and request.user.is_authenticated():
form = createForm("", project)
form2 = defaulttag()
return render_to_response(
'create.html',
dict(user=request.user, form=form, form2=form2, project=project))
##### EDIT
elif (not creating) and str(project.author) == str(request.user):
if project.bodyFile:
readme = project.bodyFile.filename.read()
else:
readme = project.body
taglist = []
for i in project.tags.names():
taglist.append(i)
taglist = ",".join(taglist)
thumbnailstring = "/" + path.split(project.thumbnail.filename.url)[1]
form = ProjectForm(
{
'body': readme,
'thumbnail': thumbnailstring,
'tags': str(taglist)
}, project)
return render_to_response(
'edit.html', dict(
project=project,
user=request.user,
form=form,
))
#return HttpResponse(response_data, mimetype="application/json")
else:
return HttpResponse(status=403)
def create_project(request):
if request.method == 'POST':
form = ProjectForm(request.POST)
if form.is_valid():
u = request.user
salt = hashlib.sha1(str(random.random())).hexdigest()[:5]
usernamesalt = request.user.email
profile = Profile.objects.get(user_id=u.id)
profile.activation_key = hashlib.sha1(salt + usernamesalt).hexdigest()
profile.key_expires = timezone.now() + timedelta(days=2)
domain = Domain.objects.create(
name=form.cleaned_data['project'],
)
# create project for new user
project = Project.objects.create(
name=form.cleaned_data['project'],
description='Project for %s ' % (u.username),
domain=domain
)
# get role
r = Role.objects.get(name="user")
# assign new user as domain user
assign_domain = Assignment.objects.create(
type=3,
actor=u,
target_domain=domain,
target_project=project,
role=r
)
# assign new user as project user
assign_project = Assignment.objects.create(
type=1,
actor=u,
target_domain=domain,
target_project=project,
role=r,
)
# get first site
site = Sites.objects.first()
# get domain assignment
domain = Assignment.objects.filter(actor=u.id)
project = Assignment.objects.filter(actor=u.id)
# get domain assignment
domain = Assignment.objects.filter(actor=u.id)
project = Assignment.objects.filter(actor=u.id)
# if there is a site
if site:
# save site id to profile
profile.selected_site = site.id
profile.selected_domain = domain[0].target_domain_id
profile.selected_project = project[0].target_project_id
profile.save()
# create domain for new user
site_url = settings.SITE_ROOT_URL
send_email({'u': u, 'profile': profile, 'site_url': site_url},
_('Welcome to our cloud'),
u.email,
settings.DEFAULT_EMAIL_FROM,
)
return render(request,
'authcp/success.html',
{'u': u, 'profile': profile})
else:
print(form.errors)
else:
form = ProjectForm()
title = _("Create Project")
return render(request, 'project/create.html', {'form': form, 'title': title})
def create_project(request):
form = ProjectForm() # A empty, unbound form
return render(request,
'project/create.html', {'form': form},
context_instance=RequestContext(request))
def get_context_data(self, **kwargs):
context = super(ProjectDisplay, self).get_context_data(**kwargs)
context['form'] = ProjectForm()
return context
def setUp(self):
self.form = ProjectForm()
