def test_create_project_form_invalid(self):
'''
The UserStoy creating view function's test with invalid form data
'''
form = CreateProjectForm(data={})
self.assertFalse(form.is_valid())
self.assertEqual(len(form.errors), 2)
def test_create_project_form_is_valid(self):
'''
The Project creating view function's test with valid form data
'''
form_data = {
'name': 'New',
'code': 'TEST',
'release': '2020',
}
form = CreateProjectForm(data=form_data)
self.assertTrue(form.is_valid())
def project_create(request):
"""
The view for creating a new project where the docs will be hosted
as objects and edited through the site
"""
form = CreateProjectForm(request.POST or None)
if request.method == "POST" and form.is_valid():
project = form.save()
form.instance.users.add(request.user)
project_manage = reverse("projects_detail", args=[project.slug])
return HttpResponseRedirect(project_manage)
return render_to_response("projects/project_create.html", {"form": form}, context_instance=RequestContext(request))
def project_create(request):
"""
The view for creating a new project where the docs will be hosted
as objects and edited through the site
"""
form = CreateProjectForm(request.POST or None)
if request.method == 'POST' and form.is_valid():
form.instance.user = request.user
project = form.save()
project_manage = reverse('projects_manage', args=[project.slug])
return HttpResponseRedirect(project_manage)
return render_to_response('projects/project_create.html', {'form': form},
context_instance=RequestContext(request))
def create_project(request,):
if request.method == 'POST':
formset = CreateProjectForm(request.POST, request.FILES,)
if formset.is_valid():
categories,dummy= Project_categories.objects.get_or_create(
name= formset.cleaned_data['category']
)
projects, created = Projects.objects.filter(
client_name = request.user,
category = categories
)
projects.title = formset.cleaned_data['title']
projects.description = formset.cleaned_data['description']
projects.suggested_budget = formset.cleaned_data['budget']
if not created:
projects.tags.clear()
# Create new tag list.
tag_names = formset.cleaned_data['tags'].split()
for tag_name in tag_names:
tag, dummy = Tag.objects.get_or_create(name=tag_name)
projects.tags.add(tag)
projects.save()
return HttpResponseRedirect(reverse('success'))
else:
formset = CreateProjectForm()
return render_to_response("projects/create_projects.html", {
"formset": formset,'user':request.user
}, context_instance = RequestContext(request), )
def test_required_fields(self):
form = CreateProjectForm()
self.assertTrue(form.fields['name'].required)
self.assertTrue(form.fields['project_type'].required)
self.assertFalse(form.fields['git_owner'].required)
self.assertFalse(form.fields['git_name'].required)
self.assertTrue(form.fields['owner_type'].required)
self.assertTrue(form.fields['organization_owner'].required)
self.assertFalse(form.fields['description'].required)
def create_project(request):
context = {'form': CreateProjectForm()}
if request.method == 'GET':
return render(request, 'projects/create-project.html', context)
else:
project_pk = request.POST.get('project_pk')
try:
project = Project.objects.get(pk=project_pk)
form = CreateProjectForm(request.POST, instance=project)
context['form'] = form
if form.is_valid():
project = form.save(commit=False)
project.save()
return JsonResponse({'pk': project.pk})
else:
return HttpResponse('error')
except Project.DoesNotExist:
project = Project.objects.create()
return JsonResponse({'pk': project.pk})
def create_project(request):
"""
Renders a form for managerial members to create a new project.
Only managerial members can access this functionality.
"""
# Check if the user is a managerial member or not
user = request.user
if not user.get_profile().is_managerial():
raise Http404 # Permission denied
form = CreateProjectForm()
# If post data has been submitted, perform validation and save
if request.method == 'POST':
form = CreateProjectForm(request.POST)
if form.is_valid():
project = form.save()
return HttpResponseRedirect(project.get_absolute_url())
# Render the form if post data was not submitted, or if validation failed
context = {'form': form, }
return render_to_response('projects/create_project.html', context,
context_instance = RequestContext(request))
def test_field_labels(self):
form = CreateProjectForm()
self.assertTrue(form.fields['name'].label is None
or form.fields['name'].label == 'Name')
self.assertTrue(form.fields['project_type'].label is None
or form.fields['project_type'].label == 'Project type')
self.assertTrue(form.fields['git_owner'].label is None
or form.fields['git_owner'].label == 'Git owner')
self.assertTrue(form.fields['git_name'].label is None
or form.fields['git_name'].label == 'Git name')
self.assertTrue(form.fields['owner_type'].label is None
or form.fields['owner_type'].label == 'Owner')
self.assertTrue(
form.fields['organization_owner'].label is None
or form.fields['organization_owner'].label == 'Organization')
self.assertTrue(form.fields['description'].label is None
or form.fields['description'].label == 'Description')
def test_invalid_form(self):
form_data = {'name': 'Project', 'description': 'opis projekta'}
form = CreateProjectForm(data=form_data)
self.assertFalse(form.is_valid())
def test_field_number(self):
form = CreateProjectForm()
self.assertEqual(len(form.fields), 7)
def test__initial_values(self):
form = CreateProjectForm()
self.assertEqual(form.fields['project_type'].initial, 'p')
self.assertEqual(form.fields['owner_type'].initial, 'o')
def create(request):
# if this is a POST request we need to process the form data
if request.method == 'POST':
# create a form instance and populate it with data from the request:
form = CreateProjectForm(request.user, request.POST)
# check whether it's valid:
if form.is_valid():
project = form.save(commit=False)
project.user = request.user
project.save()
branch = Branch()
branch.project = project
branch.code = 'master'
branch.name = 'Master'
branch.save()
project.active_branch = branch
project.save()
revision = Revision()
revision.branch = branch
revision.save()
branch.head = revision
branch.save()
readme_file = File()
readme_file.filename = 'README.md'
readme_file.file = '# %s\n' % project.name
readme_file.mime = 'text/markdown'
readme_file.save()
revision.files.add(readme_file)
side_config_file = File()
side_config_file.filename = '%s.side' % project.code
side_config_file.file = '%s.c\n' % project.code
side_config_file.mime = 'text/plain'
side_config_file.save()
revision.files.add(side_config_file)
main_source_file = File()
main_source_file.filename = '%s.c' % project.code
main_source_file.file = """// ------ Libraries and Definitions ------
#include "simpletools.h"
// ------ Main Program ------
int main()
{
}
"""
main_source_file.mime = 'text/x-c'
main_source_file.save()
revision.files.add(main_source_file)
revision.save()
return redirect('projects:project', project.user.username,
project.code, 'master')
# if a GET (or any other method) we'll create a blank form
else:
form = CreateProjectForm(request.user)
logger.error("Project already exists")
return render(request, 'create.html', {'form': form})
