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 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):
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(request):
#template_project = Project()
#form = ProjectForm(request.POST or template_project)
form = ProjectForm(request.POST or None, initial={})
if form.is_valid():
new_project = Project(title=form.cleaned_data['title'], description=form.cleaned_data['description'], url=form.cleaned_data['url'], open=form.cleaned_data['open'])
new_project.save()
#new_project = form.save()
new_position = admin_position_default
new_position.project = new_project
new_position.save()
relation = ProjectRelation(admin=True, user=request.user.userdata, project=new_project)
relation.save()
new_position.project_relation = relation
new_position.save()
admin_position_default.id=None
for interest in form.cleaned_data['interests']:
pi = ProjectInterest(project=new_project, interest=interest)
pi.save()
return redirect(project_detail, new_project.id)
return render_to_response('project/create.html', {'form': form}, context_instance=RequestContext(request))
def create( request, badge_id ):
badge = badge_api.get_badge(badge_api.id2uri(badge_id))
fetch_badge_resources(badge)
context = { 'badge': badge }
user_uri = request.session['user']['uri']
if request.method == 'POST':
form = ProjectForm(request.POST, request.FILES)
else:
form = ProjectForm()
if form.is_valid():
image = media_api.upload_image(request.FILES['image'], user_uri)
try:
project = project_api.create_project(
badge['uri'],
user_uri,
form.cleaned_data['title'],
image['uri'],
form.cleaned_data['work_url'],
form.cleaned_data['description'],
form.cleaned_data['reflection'],
form.cleaned_data['tags']
)
return http.HttpResponseRedirect(reverse('project_view', args=(project['id'],)))
except project_api.MultipleProjectError:
messages.error(request, _('You have already submitted a project for this badge.'))
context['form'] = form
return render_to_response(
'project/create.html',
context,
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 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 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 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 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 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 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 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 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 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_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 create(request, badge_id):
badge = badge_api.get_badge(badge_api.id2uri(badge_id))
fetch_badge_resources(badge)
context = {'badge': badge}
user_uri = request.session['user']['uri']
if request.method == 'POST':
form = ProjectForm(request.POST, request.FILES)
else:
form = ProjectForm()
if form.is_valid():
try:
image = media_api.upload_image(
request.FILES['image'],
user_uri,
media_root=settings.MEDIA_ROOT,
delete_original=True)
project = project_api.create_project(
badge['uri'],
user_uri,
form.cleaned_data['title'],
image['uri'],
form.cleaned_data['work_url'],
form.cleaned_data['description'],
form.cleaned_data['reflection'],
form.cleaned_data['tags']
)
return http.HttpResponseRedirect(reverse('project_view', args=(project['id'],)))
except project_api.MultipleProjectError:
messages.error(request, _('You have already submitted a project for this badge.'))
except media_api.UploadImageError:
messages.error(request, _('Project image cannot be uploaded. Possible reasons: format not supported'
'(png, jpeg, jpg, gif), file size too large (up to 256kb).'))
context['form'] = form
return render_to_response(
'project/create.html',
context,
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 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 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 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 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_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 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 editOrCreateStuff(project, request):
if request.user.is_authenticated() and str(project.author) == str(request.user):
## postmode! We are getting pretty post data from the user!!!
if request.method == 'POST':
if (request.POST['action']=="Delete"):
project.delete()
return HttpResponseRedirect('/mydrafts/')
## get the forms and check that they are valid
form = ProjectForm(request.POST.copy(), project)
if form.is_valid():
project.valid=True
## Title related stuff. Setting it, making sure it's still there, whatever.
if "title" in form.cleaned_data and form.cleaned_data["title"]: # if that data is not a blank string
project.title = form.cleaned_data["title"] # than we do change the title
else:
form.data['title'] = project.title
project.updateReadme(form.cleaned_data["body"])
list_to_tags(form.cleaned_data["tags"], project.tags)
#### All this fun stuff is handeling what happens for trying to publish vs trying to save the project.
if project.valid:
if(request.POST['action']=="Publish"):
project.draft=False
project.save()
return HttpResponseRedirect('/project/'+str(project.pk))
elif(request.POST['action'] in ["Save", "Update"]):
project.save()
return HttpResponseRedirect('/mydrafts/')
else:
project.save()
draftSaved = True
return render_to_response('edit.html', RequestContext(request,{'project':project, 'user':request.user, 'form':form, 'draftSaved':draftSaved,}))
#### Not a POST request. We are setting up the form for the user to fill in. We are not getting form data from the user.
else:
form = project.get_form()## this gets a form filled with the projects data
form.errors['title'] = ""#form['body'].error_class()
form.errors['thumbnail'] = ""#form['body'].error_class()
form.errors['body'] = ""#form['body'].error_class()
return render_to_response('edit.html', RequestContext(request,{'project':project, 'user':request.user, 'form':form}))
else: ##If the user isn't authenticated.
return HttpResponse(status=403)
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 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 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 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_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 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,
},
),
)
def setUp(self):
self.form = ProjectForm()
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 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:
for i in form2.cleaned_data["categories"]:
project.tags.add(i)
# 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 new_project(request, pid='', nid=''):
#没登陆的提示去登录
if not request.user.is_authenticated():
return HttpResponseRedirect("/nologin")
#编辑的得有编辑权限
if pid:
uid = request.session['id']
cpro = models.project.objects.get(id=pid)
#如果是负责人且有编辑权限才可以
flag = 0
if uid == cpro.leader_p_id or uid == cpro.designer_p_id or uid == cpro.tester_p_id or request.user.has_perm('auth.change_permission'):
if request.user.has_perm('project.change_project'):
flag = 1
if not flag:
return HttpResponseRedirect("/noperm")
#新建的得有新建权限
if not pid and not request.user.has_perm('project.add_project'):
return HttpResponseRedirect("/noperm")
if request.user.has_perm('auth.change_permission'):
editdate = 1
else:
editdate = 0
form = ProjectForm()
if request.method == 'POST':
form = ProjectForm(request.POST)
if form.is_valid():
priority = form.cleaned_data['priority']
pname = form.cleaned_data['pname']
status = form.cleaned_data['status']
leaderid = form.cleaned_data['leader']
leader = models.user.objects.get(id=leaderid)
designer = form.cleaned_data['designer']
if designer:
designer = models.user.objects.get(id=designer)
tester = form.cleaned_data['tester']
if tester:
tester = models.user.objects.get(id=tester)
sdate = form.cleaned_data['startdate']
pdate = form.cleaned_data['plandate']
psdate = form.cleaned_data['psdate']
pedate = form.cleaned_data['pedate']
dsdate = form.cleaned_data['dsdate']
dedate = form.cleaned_data['dedate']
tsdate = form.cleaned_data['tsdate']
tedate = form.cleaned_data['tedate']
ppath = form.cleaned_data['ppath']
dppath = form.cleaned_data['dppath']
tppath = form.cleaned_data['tppath']
tcpath = form.cleaned_data['tcpath']
trpath = form.cleaned_data['trpath']
relateduser = form.cleaned_data['relateduser']
if pid == '' or nid == '1':
pro = models.project(priority=priority, \
project=pname, status_p=status, leader_p=leader, \
designer_p=designer, tester_p=tester, start_date=sdate, \
expect_launch_date=pdate, \
estimated_product_start_date=psdate, \
estimated_product_end_date=pedate, \
estimated_develop_start_date=dsdate, \
estimated_develop_end_date=dedate, \
estimated_test_start_date=tsdate, \
estimated_test_end_date=tedate, blueprint_p=ppath, \
develop_plan_p=dppath, test_plan_p=tppath, \
test_case_p=tcpath, test_report_p=trpath, isactived=1)
else:
rdate = models.project.objects.get(id=pid).real_launch_date
pnum = models.project.objects.get(id=pid).praise_p
pro = models.project(id=pid, priority=priority,\
project=pname, status_p=status, leader_p=leader, \
designer_p=designer, tester_p=tester, start_date=sdate, \
expect_launch_date=pdate, \
real_launch_date=rdate, \
estimated_product_start_date=psdate, \
estimated_product_end_date=pedate, \
estimated_develop_start_date=dsdate, \
estimated_develop_end_date=dedate, \
estimated_test_start_date=tsdate, \
estimated_test_end_date=tedate, blueprint_p=ppath, \
develop_plan_p=dppath, test_plan_p=tppath, \
test_case_p=tcpath, test_report_p=trpath, \
isactived=1, praise_p=pnum)
pro.save()
#存完项目，存相关产品测试开发人员信息
relateduser = relateduser.replace(" ", "").split(",")
if len(relateduser):
if pid == '' or nid =='1':
pid = models.project.objects.filter\
(project=pname).order_by("-id")[0].id
else:
models.project_user.objects.filter(project_id=pid).delete()
#
for uid in relateduser:
if uid:
project_user = models.project_user\
(username_id=uid, project_id=pid, isactived=1)
project_user.save()
#给项目的各负责人添加编辑项目权限
musername = models.user.objects.get(id=leaderid).username
#给项目负责人加入到项目负责人权限组
User.objects.get(username=musername).groups.add(4)
if designer:
dusername = models.user.objects.get\
(id=form.cleaned_data['designer']).username
#给产品负责人加入到产品负责人权限组
User.objects.get(username=dusername).groups.add(5)
if tester:
tusername = models.user.objects.get\
(id=form.cleaned_data['tester']).username
#给测试负责人加入到测试负责人权限组
User.objects.get(username=tusername).groups.add(6)
#给项目负责人添加申请延期权限
#User.objects.get(username=musername).user_permissions.add(34)
#上线后插条公告,如果表中项目ID存在,排序看isactived是否为0,如果不存在该项目ID或最小的isactived=0,则插入公告
if status == "已上线":
flag = 0
prolist = public_message.objects.filter\
(project=pid).order_by("isactived")
try:
prolist[0].isactived
except IndexError:
try:
request.session['id']
except KeyError:
return HttpResponseRedirect("/nologin")
else:
flag = 1
else:
if prolist[0].isactived != 0:
try:
request.session['id']
except KeyError:
return HttpResponseRedirect("/nologin")
else:
flag = 1
if flag == 1:
usrid = request.session['id']
project = models.project.objects.get(id=pid)
time = datetime.datetime.now().strftime("%Y-%m-%d %H:%I:%S")
content = project.project + u"于"+time+u"已上线"
pmessage = public_message(project=pid, \
publisher=usrid, content=content, type_p="notice", \
publication_date=datetime.datetime.now(), \
isactived=False)
pmessage.save()
project.real_launch_date = datetime.datetime.now()
project.save()
return redirect('/projectlist/')
return render_to_response('newproject.html', \
{'form':form, 'editdate':editdate}, context_instance=RequestContext(request))
def get_context_data(self, **kwargs):
context = super(ProjectDisplay, self).get_context_data(**kwargs)
context['form'] = ProjectForm()
return context
