ross/penracourses
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
4460545442b164ba747ea2500ae96dde1815b618
penracourses/atlas/forms.py
T
Ross 5187885c3b lots of improvements
2025-07-14 13:26:11 +01:00

995 lines
31 KiB
Python
Executable File
Raw Blame History

from django import forms
from django.contrib.admin import widgets
from django.forms import (
BaseInlineFormSet,
BooleanField,
Form,
HiddenInput,
ModelForm,
ModelMultipleChoiceField,
ModelChoiceField,
ChoiceField,
CharField,
ValidationError,
modelformset_factory,
CheckboxSelectMultiple
)
from django.forms import inlineformset_factory
from django.shortcuts import get_object_or_404
from django_jsonforms.forms import JSONSchemaField
from django_svelte_jsoneditor.widgets import SvelteJSONEditorWidget
from atlas.models import (
Case,
CaseCollection,
CaseDetail,
CasePrior,
CidReportAnswer,
Differential,
Finding,
QuestionSchema,
Resource,
SelfReview,
Series,
SeriesDetail,
SeriesImage,
SeriesFinding,
Condition,
Structure,
Subspecialty,
UncategorisedDicom,
UserReportAnswer,
CaseDisplaySet,
)
from anatomy.models import Modality
from generic.models import Examination#, Sign
# from generic.models import Examination, Site, Condition, Sign
from django.contrib.admin.widgets import FilteredSelectMultiple
from django.forms.widgets import RadioSelect, TextInput, Textarea, Select
from crispy_forms.layout import Submit, Layout, Fieldset, Field, Div, HTML
from crispy_forms.bootstrap import Accordion, AccordionGroup
from tinymce.widgets import TinyMCE
from dal import autocomplete
from autocomplete import widgets as htmx_widgets, Autocomplete, AutocompleteWidget, ModelAutocomplete, register as autocomplete_register
import logging
from generic.forms import ExamAuthorFormMixin, ExamGroupsFormMixin
from crispy_forms.helper import FormHelper
from atlas.helpers import get_cases_available_to_user
from typing import Any
from helpers.cimar import CimarAPI, NotFoundError
from rad.settings import CIMAR_USERNAME, CIMAR_PASSWORD
class ClearableInput(TextInput):
template_name = "crispy_forms/widgets/clearable_input_single_line.html"
class ClearableTextarea(Textarea):
template_name = "crispy_forms/widgets/clearable_input.html"
class CaseSelect(Select):
template_name = "atlas/case_select_widget.html"
def create_option(self, *args, **kwargs):
option = super().create_option(*args, **kwargs)
return option
def get_context(self, name: str, value, attrs) -> dict[str, Any]:
context = super().get_context(name, value, attrs)
return context
pass
class ConditionForm(ModelForm):
class Meta:
model = Condition
exclude = ["rcr_curriculum"]
widgets = {
"synonym": autocomplete.ModelSelect2Multiple(
url="atlas:condition-autocomplete"
),
"parent": autocomplete.ModelSelect2Multiple(
url="atlas:condition-autocomplete"
),
"rcr_curriculum_map": autocomplete.ModelSelect2Multiple(
url="atlas:condition-autocomplete-rcr-curriculum"
),
}
class CaseCollectionForm(ModelForm):
class Meta:
model = CaseCollection
exclude = ["cases", "valid_cid_users", "valid_user_users", "author"]
def __init__(self, *args, **kwargs):
self.user = kwargs.pop(
"user"
) # To get request.user. Do not use kwargs.pop('user', None) due to potential security hole
if kwargs.get("instance"):
# We get the 'initial' keyword argument or initialize it
# as a dict if it didn't exist.
initial = kwargs.setdefault("initial", {})
# The widget for a ModelMultipleChoiceField expects
# a list of primary key for the selected data.
# initial["exams"] = [t.pk for t in kwargs["instance"].exams.all()]
ModelForm.__init__(self, *args, **kwargs)
super(CaseCollectionForm, self).__init__(*args, **kwargs)
def save(self, commit=True):
# Get the unsaved Case instance
instance = ModelForm.save(self, False)
# Do we need to save all changes now?
# if commit:
instance.save()
self.save_m2m()
return instance
class FindingForm(ModelForm):
class Meta:
model = Finding
exclude = []
widgets = {
"synonym": autocomplete.ModelSelect2Multiple(
url="atlas:finding-autocomplete"
),
}
class StructureForm(ModelForm):
class Meta:
model = Structure
exclude = []
widgets = {
"synonym": autocomplete.ModelSelect2Multiple(
url="atlas:structure-autocomplete"
),
}
class SeriesFindingForm(ModelForm):
class Meta:
model = SeriesFinding
exclude = ["series", "annotation_json", "viewport_json", "current_image_id_index", "annotation_json_3d", "viewer_state_3d"]
widgets = {
"findings": autocomplete.ModelSelect2Multiple(
url="atlas:finding-autocomplete"
),
"structures": autocomplete.ModelSelect2Multiple(
url="atlas:structure-autocomplete"
),
"conditions": autocomplete.ModelSelect2Multiple(
url="atlas:condition-autocomplete"
),
}
def __init__(self, *args, **kwargs):
if kwargs.get("series_id"):
# We get the 'initial' keyword argument or initialize it
# as a dict if it didn't exist.
initial = kwargs.setdefault("initial", {})
# The widget for a ModelMultipleChoiceField expects
# a list of primary key for the selected data.
initial["series"] = kwargs.pop("series_id")
# elif kwargs.get("instance"):
# # We get the 'initial' keyword argument or initialize it
# # as a dict if it didn't exist.
# initial = kwargs.setdefault("initial", {})
# # The widget for a ModelMultipleChoiceField expects
# # a list of primary key for the selected data.
# #initial["structures"] = [t.pk for t in kwargs["structures"].case.all()]
# #initial["structures"] = [t.pk for t in kwargs["structures"].case.all()]
super(SeriesFindingForm, self).__init__(*args, **kwargs)
ModelForm.__init__(self, *args, **kwargs)
class SeriesForm(ModelForm):
class Media:
# Django also includes a few javascript files necessary
# for the operation of this form element. You need to
# include <script src="/admin/jsi18n"></script>
# in the template.
css = {
"all": ["css/widgets.css"],
}
# Adding this javascript is crucial
js = ["jsi18n.js", "tesseract.min.js", "js/upload_form_helpers.js"]
def __init__(self, *args, **kwargs):
self.user = kwargs.pop(
"user"
) # To get request.user. Do not use kwargs.pop('user', None) due to potential security hole
if kwargs.get("instance"):
# We get the 'initial' keyword argument or initialize it
# as a dict if it didn't exist.
initial = kwargs.setdefault("initial", {})
# The widget for a ModelMultipleChoiceField expects
# a list of primary key for the selected data.
initial["case"] = [t.pk for t in kwargs["instance"].case.all()]
super(SeriesForm, self).__init__(*args, **kwargs)
# self.fields["examination"] = ModelChoiceField(
# queryset=Examination.objects.all(),
# widget=FilteredSelectMultiple(verbose_name="Examination", is_stacked=False),
# )
self.fields["modality"] = ModelChoiceField(
required=True,
queryset=Modality.objects.all(),
)
ModelForm.__init__(self, *args, **kwargs)
if self.user.groups.filter(name="atlas_editor").exists():
case_queryset = Case.objects.all()
else:
case_queryset = Case.objects.filter(
author__id=self.user.id
) # | Case.objects.filter(open_access=True)
self.fields["case"] = ModelMultipleChoiceField(
required=False,
queryset=case_queryset,
widget=FilteredSelectMultiple(verbose_name="Case", is_stacked=False),
)
def save(self, commit=True):
# Get the unsaved Long instance
instance = ModelForm.save(self, False)
# Prepare a 'save_m2m' method for the form,
old_save_m2m = self.save_m2m
def save_m2m():
old_save_m2m()
instance.case.clear()
for case in self.cleaned_data["case"]:
# We need the id here
instance.case.add(case.pk)
self.save_m2m = save_m2m
# Do we need to save all changes now?
# if commit:
instance.save()
self.save_m2m()
# instance.anonymise_images()
return instance
class Meta:
model = Series
exclude = ["author", "series_instance_uid"]
widgets = {
"examination": autocomplete.ModelSelect2(
url="generic:examination-autocomplete"
),
"description": Textarea(attrs={"maxlength": 1000, "rows": 5, "cols": 80}),
}
#def save(self, commit=True):
# # Get the unsaved Case instance
# instance = ModelForm.save(self, False)
# # Prepare a 'save_m2m' method for the form,
# old_save_m2m = self.save_m2m
# def save_m2m():
# old_save_m2m()
# # instance.exams.clear()
# # for exam in self.cleaned_data["exams"]:
# # # We need the id here
# # instance.exams.add(exam.pk)
# self.save_m2m = save_m2m
# # Do we need to save all changes now?
# # if commit:
# instance.save()
# self.save_m2m()
# return instance
class CaseForm(ModelForm):
class Media:
# Django also includes a few javascript files necessary
# for the operation of this form element. You need to
# include <script src="/admin/jsi18n"></script>
# in the template.
#history = forms.CharField(
# widget=ClearableTextarea(attrs={"maxlength": 1000, "rows": 5, "cols": 80}),
# required=False,
#)
css = {
"all": ["css/widgets.css"],
}
# Adding this javascript is crucial
js = ["jsi18n.js", "tesseract.min.js", "js/upload_form_helpers.js"]
def __init__(self, *args, **kwargs):
self.user = kwargs.pop(
"user"
) # To get request.user. Do not use kwargs.pop('user', None) due to potential security hole
# This is populated if we create the case from an exam/collection
self.collection = None
if kwargs["initial"] is not None and "exams" in kwargs["initial"]:
collections = kwargs["initial"].pop("exams")
logging.debug(collections)
self.collection = get_object_or_404(CaseCollection, pk=collections[0])
if kwargs.get("instance"):
# We get the 'initial' keyword argument or initialize it
# as a dict if it didn't exist.
initial = kwargs.setdefault("initial", {})
# The widget for a ModelMultipleChoiceField expects
# a list of primary key for the selected data.
# initial["exams"] = [t.pk for t in kwargs["instance"].exams.all()]
ModelForm.__init__(self, *args, **kwargs)
super(CaseForm, self).__init__(*args, **kwargs)
# self.fields["series"].queryset =
if self.user.groups.filter(name="atlas_editor").exists():
case_queryset = Case.objects.all().order_by("pk").prefetch_related(
)
else:
case_queryset = get_cases_available_to_user(self.user)
self.fields["previous_case"].queryset=case_queryset
self.helper = FormHelper()
self.helper.form_id = "id-case-form"
self.helper.form_class = "case-form"
self.helper.form_method = "post"
self.helper.form_action = "submit"
self.helper.form_tag = False
self.helper.layout = Layout(
Fieldset(
"Case details",
"title",
"subspecialty",
"description",
"history",
"presentation",
"discussion",
"report",
"condition",
"pathological_process",
"open_access",
"previous_case",
"diagnostic_certainty",
"cimar_uuid",
),
)
def get_queryset(self, request):
return (
super()
.get_queryset(request)
.prefetch_related(
"condition", "subspecialty", "pathological_process", "series"
)
)
class Meta:
model = Case
# fields = ['due_back']
# fields = '__all__'
fields = [
# "examination",
# "site",
"title",
"subspecialty",
"description",
"history",
"presentation",
"discussion",
"condition",
"pathological_process",
"report",
"open_access",
"previous_case",
"diagnostic_certainty",
"cimar_uuid"
]
# fields = ['question', 'findings', 'subspecialty', 'references']
widgets = {
# "normal": RadioSelect(
# choices=[(True, 'Yes'),
# (False, 'No')])
# "findings": TinyMCE(attrs={"cols": 80, "rows": 20}),
# "mark_scheme": TinyMCE(attrs={"cols": 80, "rows": 30}),
"title": ClearableInput(attrs={"rows": 1}),
"description": ClearableTextarea(attrs={"cols": 80, "rows": 5}),
"history": ClearableTextarea(attrs={"maxlength": 2000, "rows": 5}),
"discussion": ClearableTextarea(attrs={"maxlength": 2000, "rows": 5}),
"report": ClearableTextarea(attrs={"maxlength": 2000, "rows": 5}),
"condition": autocomplete.ModelSelect2Multiple(
url="atlas:condition-autocomplete"
),
"presentation": autocomplete.ModelSelect2Multiple(
url="atlas:presentation-autocomplete"
),
"subspecialty": CheckboxSelectMultiple(),
"pathological_process": CheckboxSelectMultiple(),
"previous_case": CaseSelect(),
}
def clean_cimar_uuid(self):
cimar_uuid = self.cleaned_data["cimar_uuid"]
if cimar_uuid:
with CimarAPI(username=CIMAR_USERNAME, password=CIMAR_PASSWORD) as api:
try:
study = api.get_study_by_uuid(cimar_uuid)
except NotFoundError:
raise ValidationError("Study not found in CIMAR")
return cimar_uuid
def save(self, commit=True):
# Get the unsaved Case instance
instance = ModelForm.save(self, False)
# Prepare a 'save_m2m' method for the form,
old_save_m2m = self.save_m2m
def save_m2m():
old_save_m2m()
# instance.exams.clear()
# for exam in self.cleaned_data["exams"]:
# # We need the id here
# instance.exams.add(exam.pk)
self.save_m2m = save_m2m
# Do we need to save all changes now?
# if commit:
instance.save()
self.save_m2m()
logging.debug(f"{self.collection=}")
if self.collection is not None:
logging.debug(f"{self.collection=}")
case_no = self.collection.cases.count() + 1
logging.debug(f"{case_no=}")
logging.debug(f"{instance=}")
# Create through model
#cd = CaseDetail(case=instance, collection=exam, sort_order=case_no)
self.collection.cases.add(instance, through_defaults={"sort_order": case_no})
return instance
CaseDifferentialFormSet = inlineformset_factory(
Case,
Differential,
exclude=[],
can_delete=True,
extra=1,
max_num=10,
widgets={
"condition": autocomplete.ModelSelect2(url="atlas:condition-autocomplete"),
"text": Textarea(attrs={"maxlength": 1000, "rows": 3, "cols": 80}),
},
)
class ResourceForm(ModelForm):
class Meta:
model = Resource
exclude = ["author"]
widgets = {
"description": Textarea(attrs={"cols": 80, "rows": 5}),
"url": TextInput(attrs={"cols": 80, "rows": 1}),
}
class CaseResourceForm(ModelForm):
def __init__(self, *args, user, **kwargs):
super(CaseResourceForm, self).__init__(*args, **kwargs)
if not user.groups.filter(name="atlas_editor").exists():
queryset = Resource.objects.filter(author__id=user.id)
else:
queryset = Resource.objects.all()
self.fields["resource"] = ModelChoiceField(
required=False,
queryset=queryset,
# widget=Select(verbose_name="Series", is_stacked=False),
)
self.fields["pre_review"] = BooleanField(required=False)
#class CaseSeriesForm(ModelForm):
#
# def __init__(self, *args, user, **kwargs):
# super(CaseSeriesForm, self).__init__(*args, **kwargs)
#
# if not user.groups.filter(name="atlas_editor").exists():
# queryset = Series.objects.filter(author__id=user.id)
# else:
# queryset = Series.objects.all()
#
# # Optimize the queryset for the ModelChoiceField
# queryset = queryset.select_related(
# "modality"
# ).prefetch_related(
# "examination", "plane", "contrast", "images"
# )
#
# self.fields["series"] = ModelChoiceField(
# required=False,
# queryset=queryset,
# # widget=Select(verbose_name="Series", is_stacked=False),
# )
class CaseCollectionCaseForm(ModelForm):
def __init__(self, *args, user, collection=None, **kwargs):
super(CaseCollectionCaseForm, self).__init__(*args, **kwargs)
queryset = get_cases_available_to_user(user, collection=collection)
self.fields["case"] = ModelChoiceField(
required=False,
queryset=queryset,
# widget=Select(verbose_name="Series", is_stacked=False),
)
#SeriesFormSet = inlineformset_factory(
# Case,
# Series.case.through,
# form=CaseSeriesForm,
# exclude=[],
# can_delete=True,
# extra=0,
# max_num=10,
#)
CaseCollectionCaseFormSet = inlineformset_factory(
CaseCollection,
Case.casecollection_set.through,
form=CaseCollectionCaseForm,
exclude=["question_schema", "question_answers"],
can_delete=True,
extra=0,
max_num=50,
)
CaseResourceFormSet = inlineformset_factory(
Case,
Resource.case_set.through,
form=CaseResourceForm,
exclude=[],
can_delete=True,
extra=1,
max_num=10,
)
SeriesImageFormSet = inlineformset_factory(
Series,
SeriesImage,
exclude=["dicom_tags_ohif", "replaced", "image_md5_hash", "image_blake3_hash", "is_dicom"],
can_delete=True,
extra=0,
max_num=2000,
)
class JsonAnswerForm(Form):
json_answer = JSONSchemaField(
schema = {},
#options = 'schema/options.json'
options = 'schema/options.json'
)
class Meta:
fields = ["json_answer"]
def __init__(self, *args, question_schema=None, **kwargs):
super(JsonAnswerForm, self).__init__(*args, **kwargs)
if question_schema is not None:
self.fields["json_answer"] = JSONSchemaField(schema=question_schema, options='schema/options.json')
self.fields["json_answer"].label = False
class BaseReportAnswerForm(ModelForm):
class Meta:
fields = ["answer"]
widgets = {
# "normal": RadioSelect(
# choices=[(True, 'Yes'),
# (False, 'No')])
# "findings": TinyMCE(attrs={"cols": 80, "rows": 20}),
# "mark_scheme": TinyMCE(attrs={"cols": 80, "rows": 30}),
"answer": Textarea(attrs={"cols": 100, "rows": 5, "placeholder":"Report text"}),
}
# help_texts = {
# "answer": "Write your answer in here."
# }
def __init__(self, *args, case_detail, **kwargs):
super(BaseReportAnswerForm, self).__init__(*args, **kwargs)
self.fields["answer"].required = False
class BaseQuestionAnswerForm(ModelForm):
json_answer = JSONSchemaField(
schema = {},
options = 'schema/options.json'
)
class Meta:
fields = ["json_answer"]
labels = {"json_answer": ""}
# help_texts = {
# "answer": "Write your answer in here."
# }
def __init__(self, *args, case_detail, **kwargs):
super(BaseQuestionAnswerForm, self).__init__(*args, **kwargs)
#self.fields["json_answer"].schema = case_detail.question_schema
if case_detail.question_schema is not None:
self.fields["json_answer"] = JSONSchemaField(schema=case_detail.question_schema, options="schema/options.json")
self.fields["json_answer"].label = ""
class CidReportAnswerForm(BaseReportAnswerForm):
class Meta(BaseReportAnswerForm.Meta):
model = CidReportAnswer
class UserReportAnswerForm(BaseReportAnswerForm):
class Meta(BaseReportAnswerForm.Meta):
model = UserReportAnswer
class CidQuestionAnswerForm(BaseQuestionAnswerForm):
class Meta(BaseQuestionAnswerForm.Meta):
model = CidReportAnswer
class UserQuestionAnswerForm(BaseQuestionAnswerForm):
class Meta(BaseQuestionAnswerForm.Meta):
model = UserReportAnswer
class CidReportAnswerMarkForm(ModelForm):
class Meta:
model = CidReportAnswer
fields = ["score", "feedback"]
widgets = {
# "normal": RadioSelect(
# choices=[(True, 'Yes'),
# (False, 'No')])
# "findings": TinyMCE(attrs={"cols": 80, "rows": 20}),
# "mark_scheme": TinyMCE(attrs={"cols": 80, "rows": 30}),
"feedback": Textarea(attrs={"cols": 80, "rows": 4}),
}
def __init__(self, *args, **kwargs):
super(CidReportAnswerMarkForm, self).__init__(*args, **kwargs)
self.fields["score"].required = False
#class AddCollectionToCaseForm(Form):
#
# def __init__(self, *args, user, **kwargs):
# super(AddCollectionToCaseForm, self).__init__(*args, **kwargs)
#
# if not user.groups.filter(name="atlas_editor").exists():
# queryset = CaseCollection.objects.filter(author__id=user.id)
# else:
# queryset = CaseCollection.objects.all()
#
# self.valid_collections = queryset
# self.case = get_object_or_404(Case, pk=pk)
#
# self.fields["casecollection"] = ModelMultipleChoiceField(
# required=False,
# queryset=queryset,
# # widget=Select(verbose_name="Series", is_stacked=False),
# )
#
# def save(self, *args, **kwargs):
# print("SAVE", args, kwargs)
# instance = super(AddCollectionToCaseForm, self).save(*args, **kwargs)
#
# # Here we save the modified project selection back into the database
# instance.casecollection_set.set(self.cleaned_data['casecollection'])
#
# print(f"{instance=}")
#
# return instance
#
# def clean_casecollection(self):
# collection_set = self.cleaned_data["casecollection"]
#
# print(f"{collection_set=}")
#
# for col in collection_set:
# if col not in self.valid_collections:
# raise ValidationError("Invalid collection")
#
# return collection_set
class AddCollectionToCaseForm(Form):
def __init__(self, *args, user, **kwargs):
super(AddCollectionToCaseForm, self).__init__(*args, **kwargs)
if not user.groups.filter(name="atlas_editor").exists():
queryset = CaseCollection.objects.filter(author__id=user.id)
else:
queryset = CaseCollection.objects.all()
self.valid_collections = queryset
self.fields["casecollection"] = ModelMultipleChoiceField(
required=False,
queryset=queryset,
# widget=Select(verbose_name="Series", is_stacked=False),
)
def save(self, *args, **kwargs):
instance = super(AddCollectionToCaseForm, self).save(*args, **kwargs)
# Here we save the modified project selection back into the database
instance.casecollection_set.set(self.cleaned_data['casecollection'])
return instance
def clean_casecollection(self):
collection_set = self.cleaned_data["casecollection"]
for col in collection_set:
if col not in self.valid_collections:
raise ValidationError("Invalid collection")
return collection_set
class SelfReviewForm(ModelForm):
class Meta:
model = SelfReview
fields = ["user_exam", "case", "comments", "findings", "interpretation"]
widgets = {"user_exam": HiddenInput(), "case": HiddenInput()}
def __init__(self, *args, **kwargs):
if "user_exam_id" in kwargs:
user_exam_id = kwargs.pop("user_exam_id")
if "case_id" in kwargs:
case_id = kwargs.pop("case_id")
ModelForm.__init__(self, *args, **kwargs)
super(SelfReviewForm, self).__init__(*args, **kwargs)
class UncategorisedDicomForm(ModelForm):
class Meta:
model = UncategorisedDicom
fields = ["image"]#, "user"]
#UncategorisedDicomFormset = formset_factory(UncategorisedDicomForm)
#class ConditionAutocompleteFormModel(forms.ModelForm):
# class Meta:
# model = Condition
# fields = ["name"]
# widgets = {
# 'members': widgets.Autocomplete(
# name='members',
# options=dict(multiselect=True, model=Condition)
# )
# }
class ConditionAutocomplete(ModelAutocomplete):
model = Condition
search_attrs = ["name"]
class ConditionAutocompleteForm(Form):
condition = ModelChoiceField(queryset=Condition.objects.all(), widget=AutocompleteWidget(
ac_class=ConditionAutocomplete#, options=dict(model=Condition)
))
autocomplete_register(ConditionAutocomplete)
class CaseCollectionAuthorForm(ExamAuthorFormMixin):
class Meta(ExamAuthorFormMixin.Meta):
model = CaseCollection
class CaseAuthorForm(ExamAuthorFormMixin):
class Meta(ExamAuthorFormMixin.Meta):
model = Case
class SeriesAuthorForm(ExamAuthorFormMixin):
class Meta(ExamAuthorFormMixin.Meta):
model = Series
class ExamGroupsForm(ExamGroupsFormMixin):
class Meta(ExamGroupsFormMixin.Meta):
model = CaseCollection
class AnswerJSONForm(Form):
json = JSONSchemaField(
schema = 'schema/schema.json',
options = 'schema/options.json'
)
class SvelteJSONEditorWidgetOverride(SvelteJSONEditorWidget):
template_name = "atlas/svelte_jsoneditor_widget_override.html"
class CaseDetailForm(ModelForm):
class Meta:
model = CaseDetail
fields = ["question_schema", "question_answers"]#, "user"]
widgets = {
"question_schema": SvelteJSONEditorWidgetOverride(),
"question_answers": SvelteJSONEditorWidgetOverride(),
}
class QuestionSchemaForm(ModelForm):
class Meta:
model = QuestionSchema
fields = ["name", "description", "schema"]
widgets = {
"schema": SvelteJSONEditorWidgetOverride(),
}
#class ModelPriorCaseForm(ModelForm):
# class Meta:
# model = CasePrior
# fields = ["case_detail", "prior_case", "relation_text", "prior_visibility"]
class PriorCaseForm(Form):
relation = CharField(max_length=255, required=True)
prior_visibility = CharField(max_length=2, required=True)
#def __init__(self, *args, **kwargs):
# self.case_detail = kwargs.pop(
# "case_detail"
# ) # To get request.user. Do not use kwargs.pop('user', None) due to potential security hole
# super(PriorCaseForm, self).__init__(*args, **kwargs)
# prior_cases = self.case_detail.case.get_all_prior_cases()
# if not prior_cases:
# prior_cases = Case.objects.none()
# self.fields["case"] = ChoiceField(
# required=False,
# # widget=Select(verbose_name="Series", is_stacked=False),
# )
class CaseSeriesForm(forms.ModelForm):
def __init__(self, *args, queryset, user=None, is_atlas_editor=False, **kwargs):
super().__init__(*args, **kwargs)
self.fields["series"].queryset = queryset
class Meta:
model = SeriesDetail # through model for Case.series
fields = ["series", "sort_order", "feedback"]
class CaseUpdateSeriesForm(forms.ModelForm):
def __init__(self, *args, **kwargs):
self.user = kwargs.pop("user")
super().__init__(*args, **kwargs)
self.helper = FormHelper()
self.helper.form_id = "id-case-form"
self.helper.form_class = "case-form"
self.helper.form_method = "post"
self.helper.form_action = "submit"
self.helper.form_tag = False
self.helper.layout = Layout()
class Meta:
model = Case
fields = [] # No fields, just for compatibility with UpdateView
class BaseSeriesFormSet(BaseInlineFormSet):
def __init__(self, *args, queryset=None, **kwargs):
self.series_queryset = queryset
super().__init__(*args, **kwargs)
def get_form_kwargs(self, index):
kwargs = super().get_form_kwargs(index)
kwargs['queryset'] = self.series_queryset
return kwargs
SeriesFormSet = inlineformset_factory(
Case,
SeriesDetail,
form=CaseSeriesForm,
formset=BaseSeriesFormSet,
extra=1,
can_delete=True,
)
class CaseDisplaySetForm(forms.ModelForm):
class Meta:
model = CaseDisplaySet
fields = [
"name",
"description",
"findings",
"structures",
"conditions",
]
widgets = {
"name": forms.TextInput(attrs={"class": "form-control", "placeholder": "Display Set Name"}),
"description": forms.Textarea(attrs={"class": "form-control", "rows": 3, "placeholder": "Description"}),
"findings": autocomplete.ModelSelect2Multiple(
url="atlas:finding-autocomplete"
),
"structures": autocomplete.ModelSelect2Multiple(
url="atlas:structure-autocomplete"
),
"conditions": autocomplete.ModelSelect2Multiple(
url="atlas:condition-autocomplete"
),
}
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# Optionally, you can filter queryset for findings/structures/conditions here if needed
Reference in New Issue View Git Blame Copy Permalink