def new_packet(request):
"""Display the New Report form.
This view combines the Report model and the corresponding data model. This needs to be made into an abstract class
that can be implemented by ths specific views of different case types.
"""
# TODO: make this an abstract class to handle every type of report
if request.method == "POST":
case_form = CaseForm(request.POST)
packet_form = PacketForm(request.POST)
report_form = ReportForm(request.POST)
if report_form.is_valid() and packet_form.is_valid(
) and case_form.is_valid():
case_form.save()
packet = packet_form.save()
# TODO: How to save relationship?
return redirect('edit_packet', pk=packet.pk)
else:
case_form = CaseForm()
packet_form = PacketForm()
report_form = ReportForm()
return render(
request, "contributor/new_packet.html", {
'case_form': case_form,
'report_form': report_form,
'packet_form': packet_form
})
def edit_packet(request, pk):
"""Display the New Report form.
This view combines the Report model and the corresponding data model. This needs to be made into an abstract class
that can be implemented by ths specific views of different case types.
"""
packet = get_object_or_404(Packet, pk=pk)
cases = get_cases(packet)
# TODO: make this an abstract class to handle every type of report
if request.method == "POST":
case_form = CaseForm(request.POST)
packet_form = PacketForm(request.POST)
report_form = ReportForm(request.POST)
if report_form.is_valid() and case_form.is_valid(
) and packet_form.is_valid():
packet_form.save()
for case in cases:
case.save()
return redirect('edit_packet')
def new_Dcase(request):
"""Display the New Report form.
This view combines the Report model and the corresponding data model. This needs to be made into an abstract class
that can be implemented by ths specific views of different case types.
"""
# TODO: make this an abstract class to handle every type of report
if request.method == "POST":
case_form = CaseForm(request.POST)
report_form = ReportForm(request.POST)
dval_form = DFormD(request.POST)
fval_form = DFormF(request.POST)
if case_form.is_valid() and report_form.is_valid(
) and dval_form.is_valid() and fval_form.is_valid():
case = case_form.save()
report = report_form.save()
dmodelf, fcreated = DModelF.objects.get_or_create(
**fval_form.cleaned_data)
dmodeld, dcreated = DModelD.objects.get_or_create(
**dval_form.cleaned_data)
dmodel, dmodelcreated = DModel.objects.get_or_create(fval=dmodelf,
dval=dmodeld)
CaseD.objects.create(report=report, case=case, dmodel=dmodel)
return redirect('case_list')
def new_case(request):
"""Display the New Report form.
This view combines the Report model and the corresponding data model. This needs to be made into an abstract class
that can be implemented by ths specific views of different case types.
"""
# TODO: make this an abstract class to handle every type of report
if request.method == "POST":
case_form = CaseForm(request.POST)
report_form = ReportForm(request.POST)
data_form = HFormData(request.POST)
stuff_form = HFormStuff(request.POST)
if report_form.is_valid() and data_form.is_valid(
) and stuff_form.is_valid():
case = case_form.save()
report = report_form.save()
hmodeldata, fcreated = HModelData.objects.get_or_create(
**data_form.cleaned_data)
hmodelstuff, dcreated = HModelStuff.objects.get_or_create(
**stuff_form.cleaned_data)
hmodel, dmodelcreated = HModel.objects.get_or_create(
data=hmodeldata, stuff=hmodelstuff)
CaseH.objects.create(report=report, case=case, hmodel=hmodel)
return redirect('case_list')
def new_report(request):
if request.method == "POST":
report_form = ReportForm(request.POST)
data_form = DataForm(request.POST)
if report_form.is_valid() and data_form.is_valid():
report = report_form.save()
data = data_form.save(commit=False)
data.report = report
data.save()
return redirect('index')
else:
report_form = ReportForm()
data_form = DataForm()
context = {
'report_form': report_form,
'data_form': data_form,
}
return render(request, "new_report.html", {
'report_form': report_form,
'data_form': data_form,
})
def caseD_edit(request, pk):
"""Display the New Report form.
This view combines the Report model and the corresponding data model. This needs to be made into an abstract class
that can be implemented by ths specific views of different case types.
"""
# TODO: make this an abstract class to handle every type of report
report = get_object_or_404(Report, pk=pk)
# TODO: NOT WORKING!!!!
dval = get_object_or_404(DModelD, pk=DModel.objects.get(report=report.id))
fval = get_object_or_404(DModelF, pk=DModel.objects.get(report=report.id))
if request.method == "POST":
report_form = ReportForm(request.POST, instance=report)
dval_form = DFormD(request.POST, instance=dval)
fval_form = DFormF(request.POST, instance=fval)
if report_form.is_valid() and dval_form.is_valid(
) and fval_form.is_valid():
report.mod_date = timezone.now
report = report_form.save()
fval, fcreated = DModelF.objects.get_or_create(
**fval_form.cleaned_data)
dval, dcreated = DModelD.objects.get_or_create(
**dval_form.cleaned_data)
DModel.objects.update(dval=dval, fval=fval, report=report)
return redirect('report_list')
else:
report_form = ReportForm(instance=report)
dval_form = DFormD(instance=dval)
fval_form = DFormF(instance=fval)
return render(request, "contributor/new_Genreport.html", {
'report_form': report_form,
'dval_form': dval_form,
'fval_form': fval_form
})
report_form = ReportForm(request.POST)
if report_form.is_valid() and case_form.is_valid(
) and packet_form.is_valid():
packet_form.save()
for case in cases:
case.save()
return redirect('edit_packet')
else:
case_form = CaseForm()
packet_form = PacketForm()
report_form = ReportForm()
return render(
request, "contributor/new_packet.html", {
'case_form': case_form,
'report_form': report_form,
'packet_form': packet_form
})
# TODO: use middleware instead of decorators
@user_passes_test(is_contributor)
def new_case(request):
"""Display the New Report form.
This view combines the Report model and the corresponding data model. This needs to be made into an abstract class