def manage_group(request):
SecondaryObjectiveFormSet = inlineformset_factory(Project, SecondaryObjective, form=SecondaryObjectiveForm,
extra=3, can_delete=False)
if request.method == 'POST':
project_form = ProjectForm(request.POST)
objective_formset = SecondaryObjectiveFormSet(request.POST)
# objective_form = SecondaryObjectiveForm(request.POST)
if project_form.is_valid() and objective_formset.is_valid():
project = project_form.save(commit=False)
objective = objective_formset.save(commit=False)
print("is valid >>>>>>>", objective)
project.created_by = request.user
project.save()
for obj in objective:
obj.project = project
obj.save()
print("is valid >>>>>>>", obj.objective)
return redirect("portal:home")
else:
data = project_form.errors.as_json()
print("form is not valid", data)
return JsonResponse(data, safe=False, status=400)
else:
project_form = ProjectForm()
objective_formset = SecondaryObjectiveFormSet()
return render(request, 'projects/group-management.html', {
"projects": Project.objects.all(),
"project_form": project_form,
"objective_formset": objective_formset,
})
def new_project(request):
names = ['Create New Project', 'OnGoing Projects', 'Completed Projects']
links = [
reverse('new_project'),
reverse('projects'),
reverse('old_projects')
]
submenus = create_sub(names, links)
context = {'proj_selected': 'current'}
if len(request.POST) <= 0:
form = ProjectForm()
context.update({
'form': form,
'entity': 'Project',
'submenus': submenus
})
return render(request, "new.html", context)
else:
form = ProjectForm(request.POST)
if form.is_valid():
form.save(commit=True)
url = reverse('projects')
return HttpResponseRedirect("%s?success=2" % (url))
else:
context.update({
'title':
'Create New Project',
'form':
form,
'entity':
'Project',
'errors':
'Invalid Entry or required fields not filled'
})
return render(request, "new.html", context)
def createProject(request):
if request.user.is_authenticated:
if request.method == 'POST':
form = ProjectForm(request.POST)
if form.is_valid():
project_form = form.save(commit=False)
project_form.save()
form.save_m2m()
for _img in request.FILES.getlist('project_images[]'):
FileSystemStorage(location='/images')
photo = Images(project=project_form, path=_img)
photo.save()
for tag in request.POST["project_tags"].split(","):
tag = tag.strip()
Tags(project=project_form, tag_name=tag).save()
# user profile page
return redirect("project_details", project_form.id)
else:
return render(request, 'projects/create_project.html/',
{'project_form': form})
else:
project_form = ProjectForm(initial={"user": request.user})
return render(request, 'projects/create_project.html/',
{'project_form': project_form})
else:
return redirect('login')
def add_project_view(request):
if request.user.is_authenticated() and request.user.is_staff:
if request.POST:
form = ProjectForm(request.POST)
if form.is_valid():
data = form.cleaned_data
td = data['end_date'] - data['start_date']
if td.total_seconds() > 0:
project = Project()
project.name = data['name']
project.description = data['description']
project.start_date = data['start_date']
project.end_date = data['end_date']
project.user = User.objects.get(
username=request.user.username)
project.save()
else:
messages.add_message(request, messages.ERROR,
" end date is less than start date!")
return (redirect(reverse('Home:add_project')))
return (redirect(reverse('Home:manager')))
else:
messages.add_message(request, messages.ERROR, "invalid form")
return (redirect(reverse('Home:add_project')))
else:
form = ProjectForm()
send_dict = {}
send_dict['form'] = form
return render_to_response('managers/add_project.html',
send_dict,
context_instance=RequestContext(request))
else:
return redirect(reverse('Login:login'))
def project_edit(request, pk):
if request.user.account.demo:
raise Http404
project = get_object_or_404(Project, pk=pk)
project_manager = project.project_manager
if project.archived:
raise Http404
elif not (request.user.account.role == 'admin'
or request.user.account.role == 'project_manager'):
raise Http404
elif request.user.account.role == 'project_manager' and request.user.account != project_manager:
raise Http404
if request.method == 'POST':
form = ProjectForm(request.POST, instance=project)
if form.is_valid():
new_project_manager = form.save().project_manager
if not project_manager == new_project_manager:
Notification.objects.create(
title=f'Project Edited',
text=
f'You have been removed as project manager from "{project.title}"',
recipient=project_manager)
Notification.objects.create(
title=f'Project Edited',
text=
f'You have been appointed as project manager for "{project.title}"',
recipient=new_project_manager)
return redirect('project_detail_ticket_open', pk)
return render(request, 'projects/project_edit.html',
{'form': ProjectForm(instance=project)})
def edit_project(request, id):
project = Project.objects.get(pk=id)
architects = Architect.objects.values('architect__username', 'id')
owners = Owner.objects.values('first_name', 'last_name', 'id')
if request.method == 'POST':
form = ProjectForm(request.POST)
if form.is_valid():
data = form.cleaned_data
project.architect = data['architect']
project.owner = data['owner']
project.name = data['name']
project.area = data['area']
project.type = data['type']
project.start_date = data['start_date']
project.end_date = data['end_date']
project.save()
return redirect('list_projects')
else:
form = ProjectForm()
return render(
request, 'projects/edit_project.html', {
'project': project,
'form': form,
'architects': architects,
'owners': owners,
'types': Project.BUILDING_TYPES
})
def edit_project(request, p_id):
authors = Author.objects.all()
teachers = Teacher.objects.all()
fields = Field.objects.all()
langs = Project.langChoices
project_types = Project.formChoices
courses = Project.courseChoices
users = User.objects.filter(profile__is_approved=True)
p = Project.objects.get(pk=p_id)
if request.method == 'POST':
pr = ProjectForm(request.POST, request.FILES)
if pr.is_valid():
file_form = DictFileForm(request.POST, request.FILES)
if file_form.is_valid():
p.file.file = request.FILES['file']
p.author.clear()
p.author.add(*request.POST.getlist('author'))
p.field.clear()
p.field.add(*request.POST.getlist('field'))
p.prof.clear()
p.prof.add(*request.POST.getlist('prof'))
p.title = request.POST['title']
p.title_en = request.POST['title_en']
p.keywords = request.POST['keywords']
p.keywords_en = request.POST['keywords_en']
p.abstract = request.POST['abstract']
p.abstract_en = request.POST['abstract_en']
p.link = request.POST['link']
p.course = request.POST['course']
p.form = request.POST['form']
p.lang = request.POST['lang']
p.user = User.objects.get(pk=int(request.POST['user']))
if request.POST['mark']:
p.mark = request.POST['mark']
p.save()
show_form = False
valid = True
return render(request, 'profile/edit.html', locals())
else:
errors = pr.errors
show_form = True
valid = False
field_set = set(p.field.values_list('id', flat=True))
prof_set = set(p.prof.values_list('id', flat=True))
author_set = set(p.author.values_list('id', flat=True))
render(request, 'profile/edit.html', locals())
else:
p = Project.objects.get(pk=p_id)
project_form = ProjectForm()
file_form = DictFileForm()
show_form = True
valid = True
field_set = set(p.field.values_list('id', flat=True))
prof_set = set(p.prof.values_list('id', flat=True))
author_set = set(p.author.values_list('id', flat=True))
return render(request, 'profile/edit.html', locals())
def new_project(request):
"""The view which lets users create a new project without having to make a
new session."""
form = ProjectForm(user=request.user)
if request.method == "POST":
form = ProjectForm(user=request.user, data=request.POST)
if form.is_valid():
form.save()
return redirect("/projects/{}/".format(form.instance.id))
return render(request, "new-project.html", {"form": form})
def create_project(request):
if request.method == 'POST':
form = ProjectForm(request.POST)
if form.is_valid():
project = form.save()
return redirect('projects:project', project.id)
else:
form = ProjectForm()
return render(request, 'projects/edit_project.html', {
'form': form,
})
def edit_project(request, id):
project = Project.objects.get(pk=id)
if request.method == 'POST':
form = ProjectForm(request.POST, instance=project)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('project_index'))
else:
return render(request, 'projects/edit_project.html', {'form': form})
else:
form = ProjectForm(instance=project)
return render(request, 'projects/edit_project.html', {'form': form})
def prj_create(request):
if request.method == 'POST':
form = ProjectForm(request.POST, request.FILES)
if form.is_valid():
prj = form.save(user=request.user)
return HttpResponseRedirect(prj.get_absolute_url())
else:
form = ProjectForm()
var = RequestContext(request, {'form': form})
return render_to_response('projects/prj_create.html', var)
def project_create(request):
if request.method == 'POST':
form = ProjectForm(request.POST)
if form.is_valid():
project = form.save(commit=False)
project.create_by = request.user
project.update_by = request.user
project.save()
return redirect(reverse("project_setting"))
else:
form = ProjectForm()
return render(request, 'projects/project_edit.html', locals())
def overview(request, username):
SecondaryObjectiveFormSet = inlineformset_factory(
Project,
SecondaryObjective,
form=SecondaryObjectiveForm,
extra=3,
can_delete=False)
user = User.objects.get(username=username)
projects = Project.objects.filter(Q(created_by=user)
| Q(members__id__in=[user.id]),
active=True).distinct()
resources = Publication.objects.filter(project__in=projects,
user=user,
archived=False)
if request.method == 'POST':
project_form = ProjectForm(request.POST)
objectives_formset = SecondaryObjectiveFormSet(request.POST)
# if project_form.is_valid() and objectives_formset.is_valid():
# project = project_form.save(commit=False)
# objectives = objectives_formset.save(commit=False)
# project.created_by = request.user
# project.save()
# for objective in objectives:
# objective.project = project
# objective.save()
#
# else:
# data = project_form.errors.as_json()
# print("form is not valid", data)
# return JsonResponse(data, safe=False, status=400)
else:
objectives_formset = inlineformset_factory(
Project,
SecondaryObjective,
form=SecondaryObjectiveForm,
extra=3,
can_delete=False,
)
# objectives_formset = objectives_formset(initial=SecondaryObjective.objects.all().values())
objectives_formset = objectives_formset()
project_form = ProjectForm()
return render(
request, 'accounts/profile-overview.html', {
'user': user,
"resources": resources,
"projects": projects,
"form": ResourceForm(user=request.user),
"project_form": project_form,
"objectives_formset": objectives_formset,
})
def edit_project(request, slug):
if request.method == 'POST':
project = get_object_or_404(Project, slug=slug)
form = ProjectForm(request.POST, instance=project)
if form.is_valid():
form.save()
return HttpResponseRedirect(project.get_absolute_url())
else:
project = get_object_or_404(Project, slug=slug)
form = ProjectForm(instance=project)
return render_to_response('projects/new_project.html', {'form': form},
context_instance=RequestContext(request))
def edit_project(request, project):
"""The view which lets users edit a project."""
project = get_object_or_404(Project, id=project, user=request.user)
form = ProjectForm(user=request.user, instance=project)
if request.method == "POST":
form = ProjectForm(user=request.user,
data=request.POST,
instance=project)
if form.is_valid():
form.save()
return redirect("/projects/{}/".format(form.instance.id))
return render(request, "edit-project.html", {"form": form})
def edit_project(request, project=project):
project = get_object_or_404(Project, id=project)
if request.method == 'POST':
form = ProjectForm(request.POST, instance=project)
if form.is_valid():
project = form.save()
return redirect('projects:project', project.id)
else:
form = ProjectForm(instance=project)
return render(request, 'projects/edit_project.html', {
'form': form,
'project': project,
})
def create_view(request):
blank_project_form = ProjectForm()
if request.method == 'POST':
upload = ProjectForm(request.POST, request.FILES)
if upload.is_valid():
upload.save()
return redirect('project_index')
else:
return HttpResponse(
"""your form is wrong, reload on <a href = "{{ url : 'project_index'}}">reload</a>"""
)
else:
return render(request, 'projects/create_project.html',
{'upload_form': blank_project_form})
def edit_project(request, project_id):
try:
project_id = Project.objects.get(id=project_id)
except User.DoesNotExist:
raise Http404
if request.method == 'POST':
form = ProjectForm(request.POST, instance=project_id)
if form.is_valid():
project_id = form.save()
return HttpResponseRedirect('/profile/')
else:
form = ProjectForm(instance=project_id)
return render_to_response('update_project.html', {'form': form},
context_instance=RequestContext(request))
def add_project(request, category_id=None):
if request.method == 'POST':
form = ProjectForm(request.POST)
if form.is_valid():
form.save()
return redirect(show_categories)
category = Category.objects.get(
id=category_id) if category_id else Category.objects.all()[:1].get()
form = ProjectForm(initial={'category': category})
form.fields['category'].queryset = request.user.categories.all()
return render(request, 'add_project.html', {
'form': form,
'title': 'Add project'
})
def add_project(request):
if request.method == 'POST':
form = ProjectForm(request.POST)
if form.is_valid():
form.instance.token = str(uuid4())
instance = form.save()
instance.user.add(request.user)
return HttpResponseRedirect('/panel/projects/%d' %
form.instance.id)
else:
form = ProjectForm()
return TemplateResponse(request, 'panel/project_form.html', {'form': form})
def CreateProject(request):
if request.method == "POST":
if request.user.is_staff:
projform = ProjectForm(request.POST)
if projform.is_valid():
p = Project.objects.create(name = projform.cleaned_data['name'] , progress=0)
p.save()
return HttpResponseRedirect('/projects')
else:
return render(request , 'new_project.html' , {'errors':True , 'form':projform})
else:
return HttpResponseRedirect('/projects')
else:
projform = ProjectForm()
return render(request , 'new_project.html' , {'form' : projform})
def create_project(request):
if request.method == 'POST':
project_form = ProjectForm(request.POST)
if project_form.is_valid():
project = project_form.save()
return HttpResponseRedirect(reverse('project_join', args=[project.id]))
else:
return render(request, 'projects/create_project.html',
{'project_form': project_form})
else:
project_form = ProjectForm(initial={'widgets': {'owner': forms.HiddenInput},
'owner': request.user})
return render(request, 'projects/create_project.html',
{'project_form': project_form})
def edit_project(request, projectid):
names = ['Material Purchase', 'Make Payment', 'Invoices', 'Payments']
links = [
'/projects/' + projectid + '/purchases',
'/projects/' + projectid + '/payments',
'/projects/' + projectid + '/invoices',
'/projects/' + projectid + '/allpayments'
]
submenus = create_sub(names, links)
proj = get_object_or_404(Project, pk=projectid)
context = {'proj_selected': 'current'}
if len(request.POST) <= 0:
data = {
'name': proj.name,
'location': proj.location,
'city': proj.city,
'owner': proj.owner,
'start_date': proj.start_date,
'end_date': proj.end_date
}
form = ProjectForm(data)
context.update({
'title': 'Update Project Details',
'form': form,
'submenus': submenus
})
return render(request, "edit.html", context)
else:
form = ProjectForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
proj.name = cd.get('name')
proj.location = cd.get('location')
proj.city = cd.get('city')
proj.owner = cd.get('owner')
proj.start_date = cd.get('start_date')
proj.end_date = cd.get('end_date')
proj.save()
url = reverse('projects')
return HttpResponseRedirect("%s?success=1" % (url))
else:
context.update({
'title': 'Update Project Details',
'form': form,
'submenus': submenus
})
return render(request, "edit.html", context)
def login(request):
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
try:
project = Project.objects.filter(
liderNome=form.data['liderNome'].upper(),
liderTelefone=form.data['liderTelefone'],
liderEmail=form.data['liderEmail'].upper(),
ativo='SIM')[0]
formulario = ProjectForm(instance=project)
except:
return render(
request, 'login.html', {
'form':
form,
'msg':
'Projeto não encontrado. Revise as suas informações.'
})
return render(request, 'formProject.html', {'form': formulario})
else:
return render(request, 'login.html', {
'form': form,
'msg': 'Os dados não são válidos. Revise os campos.'
})
else:
form = LoginForm()
return render(request, 'login.html', {
'form': form,
'msg': 'Erro de login.'
})
def post(self, request, *args, **kwargs):
"""Process the post request with a new Project form filled out."""
form = ProjectForm(request.POST)
if form.is_valid():
form.save(commit=True)
return HttpResponseRedirect('/projects/projects/')
return render(request, "project_create.html", {'form': form})
def getrepos():
"""
This function collects all the repos from
GitHub and store them in the database
"""
projects = requests.get('https://api.github.com/orgs/kodkollektivet/repos' + OAUTH_TOKEN).json()
for project in projects:
readme = requests.get(
'https://api.github.com/repos/kodkollektivet/' + project['name'] + '/readme' + OAUTH_TOKEN).json()
try:
readme = b64decode(readme['content'])
except:
readme = ''
form = ProjectForm({
'gh_name': project['name'],
'gh_id': project['id'],
'gh_url': project['html_url'],
'gh_readme': readme
})
if form.is_valid():
# Creates or updates a project. It fist looks it match on gh_name
pro, created = Project.objects.update_or_create(gh_name=form.data['gh_name'], defaults=form.data)
languages = requests.get('https://api.github.com/repos/kodkollektivet/'+project['name']+'/languages' + OAUTH_TOKEN).json()
for key, value in languages.iteritems():
lan, created = Language.objects.update_or_create(name=key)
obj, created = ProLan.objects.update_or_create(project=pro, language=lan)
def edit_project(request, project_id):
# if freelancer is not working on the project return forbidden
if Freelancer.objects.filter(email=request.user.email).exists() and \
Freelancer.objects.get(email=request.user.email).current_project != project_id:
return HttpResponseForbidden()
# if user is not owner of the project return forbidden
elif not Freelancer.objects.filter(email=request.user.email).exists() and \
Appointment.objects.get(email=request.user.email).project_number != project_id:
return HttpResponseForbidden()
project_i = get_object_or_404(Project, project_number=project_id)
if request.method == 'POST':
form = ProjectForm(request.POST, instance=project_i)
if form.is_valid():
form = form.save()
messages.success(request, f'Details updated successfully!{form} ')
return redirect(reverse('freelancer'))
else:
messages.error(
request, 'There is something wrong with your form '
' Please check your input! ')
return render(request, 'freelancers/dashboard.html',
{'form': form})
def edit_project(request, project_id):
project = Project.objects.get(pk=project_id)
if request.method == 'POST':
form = ProjectForm(request.POST, instance=project)
if form.is_valid():
print(">>>>>>>>>>>>>>>>>>", form.cleaned_data)
project = form.save(commit=False)
project.save()
members_queryset = form.cleaned_data.get("members")
# ProjectMembers.objects.filter(project=project).delete()
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>", members_queryset.all().values_list('id', flat=True))
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>", Membership.objects.filter(project=project))
for id in Membership.objects.select_related().filter(project=project).values_list('user__id', flat=True):
if id not in members_queryset.all().values_list('id', flat=True):
Membership.objects.filter(project=project, user__id=id).delete()
for member in members_queryset.all():
if not Membership.objects.filter(project=project, user=member).exists():
Membership.objects.create(user=member, project=project)
return render(request, 'projects/includes/_project-card.html', {
'project': project,
})
else:
data = form.errors.as_json()
return JsonResponse(data, safe=False, status=400)
def post(self, request):
var = ''
form = ProjectForm(request.POST, request.FILES)
form2 = ProfileForm(request.POST, request.FILES)
projects = request.user.projects.all()
template_name = 'capturista/home.html'
if form.is_valid():
pro = form.save(commit=False)
pro.user = request.user
pro.save()
messages.success(request, "Proyecto guardado con éxito")
context = {'section': 'alta', 'num_projects': projects.count()}
else:
context = {
'section': 'alta',
'form': form,
'form2': form2,
'num_projects': projects.count()
}
return render(request, template_name, context)
if form2.is_valid():
perf = form2.save(commit=False)
perf.uid = pro.uid
perf.save()
return redirect('projects:detail', id=pro.id)
def checkCommunityPartner(request):
partnerForm = ProjectForm()
communityParnterName = []
for object in CommunityPartner.objects.order_by('name'):
partner = object.name
if partner not in communityParnterName:
communityParnterName.append(partner)
if request.method == 'POST':
partnerForm = ProjectForm(request.POST)
# print(projectNames)
return render(request, 'partners/checkCommunityPartner.html',
{'partnerForm': partnerForm, 'partnerNames':communityParnterName})
