class StudyPopulationForm(forms.ModelForm):
inclusion_criteria = selectable.AutoCompleteSelectMultipleField(
lookup_class=lookups.StudyCriteriaLookup, required=False)
exclusion_criteria = selectable.AutoCompleteSelectMultipleField(
lookup_class=lookups.StudyCriteriaLookup, required=False)
confounding_criteria = selectable.AutoCompleteSelectMultipleField(
lookup_class=lookups.StudyCriteriaLookup, required=False)
class Meta:
fields = ('name', 'design', 'country', 'region', 'state', 'sex',
'ethnicity', 'fraction_male', 'fraction_male_calculated',
'n', 'starting_n', 'age_mean', 'age_mean_type',
'age_calculated', 'age_description', 'age_sd', 'age_sd_type',
'age_lower', 'age_lower_type', 'age_upper', 'age_upper_type',
'inclusion_criteria', 'exclusion_criteria',
'confounding_criteria')
model = models.StudyPopulation
exclude = ('study', )
def __init__(self, *args, **kwargs):
study = kwargs.pop('parent', None)
super(StudyPopulationForm, self).__init__(*args, **kwargs)
self.fields['region'].widget = selectable.AutoCompleteWidget(
lookup_class=lookups.RegionLookup, allow_new=True)
self.fields['state'].widget = selectable.AutoCompleteWidget(
lookup_class=lookups.StateLookup, allow_new=True)
for fld in self.fields.keys():
widget = self.fields[fld].widget
if type(widget) != CheckboxInput:
widget.attrs['class'] = 'span12'
if study:
self.instance.study = study
class MetaProtocolForm(forms.ModelForm):
inclusion_criteria = selectable.AutoCompleteSelectMultipleField(
lookup_class=lookups.StudyCriteriaLookup, required=False)
exclusion_criteria = selectable.AutoCompleteSelectMultipleField(
lookup_class=lookups.StudyCriteriaLookup, required=False)
class Meta:
model = models.MetaProtocol
exclude = ('study', )
def __init__(self, *args, **kwargs):
parent = kwargs.pop('parent', None)
super(MetaProtocolForm, self).__init__(*args, **kwargs)
for fld in self.fields.keys():
if fld in ('lit_search_notes', 'notes'):
self.fields[fld].widget.attrs['rows'] = 3
widget = self.fields[fld].widget
if type(widget) != CheckboxInput:
widget.attrs['class'] = 'span12'
if parent:
self.instance.study = parent
self.fields['inclusion_criteria'].widget.update_query_parameters(
{'related': self.instance.study.assessment_id})
self.fields['exclusion_criteria'].widget.update_query_parameters(
{'related': self.instance.study.assessment_id})
class ProductionAdminForm(ModelForm):
theater_companies = selectable_forms.AutoCompleteSelectMultipleField(
lookup_class=TheaterCompanyLookup,
required=False,
label=_(u"Theater companies"))
def __init__(self, *args, **kwargs):
super(ProductionAdminForm, self).__init__(*args, **kwargs)
if self.instance and self.instance.pk:
if self.instance.venue:
self.initial['venue'] = self.instance.venue.pk
corporate_creator = Creator.objects.filter(creator_type='corp',
org_name__isnull=False)
self.fields['theater_companies'].widget.update_query_parameters(
{'theater_companies': corporate_creator})
class Meta(object):
model = Production
widgets = \
{'source_work':
selectable_forms.AutoCompleteSelectMultipleWidget(
lookup_class=WorkRecordLookup, attrs={'size':'100'}),
'venue':selectable_forms.AutoCompleteSelectWidget(
lookup_class=LocationLookup, attrs={'size':'100'}),
'primary_publications': \
selectable_forms.AutoCompleteSelectMultipleWidget(
lookup_class=PublicationLookup, attrs={'size':'100'}),
'secondary_publications': \
selectable_forms.AutoCompleteSelectMultipleWidget(
lookup_class=PublicationLookup, attrs={'size':'100'}),}
class MetaResultForm(forms.ModelForm):
adjustment_factors = selectable.AutoCompleteSelectMultipleField(
help_text="All factors which were included in final model",
lookup_class=lookups.FactorLookup,
required=False)
class Meta:
model = models.MetaResult
exclude = ('protocol', )
def __init__(self, *args, **kwargs):
parent = kwargs.pop('parent', None)
super(MetaResultForm, self).__init__(*args, **kwargs)
self.fields['health_outcome'].widget = selectable.AutoCompleteWidget(
lookup_class=lookups.MetaResultHealthOutcomeLookup, allow_new=True)
self.fields['exposure_name'].widget = selectable.AutoCompleteWidget(
lookup_class=lookups.MetaResultExposureNameLookup, allow_new=True)
for fld in self.fields.keys():
widget = self.fields[fld].widget
if fld in ('health_outcome_notes', 'statistical_notes', 'notes',
'exposure_details'):
self.fields[fld].widget.attrs['rows'] = 3
if type(widget) != CheckboxInput:
widget.attrs['class'] = 'span12'
if parent:
self.instance.protocol = parent
class FruitForm(forms.Form):
autocomplete = forms.CharField(
label='Type the name of a fruit (AutoCompleteWidget)',
widget=selectable.AutoCompleteWidget(FruitLookup),
required=False,
)
newautocomplete = forms.CharField(
label='Type the name of a fruit (AutoCompleteWidget which allows new items)',
widget=selectable.AutoCompleteWidget(FruitLookup, allow_new=True),
required=False,
)
combobox = forms.CharField(
label='Type/select the name of a fruit (AutoComboboxWidget)',
widget=selectable.AutoComboboxWidget(FruitLookup),
required=False,
)
newcombobox = forms.CharField(
label='Type/select the name of a fruit (AutoComboboxWidget which allows new items)',
widget=selectable.AutoComboboxWidget(FruitLookup, allow_new=True),
required=False,
)
# AutoCompleteSelectField (no new items)
autocompleteselect = selectable.AutoCompleteSelectField(
lookup_class=FruitLookup,
label='Select a fruit (AutoCompleteField)',
required=False,
)
# AutoCompleteSelectField (allows new items)
newautocompleteselect = selectable.AutoCompleteSelectField(
lookup_class=FruitLookup,
allow_new=True,
label='Select a fruit (AutoCompleteField which allows new items)',
required=False,
)
# AutoComboboxSelectField (no new items)
comboboxselect = selectable.AutoComboboxSelectField(
lookup_class=FruitLookup,
label='Select a fruit (AutoComboboxSelectField)',
required=False,
)
# AutoComboboxSelectField (allows new items)
newcomboboxselect = selectable.AutoComboboxSelectField(
lookup_class=FruitLookup,
allow_new=True,
label='Select a fruit (AutoComboboxSelectField which allows new items)',
required=False,
)
# AutoCompleteSelectMultipleField
multiautocompleteselect = selectable.AutoCompleteSelectMultipleField(
lookup_class=FruitLookup,
label='Select a fruit (AutoCompleteSelectMultipleField)',
required=False,
)
# AutoComboboxSelectMultipleField
multicomboboxselect = selectable.AutoComboboxSelectMultipleField(
lookup_class=FruitLookup,
label='Select a fruit (AutoComboboxSelectMultipleField)',
required=False,
)
def __init__(self, *args, **kwargs):
super(EndpointAggregationForm, self).__init__(*args, **kwargs)
self.fields["endpoints"] = selectable.AutoCompleteSelectMultipleField(
lookup_class=EndpointByAssessmentLookup,
label='Endpoints',
widget=selectable.AutoCompleteSelectMultipleWidget)
self.fields["endpoints"].widget.update_query_parameters(
{'assessment_id': self.instance.assessment_id})
self.helper = self.setHelper()
class AssessedOutcomeForm(forms.ModelForm):
adjustment_factors = selectable.AutoCompleteSelectMultipleField(
help_text="All factors which were included in final model",
lookup_class=lookups.FactorLookup,
required=False)
confounders_considered = selectable.AutoCompleteSelectMultipleField(
label="Adjustment factors considered",
help_text=
"All factors which were examined (including those which were included in final model)",
lookup_class=lookups.FactorLookup,
required=False)
effects = selectable.AutoCompleteSelectMultipleField(
lookup_class=EffectTagLookup,
required=False,
help_text="Tags used to help categorize effect description.")
class Meta:
model = models.AssessedOutcome
exclude = ('assessment', 'exposure')
def __init__(self, *args, **kwargs):
assessment = kwargs.pop('assessment', None)
exposure = kwargs.pop('parent', None)
super(AssessedOutcomeForm, self).__init__(*args, **kwargs)
self.fields['name'].widget = selectable.AutoCompleteWidget(
lookup_class=BaseEndpointLookup, allow_new=True)
if assessment:
self.instance.assessment = assessment
if exposure:
self.instance.exposure = exposure
self.fields['main_finding'].queryset = \
self.fields['main_finding'].queryset.filter(
exposure=self.instance.exposure)
for fld in self.fields.keys():
self.fields[fld].widget.attrs['class'] = 'span12'
for fld in ('diagnostic_description', 'summary',
'prevalence_incidence', 'statistical_power_details',
'dose_response_details', 'statistical_metric_description'):
self.fields[fld].widget.attrs['rows'] = 3
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields["endpoints"] = selectable.AutoCompleteSelectMultipleField(
lookup_class=EndpointByAssessmentLookupHtml,
label="Endpoints",
widget=EndpointAggregationSelectMultipleWidget,
)
self.fields["endpoints"].widget.update_query_parameters(
{"related": self.instance.assessment_id})
self.helper = self.setHelper()
self.helper.attrs["novalidate"] = ""
class ProjectFiltersForm(forms.Form):
TRUNC_CHOICES = [
('day', 'Day'),
('week', 'Week'),
('month', 'Month'),
]
DEFAULT_TRUNC = TRUNC_CHOICES[2][0]
billable = forms.BooleanField(initial=True, required=False)
non_billable = forms.BooleanField(label='Non-Billable',
initial=True,
required=False)
paid_leave = forms.BooleanField(initial=True, required=False)
trunc = forms.ChoiceField(label='Group Totals By:',
choices=TRUNC_CHOICES,
widget=forms.RadioSelect(),
required=False,
initial=DEFAULT_TRUNC)
pj_select = selectable_forms.AutoCompleteSelectMultipleField(
ProjectLookup, label='Project Name:', required=False)
def clean_trunc(self):
trunc = self.cleaned_data.get('trunc', '')
if not trunc:
trunc = self.DEFAULT_TRUNC
return trunc
def get_hour_type(self):
try:
billable = self.cleaned_data.get('billable', False)
non_billable = self.cleaned_data.get('non_billable', False)
except AttributeError:
return 'total'
if billable and non_billable:
return 'total'
elif billable:
return 'billable'
elif non_billable:
return 'non_billable'
return 'nothing'
class HourlyReportForm(DateForm):
TRUNC_CHOICES = (
('day', 'Day'),
('week', 'Week'),
('month', 'Month'),
('year', 'Year'),
)
billable = forms.BooleanField(required=False)
non_billable = forms.BooleanField(label='Non-billable', required=False)
paid_leave = forms.BooleanField(required=False)
trunc = forms.ChoiceField(label='Group Totals By',
choices=TRUNC_CHOICES,
widget=forms.RadioSelect())
projects = selectable.AutoCompleteSelectMultipleField(ProjectLookup,
label='Project Name',
required=False)
def __init__(self, *args, **kwargs):
super(HourlyReportForm, self).__init__(*args, **kwargs)
self.fields['from_date'].required = True
self.fields['to_date'].required = True
class OutcomeFilterForm(forms.Form):
ORDER_BY_CHOICES = (
('study_population__study__short_citation', 'study'),
('study_population__name', 'study population'),
('name', 'outcome name'),
('system', 'system'),
('effect', 'effect'),
('diagnostic', 'diagnostic'),
)
studies = selectable.AutoCompleteSelectMultipleField(
label='Study reference',
lookup_class=EpiStudyLookup,
help_text="ex: Smith et al. 2010",
required=False)
name = forms.CharField(label='Outcome name',
widget=selectable.AutoCompleteWidget(
lookups.OutcomeLookup),
help_text="ex: blood, glucose",
required=False)
study_population = forms.CharField(
label='Study population',
widget=selectable.AutoCompleteWidget(
lookups.StudyPopulationByAssessmentLookup),
help_text="ex: population near a Teflon manufacturing plant",
required=False)
metric = forms.CharField(label='Measurement metric',
widget=selectable.AutoCompleteWidget(
lookups.RelatedExposureMetricLookup),
help_text="ex: drinking water",
required=False)
age_profile = forms.CharField(
label='Age profile',
widget=selectable.AutoCompleteWidget(
lookups.RelatedStudyPopulationAgeProfileLookup),
help_text="ex: children",
required=False)
source = forms.CharField(label='Study population source',
widget=selectable.AutoCompleteWidget(
lookups.RelatedStudyPopulationSourceLookup),
help_text="ex: occupational exposure",
required=False)
country = forms.CharField(label='Study population country',
widget=selectable.AutoCompleteWidget(
lookups.RelatedCountryNameLookup),
help_text="ex: Japan",
required=False)
design = forms.MultipleChoiceField(
label='Study design',
choices=models.StudyPopulation.DESIGN_CHOICES,
widget=forms.CheckboxSelectMultiple,
initial=[c[0] for c in models.StudyPopulation.DESIGN_CHOICES],
required=False)
system = forms.CharField(label='System',
widget=selectable.AutoCompleteWidget(
lookups.RelatedSystemLookup),
help_text="ex: immune and lymphatic system",
required=False)
effect = forms.CharField(label='Effect',
widget=selectable.AutoCompleteWidget(
lookups.RelatedEffectLookup),
help_text="ex: Cancer",
required=False)
effect_subtype = forms.CharField(label='Effect subtype',
widget=selectable.AutoCompleteWidget(
lookups.RelatedEffectSubtypeLookup),
help_text="ex: Melanoma",
required=False)
diagnostic = forms.MultipleChoiceField(
choices=models.Outcome.DIAGNOSTIC_CHOICES,
widget=forms.CheckboxSelectMultiple,
initial=[c[0] for c in models.Outcome.DIAGNOSTIC_CHOICES],
required=False)
order_by = forms.ChoiceField(choices=ORDER_BY_CHOICES, )
paginate_by = forms.IntegerField(label='Items per page',
min_value=1,
initial=25,
max_value=10000,
required=False)
def __init__(self, *args, **kwargs):
assessment_id = kwargs.pop('assessment_id')
super().__init__(*args, **kwargs)
for field in self.fields:
if field not in ('design', 'diagnostic', 'order_by',
'paginate_by'):
self.fields[field].widget.update_query_parameters(
{'related': assessment_id})
self.helper = self.setHelper()
def setHelper(self):
# by default take-up the whole row-fluid
for fld in list(self.fields.keys()):
widget = self.fields[fld].widget
if type(widget) not in [
forms.CheckboxInput, forms.CheckboxSelectMultiple
]:
widget.attrs['class'] = 'span12'
helper = BaseFormHelper(self)
helper.form_method = "GET"
helper.form_class = None
helper.add_fluid_row('studies', 4, "span3")
helper.add_fluid_row('age_profile', 4, "span3")
helper.add_fluid_row('system', 4, "span3")
helper.layout.append(
cfb.FormActions(cfl.Submit('submit', 'Apply filters'), ))
return helper
def get_query(self):
studies = self.cleaned_data.get('studies')
name = self.cleaned_data.get('name')
study_population = self.cleaned_data.get('study_population')
metric = self.cleaned_data.get('metric')
age_profile = self.cleaned_data.get('age_profile')
source = self.cleaned_data.get('source')
country = self.cleaned_data.get('country')
design = self.cleaned_data.get('design')
system = self.cleaned_data.get('system')
effect = self.cleaned_data.get('effect')
effect_subtype = self.cleaned_data.get('effect_subtype')
diagnostic = self.cleaned_data.get('diagnostic')
query = Q()
if studies:
query &= Q(study_population__study__in=studies)
if name:
query &= Q(name__icontains=name)
if study_population:
query &= Q(study_population__name__icontains=study_population)
if metric:
query &= Q(study_population__exposures__metric__icontains=metric)
if age_profile:
query &= Q(study_population__age_profile__icontains=age_profile)
if source:
query &= Q(study_population__source__icontains=source)
if country:
query &= Q(study_population__country__name__icontains=country)
if design:
query &= Q(study_population__design__in=design)
if system:
query &= Q(system__icontains=system)
if effect:
query &= Q(effect__icontains=effect)
if effect_subtype:
query &= Q(effect_subtype__icontains=effect_subtype)
if diagnostic:
query &= Q(diagnostic__in=diagnostic)
return query
def get_order_by(self):
return self.cleaned_data.get('order_by', self.ORDER_BY_CHOICES[0][0])
class ResultForm(forms.ModelForm):
HELP_TEXT_CREATE = """Describe results found for measured outcome."""
HELP_TEXT_UPDATE = """Update results found for measured outcome."""
ADJUSTMENT_FIELDS = ["factors_applied", "factors_considered"]
factors_applied = selectable.AutoCompleteSelectMultipleField(
help_text="All adjustment factors included in final statistical model",
lookup_class=lookups.AdjustmentFactorLookup,
required=False)
factors_considered = selectable.AutoCompleteSelectMultipleField(
label="Adjustment factors considered",
help_text=models.OPTIONAL_NOTE,
lookup_class=lookups.AdjustmentFactorLookup,
required=False)
class Meta:
model = models.Result
exclude = ('outcome', 'adjustment_factors')
def __init__(self, *args, **kwargs):
outcome = kwargs.pop('parent', None)
super().__init__(*args, **kwargs)
self.fields['comments'] = self.fields.pop('comments') # move to end
self.fields[
'resulttags'].widget = selectable.AutoCompleteSelectMultipleWidget(
lookup_class=EffectTagLookup)
if outcome:
self.instance.outcome = outcome
else:
outcome = self.instance.outcome
self.fields["comparison_set"].queryset = models.ComparisonSet.objects\
.filter(
Q(study_population=outcome.study_population) |
Q(outcome=outcome)
)
for fld in self.ADJUSTMENT_FIELDS:
self.fields[fld].widget.update_query_parameters(
{'related': self.instance.outcome.assessment_id})
if self.instance.id:
self.fields[fld].initial = getattr(self.instance, fld)
self.helper = self.setHelper()
def save_factors(self):
"""
Adjustment factors is a through model; requires the inclusion type.
We save the m2m relations using the additional information from the
field-name
"""
self.instance.resfactors.all().delete()
objs = []
applied = self.cleaned_data.get("factors_applied", [])
objs.extend([
models.ResultAdjustmentFactor(adjustment_factor=af,
result=self.instance,
included_in_final_model=True)
for af in applied
])
considered = self.cleaned_data.get("factors_considered", [])
considered = set(considered) - set(applied)
objs.extend([
models.ResultAdjustmentFactor(adjustment_factor=af,
result=self.instance,
included_in_final_model=False)
for af in considered
])
models.ResultAdjustmentFactor.objects.bulk_create(objs)
def save(self, commit=True):
instance = super().save(commit)
if commit:
self.save_factors()
return instance
def setHelper(self):
for fld in list(self.fields.keys()):
widget = self.fields[fld].widget
if type(widget) != forms.CheckboxInput:
if fld in self.ADJUSTMENT_FIELDS or fld == "resulttags":
widget.attrs['class'] = 'span10'
else:
widget.attrs['class'] = 'span12'
if type(widget) == forms.Textarea:
widget.attrs['rows'] = 3
if self.instance.id:
inputs = {
"legend_text": "Update {}".format(self.instance),
"help_text": self.HELP_TEXT_UPDATE,
"cancel_url": self.instance.get_absolute_url()
}
else:
inputs = {
"legend_text": "Create new set of results",
"help_text": self.HELP_TEXT_CREATE,
"cancel_url": self.instance.outcome.get_absolute_url()
}
helper = BaseFormHelper(self, **inputs)
helper.form_class = None
helper.add_fluid_row('name', 2, "span6")
helper.add_fluid_row('metric', 3, "span4")
helper.add_fluid_row('data_location', 2, "span6")
helper.add_fluid_row('dose_response', 3, "span4")
helper.add_fluid_row('statistical_power', 4, "span3")
helper.add_fluid_row('factors_applied', 2, "span6")
helper.add_fluid_row('estimate_type', 3, "span4")
helper.add_fluid_row("resulttags", 1, "span6")
url = reverse('assessment:effect_tag_create',
kwargs={'pk': self.instance.outcome.assessment_id})
helper.addBtnLayout(helper.layout[8], 0, url, "Add new result tag",
"span6")
url = reverse('epi:adjustmentfactor_create',
kwargs={'pk': self.instance.outcome.assessment_id})
# remove magic number 9; breaks if we change number of elements in the form. This still isn't great; what if comments went away?
btn_target_idx = helper.find_layout_idx_for_field_name('comments') - 1
helper.addBtnLayout(helper.layout[btn_target_idx], 0, url,
"Add new adjustment factor", "span6")
helper.addBtnLayout(helper.layout[btn_target_idx], 1, url,
"Add new adjustment factor", "span6")
return helper
class MetaResultFilterForm(forms.Form):
ORDER_BY_CHOICES = (
("protocol__study__short_citation", "study"),
("label", "meta result label"),
("protocol__name", "protocol"),
("health_outcome", "health outcome"),
("exposure", "exposure"),
)
studies = selectable.AutoCompleteSelectMultipleField(
label="Study reference",
lookup_class=EpimetaStudyLookup,
help_text="ex: Smith et al. 2010",
required=False,
)
label = forms.CharField(
label="Meta result label",
widget=selectable.AutoCompleteWidget(
lookups.MetaResultByAssessmentLookup),
help_text="ex: ALL, folic acid, any time",
required=False,
)
protocol = forms.CharField(
label="Protocol",
widget=selectable.AutoCompleteWidget(lookups.MetaProtocolLookup),
help_text="ex: B vitamins and risk of cancer",
required=False,
)
health_outcome = forms.CharField(
label="Health outcome",
widget=selectable.AutoCompleteWidget(
lookups.MetaResultHealthOutcomeLookup),
help_text="ex: Any adenoma",
required=False,
)
exposure_name = forms.CharField(
label="Exposure name",
widget=selectable.AutoCompleteWidget(lookups.ExposureLookup),
help_text="ex: Folate",
required=False,
)
order_by = forms.ChoiceField(choices=ORDER_BY_CHOICES, )
paginate_by = forms.IntegerField(label="Items per page",
min_value=1,
initial=25,
max_value=10000,
required=False)
def __init__(self, *args, **kwargs):
assessment = kwargs.pop("assessment")
super().__init__(*args, **kwargs)
for field in self.fields:
if field not in ("order_by", "paginate_by"):
self.fields[field].widget.update_query_parameters(
{"related": assessment.id})
self.helper = self.setHelper()
def setHelper(self):
# by default take-up the whole row-fluid
for fld in list(self.fields.keys()):
widget = self.fields[fld].widget
if type(widget) not in [
forms.CheckboxInput, forms.CheckboxSelectMultiple
]:
widget.attrs["class"] = "span12"
helper = BaseFormHelper(self)
helper.form_method = "GET"
helper.form_class = None
helper.add_fluid_row("studies", 4, "span3")
helper.layout.append(
cfb.FormActions(cfl.Submit("submit", "Apply filters"), ))
return helper
def get_query(self):
studies = self.cleaned_data.get("studies")
label = self.cleaned_data.get("label")
protocol = self.cleaned_data.get("protocol")
health_outcome = self.cleaned_data.get("health_outcome")
exposure_name = self.cleaned_data.get("exposure_name")
query = Q()
if studies:
query &= Q(protocol__study__in=studies)
if label:
query &= Q(label__icontains=label)
if protocol:
query &= Q(protocol__name__icontains=protocol)
if health_outcome:
query &= Q(health_outcome__icontains=health_outcome)
if exposure_name:
query &= Q(exposure_name__icontains=exposure_name)
return query
def get_order_by(self):
return self.cleaned_data.get("order_by", self.ORDER_BY_CHOICES[0][0])
class MetaResultForm(forms.ModelForm):
CREATE_LEGEND = "Create a new meta-result"
CREATE_HELP_TEXT = """
Create a new meta-result for an epidemiological assessment.
A meta-result is the aggregate result from a meta-analysis or
pooled analysis from multiple primary literature components.
"""
UPDATE_HELP_TEXT = "Update an existing meta-result"
adjustment_factors = selectable.AutoCompleteSelectMultipleField(
help_text="All factors which were included in final model",
lookup_class=AdjustmentFactorLookup,
required=False,
)
class Meta:
model = models.MetaResult
exclude = ("protocol", )
def __init__(self, *args, **kwargs):
parent = kwargs.pop("parent", None)
assessment = kwargs.pop("assessment", None)
super().__init__(*args, **kwargs)
self.fields["health_outcome"].widget = selectable.AutoCompleteWidget(
lookup_class=lookups.MetaResultHealthOutcomeLookup, allow_new=True)
self.fields["exposure_name"].widget = selectable.AutoCompleteWidget(
lookup_class=lookups.MetaResultExposureNameLookup, allow_new=True)
if parent:
self.instance.protocol = parent
self.fields["adjustment_factors"].widget.update_query_parameters(
{"related": assessment.id})
self.fields["health_outcome"].widget.update_query_parameters(
{"related": assessment.id})
self.fields["exposure_name"].widget.update_query_parameters(
{"related": assessment.id})
self.helper = self.setHelper()
def setHelper(self):
for fld in list(self.fields.keys()):
widget = self.fields[fld].widget
if type(widget) != forms.CheckboxInput:
if fld == "adjustment_factors":
widget.attrs["class"] = "span10"
else:
widget.attrs["class"] = "span12"
if type(widget) == forms.Textarea:
widget.attrs["rows"] = 3
if self.instance.id:
inputs = {
"legend_text": f"Update {self.instance}",
"help_text": self.UPDATE_HELP_TEXT,
"cancel_url": self.instance.get_absolute_url(),
}
else:
inputs = {
"legend_text": self.CREATE_LEGEND,
"help_text": self.CREATE_HELP_TEXT,
"cancel_url": self.instance.protocol.get_absolute_url(),
}
helper = BaseFormHelper(self, **inputs)
helper.form_class = None
helper.add_fluid_row("label", 2, "span6")
helper.add_fluid_row("health_outcome", 2, "span6")
helper.add_fluid_row("exposure_name", 2, "span6")
helper.add_fluid_row("number_studies", 3, "span4")
helper.add_fluid_row("n", 3, "span4")
helper.add_fluid_row("lower_ci", 3, "span4")
helper.add_fluid_row("adjustment_factors", 2, "span6")
url = reverse(
"epi:adjustmentfactor_create",
kwargs={"pk": self.instance.protocol.study.assessment.pk},
)
helper.addBtnLayout(helper.layout[8], 0, url, "Create criteria",
"span6")
return helper
class EndpointFilterForm(forms.Form):
ORDER_BY_CHOICES = (
('animal_group__experiment__study__short_citation', 'study'),
('name', 'endpoint name'),
('system', 'system'),
('organ', 'organ'),
('effect', 'effect'),
('effect_subtype', 'effect subtype'),
('animal_group__experiment__chemical', 'chemical'),
)
studies = selectable.AutoCompleteSelectMultipleField(
label='Study reference',
lookup_class=AnimalStudyLookup,
help_text="ex: Smith et al. 2010",
required=False)
cas = forms.CharField(
label='CAS',
widget=selectable.AutoCompleteWidget(lookups.RelatedExperimentCASLookup),
help_text="ex: 107-02-8",
required=False)
lifestage_exposed = forms.CharField(
label='Lifestage exposed',
widget=selectable.AutoCompleteWidget(lookups.RelatedAnimalGroupLifestageExposedLookup),
help_text="ex: pup",
required=False)
lifestage_assessed = forms.CharField(
label='Lifestage assessed',
widget=selectable.AutoCompleteWidget(lookups.RelatedAnimalGroupLifestageAssessedLookup),
help_text="ex: adult",
required=False)
species = selectable.AutoCompleteSelectField(
label='Species',
lookup_class=SpeciesLookup,
help_text="ex: Mouse",
required=False)
strain = selectable.AutoCompleteSelectField(
label='Strain',
lookup_class=StrainLookup,
help_text="ex: B6C3F1",
required=False)
sex = forms.MultipleChoiceField(
choices=models.AnimalGroup.SEX_CHOICES,
widget=forms.CheckboxSelectMultiple,
initial=[c[0] for c in models.AnimalGroup.SEX_CHOICES],
required=False)
data_extracted = forms.ChoiceField(
choices=((True, "Yes"), (False, "No"), (None, "All data")),
initial=None,
required=False)
name = forms.CharField(
label='Endpoint name',
widget=selectable.AutoCompleteWidget(lookups.EndpointByAssessmentTextLookup),
help_text="ex: heart weight",
required=False)
system = forms.CharField(
label='System',
widget=selectable.AutoCompleteWidget(lookups.RelatedEndpointSystemLookup),
help_text="ex: endocrine",
required=False)
organ = forms.CharField(
label='Organ',
widget=selectable.AutoCompleteWidget(lookups.RelatedEndpointOrganLookup),
help_text="ex: pituitary",
required=False)
effect = forms.CharField(
label='Effect',
widget=selectable.AutoCompleteWidget(lookups.RelatedEndpointEffectLookup),
help_text="ex: alanine aminotransferase (ALT)",
required=False)
effect_subtype = forms.CharField(
label='Effect Subtype',
widget=selectable.AutoCompleteWidget(lookups.RelatedEndpointEffectSubtypeLookup),
help_text="ex: ",
required=False)
tags = forms.CharField(
label='Tags',
widget=selectable.AutoCompleteWidget(EffectTagLookup),
help_text="ex: antibody response",
required=False)
dose_units = forms.ModelChoiceField(
queryset=DoseUnits.objects.all(),
required=False
)
order_by = forms.ChoiceField(
choices=ORDER_BY_CHOICES,
)
paginate_by = forms.IntegerField(
label='Items per page',
min_value=1,
initial=25,
max_value=10000,
required=False)
def __init__(self, *args, **kwargs):
assessment_id = kwargs.pop('assessment_id')
super().__init__(*args, **kwargs)
for field in self.fields:
if field not in ('sex', 'data_extracted', 'dose_units', 'order_by', 'paginate_by'):
self.fields[field].widget.update_query_parameters(
{'related': assessment_id})
self.helper = self.setHelper()
def setHelper(self):
# by default take-up the whole row-fluid
for fld in list(self.fields.keys()):
widget = self.fields[fld].widget
if type(widget) not in [forms.CheckboxInput, forms.CheckboxSelectMultiple]:
widget.attrs['class'] = 'span12'
helper = BaseFormHelper(self)
helper.form_method = "GET"
helper.form_class = None
helper.add_fluid_row('studies', 4, "span3")
helper.add_fluid_row('species', 4, "span3")
helper.add_fluid_row('name', 4, "span3")
helper.add_fluid_row('tags', 4, "span3")
helper.layout.append(
cfb.FormActions(
cfl.Submit('submit', 'Apply filters'),
)
)
return helper
def get_query(self):
studies = self.cleaned_data.get('studies')
cas = self.cleaned_data.get('cas')
lifestage_exposed = self.cleaned_data.get('lifestage_exposed')
lifestage_assessed = self.cleaned_data.get('lifestage_assessed')
species = self.cleaned_data.get('species')
strain = self.cleaned_data.get('strain')
sex = self.cleaned_data.get('sex')
data_extracted = self.cleaned_data.get('data_extracted')
name = self.cleaned_data.get('name')
system = self.cleaned_data.get('system')
organ = self.cleaned_data.get('organ')
effect = self.cleaned_data.get('effect')
effect_subtype = self.cleaned_data.get('effect_subtype')
tags = self.cleaned_data.get('tags')
dose_units = self.cleaned_data.get('dose_units')
query = Q()
if studies:
query &= Q(animal_group__experiment__study__in=studies)
if cas:
query &= Q(animal_group__experiment__cas__icontains=cas)
if lifestage_exposed:
query &= Q(animal_group__lifestage_exposed__icontains=lifestage_exposed)
if lifestage_assessed:
query &= Q(animal_group__lifestage_assessed__icontains=lifestage_assessed)
if species:
query &= Q(animal_group__species=species)
if strain:
query &= Q(animal_group__strain__name__icontains=strain.name)
if sex:
query &= Q(animal_group__sex__in=sex)
if data_extracted:
query &= Q(data_extracted=data_extracted == 'True')
if name:
query &= Q(name__icontains=name)
if system:
query &= Q(system__icontains=system)
if organ:
query &= Q(organ__icontains=organ)
if effect:
query &= Q(effect__icontains=effect)
if effect_subtype:
query &= Q(effect_subtype__icontains=effect_subtype)
if tags:
query &= Q(effects__name__icontains=tags)
if dose_units:
query &= Q(animal_group__dosing_regime__doses__dose_units=dose_units)
return query
def get_order_by(self):
return self.cleaned_data.get('order_by', self.ORDER_BY_CHOICES[0][0])
def get_dose_units_id(self):
if hasattr(self, "cleaned_data") and self.cleaned_data.get('dose_units'):
return self.cleaned_data.get('dose_units').id
class MetaProtocolForm(forms.ModelForm):
CREATE_LEGEND = "Create a new meta-protocol"
CREATE_HELP_TEXT = """
Create a new meta-protocol for an epidemiological
assessment. A meta-protocol contains the methodology behind a
meta-analysis or pooled analysis, which are frequently used
techniques used to quantitatively summarize results from
multiple studies or reference populations.
"""
UPDATE_HELP_TEXT = "Update an existing meta-protocol"
inclusion_criteria = selectable.AutoCompleteSelectMultipleField(
lookup_class=CriteriaLookup, required=False)
exclusion_criteria = selectable.AutoCompleteSelectMultipleField(
lookup_class=CriteriaLookup, required=False)
CRITERION_FIELDS = [
"inclusion_criteria",
"exclusion_criteria",
]
class Meta:
model = models.MetaProtocol
exclude = ("study", )
def __init__(self, *args, **kwargs):
parent = kwargs.pop("parent", None)
super().__init__(*args, **kwargs)
if parent:
self.instance.study = parent
self.fields["inclusion_criteria"].widget.update_query_parameters(
{"related": self.instance.study.assessment_id})
self.fields["exclusion_criteria"].widget.update_query_parameters(
{"related": self.instance.study.assessment_id})
self.helper = self.setHelper()
def setHelper(self):
for fld in list(self.fields.keys()):
widget = self.fields[fld].widget
if type(widget) != forms.CheckboxInput:
if fld in self.CRITERION_FIELDS:
widget.attrs["class"] = "span10"
else:
widget.attrs["class"] = "span12"
if type(widget) == forms.Textarea:
widget.attrs["rows"] = 3
if self.instance.id:
inputs = {
"legend_text": f"Update {self.instance}",
"help_text": self.UPDATE_HELP_TEXT,
"cancel_url": self.instance.get_absolute_url(),
}
else:
inputs = {
"legend_text": self.CREATE_LEGEND,
"help_text": self.CREATE_HELP_TEXT,
"cancel_url": self.instance.study.get_absolute_url(),
}
helper = BaseFormHelper(self, **inputs)
helper.form_class = None
helper.add_fluid_row("name", 2, "span6")
helper.add_fluid_row("lit_search_strategy", 2, "span6")
helper.add_fluid_row("lit_search_start_date", 3, "span4")
helper.add_fluid_row("inclusion_criteria", 2, "span6")
url = reverse("epi:studycriteria_create",
kwargs={"pk": self.instance.study.assessment.pk})
helper.addBtnLayout(helper.layout[5], 0, url, "Create criteria",
"span6")
helper.addBtnLayout(helper.layout[5], 1, url, "Create criteria",
"span6")
return helper
class StudyPopulationForm(forms.ModelForm):
CREATE_LEGEND = "Create new study-population"
CREATE_HELP_TEXT = ""
UPDATE_HELP_TEXT = "Update an existing study-population."
CRITERION_FIELDS = [
"inclusion_criteria",
"exclusion_criteria",
"confounding_criteria",
]
CRITERION_TYPE_CW = {
"inclusion_criteria": "I",
"exclusion_criteria": "E",
"confounding_criteria": "C",
}
inclusion_criteria = selectable.AutoCompleteSelectMultipleField(
lookup_class=lookups.CriteriaLookup, required=False
)
exclusion_criteria = selectable.AutoCompleteSelectMultipleField(
lookup_class=lookups.CriteriaLookup, required=False
)
confounding_criteria = selectable.AutoCompleteSelectMultipleField(
lookup_class=lookups.CriteriaLookup, required=False
)
class Meta:
model = models.StudyPopulation
exclude = ("study", "criteria")
labels = {"comments": "Recruitment description"}
def __init__(self, *args, **kwargs):
study = kwargs.pop("parent", None)
super().__init__(*args, **kwargs)
self.fields["comments"] = self.fields.pop("comments") # move to end
self.fields["region"].widget = selectable.AutoCompleteWidget(
lookup_class=lookups.RegionLookup, allow_new=True
)
self.fields["state"].widget = selectable.AutoCompleteWidget(
lookup_class=lookups.StateLookup, allow_new=True
)
if study:
self.instance.study = study
for fld in self.CRITERION_FIELDS:
self.fields[fld].widget.update_query_parameters(
{"related": self.instance.study.assessment_id}
)
if self.instance.id:
self.fields[fld].initial = getattr(self.instance, fld)
# set the help text here for the correct criteria field
self.fields[fld].help_text = self.instance.CRITERIA_HELP_TEXTS.get(fld, "")
self.helper = self.setHelper()
def save_criteria(self):
"""
StudyPopulationCriteria is a through model; requires the criteria type.
We save the m2m relations using the additional information from the
field-name
"""
self.instance.spcriteria.all().delete()
objs = []
for field in self.CRITERION_FIELDS:
for criteria in self.cleaned_data.get(field, []):
objs.append(
models.StudyPopulationCriteria(
criteria=criteria,
study_population=self.instance,
criteria_type=self.CRITERION_TYPE_CW[field],
)
)
models.StudyPopulationCriteria.objects.bulk_create(objs)
def save(self, commit=True):
instance = super().save(commit)
if commit:
self.save_criteria()
return instance
def setHelper(self):
for fld in list(self.fields.keys()):
widget = self.fields[fld].widget
if type(widget) != forms.CheckboxInput:
if fld in self.CRITERION_FIELDS:
widget.attrs["class"] = "span10"
else:
widget.attrs["class"] = "span12"
if type(widget) == forms.Textarea:
widget.attrs["rows"] = 3
if self.instance.id:
inputs = {
"legend_text": f"Update {self.instance}",
"help_text": self.UPDATE_HELP_TEXT,
"cancel_url": self.instance.get_absolute_url(),
}
else:
inputs = {
"legend_text": self.CREATE_LEGEND,
"help_text": self.CREATE_HELP_TEXT,
"cancel_url": self.instance.study.get_absolute_url(),
}
helper = BaseFormHelper(self, **inputs)
helper.form_class = None
helper.add_fluid_row("name", 2, "span6")
helper.add_fluid_row("age_profile", 2, "span6")
helper.add_fluid_row("countries", 3, "span4")
helper.add_fluid_row("eligible_n", 3, "span4")
helper.add_fluid_row("inclusion_criteria", 3, "span4")
url = reverse("epi:studycriteria_create", kwargs={"pk": self.instance.study.assessment.pk})
btn_target_idx = helper.find_layout_idx_for_field_name("comments") - 1
helper.addBtnLayout(helper.layout[btn_target_idx], 0, url, "Create criteria", "span4")
helper.addBtnLayout(helper.layout[btn_target_idx], 1, url, "Create criteria", "span4")
helper.addBtnLayout(helper.layout[btn_target_idx], 2, url, "Create criteria", "span4")
return helper
def clean(self):
cleaned_data = super().clean()
countries = cleaned_data.get("countries")
if not countries:
self.add_error("countries", "At least one country must be selected")
return cleaned_data
class StudyPopulationForm(forms.ModelForm):
inclusion_criteria = selectable.AutoCompleteSelectMultipleField(
lookup_class=lookups.StudyCriteriaLookup, required=False)
exclusion_criteria = selectable.AutoCompleteSelectMultipleField(
lookup_class=lookups.StudyCriteriaLookup, required=False)
confounding_criteria = selectable.AutoCompleteSelectMultipleField(
lookup_class=lookups.StudyCriteriaLookup, required=False)
class Meta:
fields = ('name', 'design', 'country', 'region', 'state', 'sex',
'ethnicity', 'fraction_male', 'fraction_male_calculated',
'n', 'starting_n', 'age_mean', 'age_mean_type',
'age_calculated', 'age_description', 'age_sd', 'age_sd_type',
'age_lower', 'age_lower_type', 'age_upper', 'age_upper_type',
'inclusion_criteria', 'exclusion_criteria',
'confounding_criteria')
model = models.StudyPopulation
exclude = ('study', )
def __init__(self, *args, **kwargs):
study = kwargs.pop('parent', None)
super(StudyPopulationForm, self).__init__(*args, **kwargs)
self.fields['region'].widget = selectable.AutoCompleteWidget(
lookup_class=lookups.RegionLookup, allow_new=True)
self.fields['state'].widget = selectable.AutoCompleteWidget(
lookup_class=lookups.StateLookup, allow_new=True)
if study:
self.instance.study = study
self.helper = self.setHelper()
def setHelper(self):
for fld in [
"inclusion_criteria", "exclusion_criteria",
"confounding_criteria"
]:
self.fields[fld].widget.update_query_parameters(
{'related': self.instance.study.assessment_id})
for fld in self.fields.keys():
widget = self.fields[fld].widget
if type(widget) != forms.CheckboxInput:
if fld in [
'inclusion_criteria', 'exclusion_criteria',
'confounding_criteria'
]:
widget.attrs['class'] = 'span11'
else:
widget.attrs['class'] = 'span12'
if self.instance.id:
inputs = {
"legend_text": u"Update {}".format(self.instance),
"help_text": u"Update an existing study-population.",
"cancel_url": self.instance.get_absolute_url()
}
else:
inputs = {
"legend_text": u"Create new study-population",
"help_text": u"""
Create a new study population. Each study-population is a
associated with an epidemiology study. There may be
multiple study populations with a single study,
though this is typically unlikely.""",
"cancel_url": self.instance.study.get_absolute_url()
}
helper = BaseFormHelper(self, **inputs)
helper.form_class = None
helper.add_fluid_row('name', 2, "span6")
helper.add_fluid_row('country', 3, "span4")
helper.add_fluid_row('sex', 4, "span3")
helper.add_fluid_row('n', 2, "span6")
helper.add_fluid_row('age_mean', 3, "span4")
helper.add_fluid_row('age_description', 3, "span4")
helper.add_fluid_row('age_lower', 4, "span3")
url = '{% url "epi:studycriteria_create" assessment.pk %}'
helper.add_adder("addIncCriteria", "Add new criteria", url)
helper.add_adder("addExcCriteria", "Add new criteria", url)
helper.add_adder("addConCriteria", "Add new criteria", url)
return helper
class EndpointForm(ModelForm):
effects = selectable.AutoCompleteSelectMultipleField(
lookup_class=EffectTagLookup,
required=False,
help_text="For now, use the endpoint specific overall study "
"evaluation rating of \"high\", \"medium\", \"low\" or "
"\"uninformative\"",
label="Additional tags")
class Meta:
model = models.Endpoint
fields = ('name', 'system', 'organ', 'effect', 'effect_subtype',
'effects', 'diagnostic', 'observation_time',
'observation_time_units', 'observation_time_text',
'data_reported', 'data_extracted', 'values_estimated',
'data_type', 'variance_type', 'confidence_interval',
'response_units', 'data_location',
'expected_adversity_direction', 'NOEL', 'LOEL', 'FEL',
'monotonicity', 'statistical_test', 'trend_result',
'trend_value', 'power_notes', 'results_notes',
'endpoint_notes', 'litter_effects', 'litter_effect_notes')
def __init__(self, *args, **kwargs):
animal_group = kwargs.pop('parent', None)
assessment = kwargs.pop('assessment', None)
super().__init__(*args, **kwargs)
self.fields['NOEL'].widget = forms.Select()
self.fields['LOEL'].widget = forms.Select()
self.fields['FEL'].widget = forms.Select()
self.fields['system'].widget = selectable.AutoCompleteWidget(
lookup_class=lookups.EndpointSystemLookup, allow_new=True)
self.fields['organ'].widget = selectable.AutoCompleteWidget(
lookup_class=lookups.EndpointOrganLookup, allow_new=True)
self.fields['effect'].widget = selectable.AutoCompleteWidget(
lookup_class=lookups.EndpointEffectLookup, allow_new=True)
self.fields['effect_subtype'].widget = selectable.AutoCompleteWidget(
lookup_class=lookups.EndpointEffectSubtypeLookup, allow_new=True)
self.fields['statistical_test'].widget = selectable.AutoCompleteWidget(
lookup_class=lookups.EndpointStatisticalTestLookup, allow_new=True)
if animal_group:
self.instance.animal_group = animal_group
self.instance.assessment = assessment
self.fields["name"].help_text = """
Short-text used to describe the endpoint/adverse
outcome. As a first pass during extraction, use
the endpoint name as presented in the study. Do
not add units — units are summarized in a separate
extraction field. Once extraction is complete for
an assessment, endpoint/adverse outcomes names may
be adjusted to use terms that best work across
studies or assessments using the data clean-up tool
(the original name as presented in the study will
be retained in the "Endpoint Name in Study" field). If the
endpoint is a repeated measure, then indicate the
time in parentheses, e.g., running wheel activity
(6 wk), using the abbreviated format: seconds = sec,
minutes = min, hours = h, days = d, weeks = wk,
months = mon, years = y.
"""
self.helper = self.setHelper()
def setHelper(self):
if self.instance.id:
inputs = {
"legend_text": "Update {}".format(self.instance),
"help_text": "Update an existing endpoint.",
"cancel_url": self.instance.get_absolute_url()
}
else:
inputs = {
"legend_text": "Create new endpoint",
"help_text": """
Create a new endpoint. An endpoint should describe
one measure-of-effect which was measured in the study.
It may or may not contain quantitative data. For
endpoint terminology, use the reference document
"<a href="https://hawcprd.epa.gov/assessment/100000039/">Recommended
Terminology for Outcomes/Endpoints</a>."
""",
"cancel_url": self.instance.animal_group.get_absolute_url()
}
helper = BaseFormHelper(self, **inputs)
helper.form_class = None
helper.form_id = "endpoint"
self.fields['diagnostic'].widget.attrs['rows'] = 2
for fld in ('results_notes', 'endpoint_notes', 'power_notes'):
self.fields[fld].widget.attrs['rows'] = 3
# by default take-up the whole row-fluid
for fld in list(self.fields.keys()):
widget = self.fields[fld].widget
if type(widget) != forms.CheckboxInput:
if fld in ["effects"]:
widget.attrs['class'] = 'span10'
else:
widget.attrs['class'] = 'span12'
helper.add_fluid_row('system', 4, "span3")
helper.add_fluid_row('effects', 2, "span6")
helper.add_fluid_row('observation_time', 3, "span4")
helper.add_fluid_row('data_reported', 3, "span4")
helper.add_fluid_row('data_type', 3, "span4")
helper.add_fluid_row('response_units', 3, "span4")
helper.add_fluid_row('NOEL', 4, "span3")
helper.add_fluid_row('statistical_test', 3,
["span6", "span3", "span3"])
helper.add_fluid_row('litter_effects', 2, "span6")
url = reverse('assessment:effect_tag_create',
kwargs={'pk': self.instance.assessment.pk})
helper.addBtnLayout(helper.layout[4], 0, url, "Add new effect tag",
"span6")
return helper
LIT_EFF_REQ = "Litter effects required if a reproductive/developmental study"
LIT_EFF_NOT_REQ = "Litter effects must be NA if non-reproductive/developmental study"
LIT_EFF_NOTES_REQ = 'Notes are required if litter effects are "Other"'
LIT_EFF_NOTES_NOT_REQ = "Litter effect notes should be blank if effects are not-applicable"
def clean(self):
cleaned_data = super().clean()
obs_time = cleaned_data.get("observation_time")
observation_time_units = cleaned_data.get("observation_time_units")
litter_effects = cleaned_data.get("litter_effects")
litter_effect_notes = cleaned_data.get("litter_effect_notes")
if obs_time is not None and observation_time_units == 0:
err = "If reporting an endpoint-observation time, time-units must be specified."
self.add_error('observation_time_units', err)
if obs_time is None and observation_time_units > 0:
err = "An observation-time must be reported if time-units are specified"
self.add_error('observation_time', err)
experiment_type = self.instance.animal_group.experiment.type
if experiment_type in ["Rp", "Dv"]:
if litter_effects == "NA":
self.add_error('litter_effects', self.LIT_EFF_REQ)
elif experiment_type != "Ot" and litter_effects != "NA":
self.add_error('litter_effects', self.LIT_EFF_NOT_REQ)
if litter_effects == "O" and litter_effect_notes == "":
self.add_error('litter_effect_notes', self.LIT_EFF_NOTES_REQ)
if litter_effects == "NA" and litter_effect_notes != "":
self.add_error('litter_effect_notes', self.LIT_EFF_NOTES_NOT_REQ)
return cleaned_data
def clean_confidence_interval(self):
confidence_interval = self.cleaned_data['confidence_interval']
data_type = self.cleaned_data.get("data_type")
if data_type == "P" and confidence_interval is None:
raise forms.ValidationError("Confidence-interval is required for"
"percent-difference data")
return confidence_interval
def clean_variance_type(self):
data_type = self.cleaned_data.get("data_type")
variance_type = self.cleaned_data.get("variance_type")
return variance_type
def clean_response_units(self):
response_units = self.cleaned_data.get("response_units")
data_extracted = self.cleaned_data.get("data_extracted")
if data_extracted and response_units == "":
raise forms.ValidationError(
"If data is extracted (see checkbox), response-units are required"
)
return response_units
class EndpointForm(ModelForm):
effects = selectable.AutoCompleteSelectMultipleField(
lookup_class=EffectTagLookup,
required=False,
help_text=get_flavored_text("ani__endpoint_form__effects"),
label="Additional tags",
)
class Meta:
model = models.Endpoint
fields = (
"name",
"system",
"organ",
"effect",
"effect_subtype",
"effects",
"diagnostic",
"observation_time",
"observation_time_units",
"observation_time_text",
"data_reported",
"data_extracted",
"values_estimated",
"data_type",
"variance_type",
"confidence_interval",
"response_units",
"data_location",
"expected_adversity_direction",
"NOEL",
"LOEL",
"FEL",
"monotonicity",
"statistical_test",
"trend_result",
"trend_value",
"power_notes",
"results_notes",
"endpoint_notes",
"litter_effects",
"litter_effect_notes",
)
def __init__(self, *args, **kwargs):
animal_group = kwargs.pop("parent", None)
assessment = kwargs.pop("assessment", None)
super().__init__(*args, **kwargs)
self.fields["NOEL"].widget = forms.Select()
self.fields["LOEL"].widget = forms.Select()
self.fields["FEL"].widget = forms.Select()
noel_names = assessment.get_noel_names(
) if assessment else self.instance.get_noel_names()
self.fields["NOEL"].label = noel_names.noel
self.fields["NOEL"].help_text = noel_names.noel_help_text
self.fields["LOEL"].label = noel_names.loel
self.fields["LOEL"].help_text = noel_names.loel_help_text
self.fields["system"].widget = selectable.AutoCompleteWidget(
lookup_class=lookups.EndpointSystemLookup, allow_new=True)
self.fields["organ"].widget = selectable.AutoCompleteWidget(
lookup_class=lookups.EndpointOrganLookup, allow_new=True)
self.fields["effect"].widget = selectable.AutoCompleteWidget(
lookup_class=lookups.EndpointEffectLookup, allow_new=True)
self.fields["effect_subtype"].widget = selectable.AutoCompleteWidget(
lookup_class=lookups.EndpointEffectSubtypeLookup, allow_new=True)
self.fields["statistical_test"].widget = selectable.AutoCompleteWidget(
lookup_class=lookups.EndpointStatisticalTestLookup, allow_new=True)
if animal_group:
self.instance.animal_group = animal_group
self.instance.assessment = assessment
self.fields["name"].help_text = get_flavored_text(
"ani__endpoint_form__name")
self.helper = self.setHelper()
self.noel_names = json.dumps(self.instance.get_noel_names()._asdict())
def setHelper(self):
if self.instance.id:
inputs = {
"legend_text": f"Update {self.instance}",
"help_text": "Update an existing endpoint.",
"cancel_url": self.instance.get_absolute_url(),
}
else:
inputs = {
"legend_text": "Create new endpoint",
"help_text": get_flavored_text("ani__endpoint_form__create"),
"cancel_url": self.instance.animal_group.get_absolute_url(),
}
helper = BaseFormHelper(self, **inputs)
helper.form_class = None
helper.form_id = "endpoint"
self.fields["diagnostic"].widget.attrs["rows"] = 2
for fld in ("results_notes", "endpoint_notes", "power_notes"):
self.fields[fld].widget.attrs["rows"] = 3
# by default take-up the whole row-fluid
for fld in list(self.fields.keys()):
widget = self.fields[fld].widget
if type(widget) != forms.CheckboxInput:
if fld in ["effects"]:
widget.attrs["class"] = "span10"
else:
widget.attrs["class"] = "span12"
helper.add_fluid_row("system", 4, "span3")
helper.add_fluid_row("effects", 2, "span6")
helper.add_fluid_row("observation_time", 3, "span4")
helper.add_fluid_row("data_reported", 3, "span4")
helper.add_fluid_row("data_type", 3, "span4")
helper.add_fluid_row("response_units", 3, "span4")
helper.add_fluid_row("NOEL", 4, "span3")
helper.add_fluid_row("statistical_test", 3,
["span6", "span3", "span3"])
helper.add_fluid_row("litter_effects", 2, "span6")
url = reverse("assessment:effect_tag_create",
kwargs={"pk": self.instance.assessment.pk})
helper.addBtnLayout(helper.layout[4], 0, url, "Add new effect tag",
"span6")
return helper
LIT_EFF_REQ = "Litter effects required if a reproductive/developmental study"
LIT_EFF_NOT_REQ = "Litter effects must be NA if non-reproductive/developmental study"
LIT_EFF_NOTES_REQ = 'Notes are required if litter effects are "Other"'
LIT_EFF_NOTES_NOT_REQ = "Litter effect notes should be blank if effects are not-applicable"
def clean(self):
cleaned_data = super().clean()
obs_time = cleaned_data.get("observation_time")
observation_time_units = cleaned_data.get("observation_time_units")
litter_effects = cleaned_data.get("litter_effects")
litter_effect_notes = cleaned_data.get("litter_effect_notes")
if obs_time is not None and observation_time_units == 0:
err = "If reporting an endpoint-observation time, time-units must be specified."
self.add_error("observation_time_units", err)
if obs_time is None and observation_time_units > 0:
err = "An observation-time must be reported if time-units are specified"
self.add_error("observation_time", err)
if self.instance.litter_effect_required():
if litter_effects == "NA":
self.add_error("litter_effects", self.LIT_EFF_REQ)
elif not self.instance.litter_effect_optional(
) and litter_effects != "NA":
self.add_error("litter_effects", self.LIT_EFF_NOT_REQ)
if litter_effects == "O" and litter_effect_notes == "":
self.add_error("litter_effect_notes", self.LIT_EFF_NOTES_REQ)
if litter_effects == "NA" and litter_effect_notes != "":
self.add_error("litter_effect_notes", self.LIT_EFF_NOTES_NOT_REQ)
return cleaned_data
def clean_confidence_interval(self):
confidence_interval = self.cleaned_data["confidence_interval"]
data_type = self.cleaned_data.get("data_type")
if data_type == "P" and confidence_interval is None:
raise forms.ValidationError("Confidence-interval is required for"
"percent-difference data")
return confidence_interval
def clean_variance_type(self):
data_type = self.cleaned_data.get("data_type")
variance_type = self.cleaned_data.get("variance_type")
if data_type == "C" and variance_type == 0:
raise forms.ValidationError(
"If entering continuous data, the variance type must be SD"
"(standard-deviation) or SE (standard error)")
return variance_type
def clean_response_units(self):
response_units = self.cleaned_data.get("response_units")
data_extracted = self.cleaned_data.get("data_extracted")
if data_extracted and response_units == "":
raise forms.ValidationError(
"If data is extracted (see checkbox), response-units are required"
)
return response_units
class StudyPopulationForm(forms.ModelForm):
CREATE_LEGEND = "Create new study-population"
CREATE_HELP_TEXT = """
Create a new study population. Each study-population is a
associated with an epidemiology study. There may be
multiple study populations with a single study,
though this is typically unlikely."""
UPDATE_HELP_TEXT = "Update an existing study-population."
CRITERION_FIELDS = [
"inclusion_criteria", "exclusion_criteria", "confounding_criteria"
]
CRITERION_TYPE_CW = {
"inclusion_criteria": "I",
"exclusion_criteria": "E",
"confounding_criteria": "C",
}
inclusion_criteria = selectable.AutoCompleteSelectMultipleField(
lookup_class=lookups.CriteriaLookup, required=False)
exclusion_criteria = selectable.AutoCompleteSelectMultipleField(
lookup_class=lookups.CriteriaLookup, required=False)
confounding_criteria = selectable.AutoCompleteSelectMultipleField(
lookup_class=lookups.CriteriaLookup, required=False)
class Meta:
model = models.StudyPopulation
exclude = ('study', 'criteria')
def __init__(self, *args, **kwargs):
study = kwargs.pop('parent', None)
super().__init__(*args, **kwargs)
self.fields['comments'] = self.fields.pop('comments') # move to end
self.fields['region'].widget = selectable.AutoCompleteWidget(
lookup_class=lookups.RegionLookup, allow_new=True)
self.fields['state'].widget = selectable.AutoCompleteWidget(
lookup_class=lookups.StateLookup, allow_new=True)
if study:
self.instance.study = study
for fld in self.CRITERION_FIELDS:
self.fields[fld].widget.update_query_parameters(
{'related': self.instance.study.assessment_id})
if self.instance.id:
self.fields[fld].initial = getattr(self.instance, fld)
self.helper = self.setHelper()
def save_criteria(self):
"""
StudyPopulationCriteria is a through model; requires the criteria type.
We save the m2m relations using the additional information from the
field-name
"""
self.instance.spcriteria.all().delete()
objs = []
for field in self.CRITERION_FIELDS:
for criteria in self.cleaned_data.get(field, []):
objs.append(
models.StudyPopulationCriteria(
criteria=criteria,
study_population=self.instance,
criteria_type=self.CRITERION_TYPE_CW[field]))
models.StudyPopulationCriteria.objects.bulk_create(objs)
def save(self, commit=True):
instance = super().save(commit)
if commit:
self.save_criteria()
return instance
def setHelper(self):
for fld in list(self.fields.keys()):
widget = self.fields[fld].widget
if type(widget) != forms.CheckboxInput:
if fld in self.CRITERION_FIELDS:
widget.attrs['class'] = 'span10'
else:
widget.attrs['class'] = 'span12'
if type(widget) == forms.Textarea:
widget.attrs['rows'] = 3
if self.instance.id:
inputs = {
"legend_text": "Update {}".format(self.instance),
"help_text": self.UPDATE_HELP_TEXT,
"cancel_url": self.instance.get_absolute_url()
}
else:
inputs = {
"legend_text": self.CREATE_LEGEND,
"help_text": self.CREATE_HELP_TEXT,
"cancel_url": self.instance.study.get_absolute_url()
}
helper = BaseFormHelper(self, **inputs)
helper.form_class = None
helper.add_fluid_row('name', 2, "span6")
helper.add_fluid_row('age_profile', 2, "span6")
helper.add_fluid_row('country', 3, "span4")
helper.add_fluid_row('eligible_n', 3, "span4")
helper.add_fluid_row('inclusion_criteria', 3, "span4")
url = reverse('epi:studycriteria_create',
kwargs={'pk': self.instance.study.assessment.pk})
helper.addBtnLayout(helper.layout[6], 0, url, "Create criteria",
"span4")
helper.addBtnLayout(helper.layout[6], 1, url, "Create criteria",
"span4")
helper.addBtnLayout(helper.layout[6], 2, url, "Create criteria",
"span4")
return helper
class EndpointFilterForm(forms.Form):
ORDER_BY_CHOICES = [
("animal_group__experiment__study__short_citation", "study"),
("animal_group__experiment__name", "experiment name"),
("animal_group__name", "animal group"),
("name", "endpoint name"),
("animal_group__dosing_regime__doses__dose_units_id", "dose units"),
("system", "system"),
("organ", "organ"),
("effect", "effect"),
["-NOEL", "<NOEL-NAME>"],
["-LOEL", "<LOEL-NAME>"],
# BMD/BMDL is stored in output which is a JsonField on the bmd Model object. We want to sort on a sub-field of that.
# when/if HAWC upgrades to Django 2.1 (see yekta's comment on https://stackoverflow.com/questions/36641759/django-1-9-jsonfield-order-by)
# could possibly do something like this instead.
# for now we use a custom sort string and handle it in EndpointList class
# ('bmd_model__model__output__-BMD', 'BMD'),
# ('bmd_model__model__output__-BMDL', 'BMDLS'),
("customBMD", "BMD"),
("customBMDLS", "BMDLS"),
("effect_subtype", "effect subtype"),
("animal_group__experiment__chemical", "chemical"),
]
studies = selectable.AutoCompleteSelectMultipleField(
label="Study reference",
lookup_class=AnimalStudyLookup,
help_text="ex: Smith et al. 2010",
required=False,
)
chemical = forms.CharField(
label="Chemical name",
widget=selectable.AutoCompleteWidget(lookups.ExpChemicalLookup),
help_text="ex: sodium",
required=False,
)
cas = forms.CharField(
label="CAS",
widget=selectable.AutoCompleteWidget(
lookups.RelatedExperimentCASLookup),
help_text="ex: 107-02-8",
required=False,
)
lifestage_exposed = forms.CharField(
label="Lifestage exposed",
widget=selectable.AutoCompleteWidget(
lookups.RelatedAnimalGroupLifestageExposedLookup),
help_text="ex: pup",
required=False,
)
lifestage_assessed = forms.CharField(
label="Lifestage assessed",
widget=selectable.AutoCompleteWidget(
lookups.RelatedAnimalGroupLifestageAssessedLookup),
help_text="ex: adult",
required=False,
)
species = selectable.AutoCompleteSelectField(
label="Species",
lookup_class=SpeciesLookup,
help_text="ex: Mouse",
required=False,
)
strain = selectable.AutoCompleteSelectField(
label="Strain",
lookup_class=StrainLookup,
help_text="ex: B6C3F1",
required=False,
)
sex = forms.MultipleChoiceField(
choices=models.AnimalGroup.SEX_CHOICES,
widget=forms.CheckboxSelectMultiple,
initial=[c[0] for c in models.AnimalGroup.SEX_CHOICES],
required=False,
)
data_extracted = forms.ChoiceField(
choices=((True, "Yes"), (False, "No"), (None, "All data")),
initial=None,
required=False,
)
name = forms.CharField(
label="Endpoint name",
widget=selectable.AutoCompleteWidget(
lookups.EndpointByAssessmentTextLookup),
help_text="ex: heart weight",
required=False,
)
system = forms.CharField(
label="System",
widget=selectable.AutoCompleteWidget(
lookups.RelatedEndpointSystemLookup),
help_text="ex: endocrine",
required=False,
)
organ = forms.CharField(
label="Organ",
widget=selectable.AutoCompleteWidget(
lookups.RelatedEndpointOrganLookup),
help_text="ex: pituitary",
required=False,
)
effect = forms.CharField(
label="Effect",
widget=selectable.AutoCompleteWidget(
lookups.RelatedEndpointEffectLookup),
help_text="ex: alanine aminotransferase (ALT)",
required=False,
)
effect_subtype = forms.CharField(
label="Effect Subtype",
widget=selectable.AutoCompleteWidget(
lookups.RelatedEndpointEffectSubtypeLookup),
help_text="ex: ",
required=False,
)
tags = forms.CharField(
label="Tags",
widget=selectable.AutoCompleteWidget(EffectTagLookup),
help_text="ex: antibody response",
required=False,
)
dose_units = forms.ModelChoiceField(queryset=DoseUnits.objects.all(),
required=False)
order_by = forms.ChoiceField(choices=ORDER_BY_CHOICES, )
paginate_by = forms.IntegerField(label="Items per page",
min_value=1,
initial=25,
max_value=10000,
required=False)
def __init__(self, *args, **kwargs):
assessment = kwargs.pop("assessment")
super().__init__(*args, **kwargs)
noel_names = assessment.get_noel_names()
for field in self.fields:
if field not in (
"sex",
"data_extracted",
"dose_units",
"order_by",
"paginate_by",
):
self.fields[field].widget.update_query_parameters(
{"related": assessment.id})
for i, (k, v) in enumerate(self.fields["order_by"].choices):
if v == "<NOEL-NAME>":
self.fields["order_by"].choices[i][1] = noel_names.noel
self.fields["order_by"].widget.choices[i][1] = noel_names.noel
elif v == "<LOEL-NAME>":
self.fields["order_by"].choices[i][1] = noel_names.loel
self.fields["order_by"].widget.choices[i][1] = noel_names.loel
self.helper = self.setHelper()
def setHelper(self):
# by default take-up the whole row-fluid
for fld in list(self.fields.keys()):
widget = self.fields[fld].widget
if type(widget) not in [
forms.CheckboxInput, forms.CheckboxSelectMultiple
]:
widget.attrs["class"] = "span12"
helper = BaseFormHelper(self)
helper.form_method = "GET"
helper.form_class = None
helper.add_fluid_row("studies", 4, "span3")
helper.add_fluid_row("species", 4, "span3")
helper.add_fluid_row("name", 4, "span3")
helper.add_fluid_row("tags", 4, "span3")
helper.layout.append(
cfb.FormActions(cfl.Submit("submit", "Apply filters"), ))
return helper
def get_query(self):
studies = self.cleaned_data.get("studies")
chemical = self.cleaned_data.get("chemical")
cas = self.cleaned_data.get("cas")
lifestage_exposed = self.cleaned_data.get("lifestage_exposed")
lifestage_assessed = self.cleaned_data.get("lifestage_assessed")
species = self.cleaned_data.get("species")
strain = self.cleaned_data.get("strain")
sex = self.cleaned_data.get("sex")
data_extracted = self.cleaned_data.get("data_extracted")
name = self.cleaned_data.get("name")
system = self.cleaned_data.get("system")
organ = self.cleaned_data.get("organ")
effect = self.cleaned_data.get("effect")
effect_subtype = self.cleaned_data.get("effect_subtype")
NOEL = self.cleaned_data.get("NOEL")
LOEL = self.cleaned_data.get("LOEL")
tags = self.cleaned_data.get("tags")
dose_units = self.cleaned_data.get("dose_units")
query = Q()
if studies:
query &= Q(animal_group__experiment__study__in=studies)
if chemical:
query &= Q(animal_group__experiment__chemical__icontains=chemical)
if cas:
query &= Q(animal_group__experiment__cas__icontains=cas)
if lifestage_exposed:
query &= Q(
animal_group__lifestage_exposed__icontains=lifestage_exposed)
if lifestage_assessed:
query &= Q(
animal_group__lifestage_assessed__icontains=lifestage_assessed)
if species:
query &= Q(animal_group__species=species)
if strain:
query &= Q(animal_group__strain__name__icontains=strain.name)
if sex:
query &= Q(animal_group__sex__in=sex)
if data_extracted:
query &= Q(data_extracted=data_extracted == "True")
if name:
query &= Q(name__icontains=name)
if system:
query &= Q(system__icontains=system)
if organ:
query &= Q(organ__icontains=organ)
if effect:
query &= Q(effect__icontains=effect)
if effect_subtype:
query &= Q(effect_subtype__icontains=effect_subtype)
if NOEL:
query &= Q(NOEL__icontains=NOEL)
if LOEL:
query &= Q(LOEL__icontains=LOEL)
if tags:
query &= Q(effects__name__icontains=tags)
if dose_units:
query &= Q(
animal_group__dosing_regime__doses__dose_units=dose_units)
return query
def get_order_by(self):
return self.cleaned_data.get("order_by", self.ORDER_BY_CHOICES[0][0])
def get_dose_units_id(self):
if hasattr(self,
"cleaned_data") and self.cleaned_data.get("dose_units"):
return self.cleaned_data.get("dose_units").id
class AssessedOutcomeForm(forms.ModelForm):
HELP_TEXT_CREATE = """Create a new assessed outcome. An assessed
outcome is an response measured in an epidemiological study,
associated with an exposure-metric. The overall assessed outcome is
described, and then quantitative differences in response based on
different exposure-metric groups is detailed below.
"""
HELP_TEXT_UPDATE = """Create a new assessed outcome. An assessed
outcome is an response measured in an epidemiological study,
associated with an exposure-metric. The overall assessed outcome is
described, and then quantitative differences in response based on
different exposure-metric groups is detailed below.
"""
adjustment_factors = selectable.AutoCompleteSelectMultipleField(
help_text="All factors which were included in final model",
lookup_class=lookups.FactorLookup,
required=False)
confounders_considered = selectable.AutoCompleteSelectMultipleField(
label="Adjustment factors considered",
help_text=
"All factors which were examined (including those which were included in final model)",
lookup_class=lookups.FactorLookup,
required=False)
class Meta:
model = models.AssessedOutcome
exclude = ('assessment', 'exposure')
def __init__(self, *args, **kwargs):
assessment = kwargs.pop('assessment', None)
exposure = kwargs.pop('parent', None)
super(AssessedOutcomeForm, self).__init__(*args, **kwargs)
self.fields['name'].widget = selectable.AutoCompleteWidget(
lookup_class=BaseEndpointLookup, allow_new=True)
self.fields[
'effects'].widget = selectable.AutoCompleteSelectMultipleWidget(
lookup_class=EffectTagLookup)
self.fields[
'effects'].help_text = 'Tags used to help categorize effect description.'
if assessment:
self.instance.assessment = assessment
if exposure:
self.instance.exposure = exposure
self.fields['adjustment_factors'].widget.update_query_parameters(
{'related': self.instance.assessment.id})
self.fields['confounders_considered'].widget.update_query_parameters(
{'related': self.instance.assessment.id})
self.fields['main_finding'].queryset = self.fields['main_finding']\
.queryset.filter(exposure=self.instance.exposure)
self.helper = self.setHelper()
def setHelper(self):
for fld in ('diagnostic_description', 'summary',
'prevalence_incidence', 'statistical_power_details',
'dose_response_details', 'statistical_metric_description'):
self.fields[fld].widget.attrs['rows'] = 3
for fld in self.fields.keys():
widget = self.fields[fld].widget
if type(widget) != forms.CheckboxInput:
if fld in [
"adjustment_factors", "confounders_considered",
"effects"
]:
widget.attrs['class'] = 'span11'
else:
widget.attrs['class'] = 'span12'
if self.instance.id:
inputs = {
"legend_text": u"Update {}".format(self.instance),
"help_text": self.HELP_TEXT_UPDATE,
"cancel_url": self.instance.get_absolute_url()
}
else:
inputs = {
"legend_text": u"Create new exposure",
"help_text": self.HELP_TEXT_CREATE,
"cancel_url": self.instance.exposure.get_absolute_url()
}
helper = BaseFormHelper(self, **inputs)
helper.form_class = None
helper.add_fluid_row('effects', 2, "span6")
helper.add_fluid_row('diagnostic', 2, "span6")
helper.add_fluid_row('summary', 2, "span6")
helper.add_fluid_row('adjustment_factors', 2, "span6")
helper.add_fluid_row('dose_response', 2, "span6")
helper.add_fluid_row('statistical_power', 2, "span6")
helper.add_fluid_row('main_finding', 2, "span6")
helper.add_fluid_row('statistical_metric', 2, "span6")
url = "{% url 'assessment:effect_tag_create' assessment.pk %}"
helper.add_adder("addEffectTags", "Add new effect tag", url)
url = "{% url 'epi:factor_create' assessment.pk %}"
helper.add_adder("addAdj", "Add new adjustment factor", url)
helper.add_adder("addAdjCons", "Add new adjustment factor", url)
return helper
class StudyPopulationForm(forms.ModelForm):
CREATE_LEGEND = "Create new study-population"
UPDATE_HELP_TEXT = "Update an existing study-population."
CRITERION_FIELDS = [
"inclusion_criteria", "exclusion_criteria", "confounding_criteria"
]
CRITERION_TYPE_CW = {
"inclusion_criteria": "I",
"exclusion_criteria": "E",
"confounding_criteria": "C",
}
inclusion_criteria = selectable.AutoCompleteSelectMultipleField(
lookup_class=lookups.CriteriaLookup, required=False)
exclusion_criteria = selectable.AutoCompleteSelectMultipleField(
lookup_class=lookups.CriteriaLookup, required=False)
confounding_criteria = selectable.AutoCompleteSelectMultipleField(
lookup_class=lookups.CriteriaLookup, required=False)
class Meta:
model = models.StudyPopulation
exclude = ('study', 'criteria')
labels = {
'comments':
'Recruitment description' # could also change field name in models.py from comments to recruitment_description, but this seems less disruptive!
}
def __init__(self, *args, **kwargs):
study = kwargs.pop('parent', None)
super().__init__(*args, **kwargs)
self.fields['comments'] = self.fields.pop('comments') # move to end
self.fields['region'].widget = selectable.AutoCompleteWidget(
lookup_class=lookups.RegionLookup, allow_new=True)
self.fields['state'].widget = selectable.AutoCompleteWidget(
lookup_class=lookups.StateLookup, allow_new=True)
if study:
self.instance.study = study
for fld in self.CRITERION_FIELDS:
self.fields[fld].widget.update_query_parameters(
{'related': self.instance.study.assessment_id})
if self.instance.id:
self.fields[fld].initial = getattr(self.instance, fld)
# set the help text here for the correct criteria field
self.fields[fld].help_text = self.instance.CRITERIA_HELP_TEXTS.get(
fld, "")
self.helper = self.setHelper()
def save_criteria(self):
"""
StudyPopulationCriteria is a through model; requires the criteria type.
We save the m2m relations using the additional information from the
field-name
"""
self.instance.spcriteria.all().delete()
objs = []
for field in self.CRITERION_FIELDS:
for criteria in self.cleaned_data.get(field, []):
objs.append(
models.StudyPopulationCriteria(
criteria=criteria,
study_population=self.instance,
criteria_type=self.CRITERION_TYPE_CW[field]))
models.StudyPopulationCriteria.objects.bulk_create(objs)
def save(self, commit=True):
instance = super().save(commit)
if commit:
self.save_criteria()
return instance
def setHelper(self):
for fld in list(self.fields.keys()):
widget = self.fields[fld].widget
if type(widget) != forms.CheckboxInput:
if fld in self.CRITERION_FIELDS:
widget.attrs['class'] = 'span10'
else:
widget.attrs['class'] = 'span12'
if type(widget) == forms.Textarea:
widget.attrs['rows'] = 3
if self.instance.id:
inputs = {
"legend_text": "Update {}".format(self.instance),
"help_text": self.UPDATE_HELP_TEXT,
"cancel_url": self.instance.get_absolute_url()
}
else:
inputs = {
"legend_text": self.CREATE_LEGEND,
"cancel_url": self.instance.study.get_absolute_url()
}
helper = BaseFormHelper(self, **inputs)
helper.form_class = None
helper.add_fluid_row('name', 2, "span6")
helper.add_fluid_row('age_profile', 2, "span6")
helper.add_fluid_row('country', 3, "span4")
helper.add_fluid_row('eligible_n', 3, "span4")
helper.add_fluid_row('inclusion_criteria', 3, "span4")
url = reverse('epi:studycriteria_create',
kwargs={'pk': self.instance.study.assessment.pk})
# remove magic number 6; breaks if we change number of elements in the form. This still isn't great; what if comments went away?
btn_target_idx = helper.find_layout_idx_for_field_name('comments') - 1
helper.addBtnLayout(helper.layout[btn_target_idx], 0, url,
"Create criteria", "span4")
helper.addBtnLayout(helper.layout[btn_target_idx], 1, url,
"Create criteria", "span4")
helper.addBtnLayout(helper.layout[btn_target_idx], 2, url,
"Create criteria", "span4")
return helper
class EndpointForm(ModelForm):
effects = selectable.AutoCompleteSelectMultipleField(
lookup_class=EffectTagLookup,
required=False,
help_text="Any additional descriptive-tags used to categorize the outcome",
label="Additional tags"
)
class Meta:
model = models.Endpoint
fields = ('name',
'system', 'organ', 'effect', 'effect_subtype',
'effects', 'diagnostic',
'observation_time', 'observation_time_units', 'observation_time_text',
'data_reported', 'data_extracted', 'values_estimated',
'data_type', 'variance_type', 'confidence_interval',
'response_units', 'data_location', 'expected_adversity_direction',
'NOEL', 'LOEL', 'FEL', 'monotonicity',
'statistical_test', 'trend_result', 'trend_value',
'power_notes', 'results_notes', 'endpoint_notes')
def __init__(self, *args, **kwargs):
animal_group = kwargs.pop('parent', None)
assessment = kwargs.pop('assessment', None)
super().__init__(*args, **kwargs)
self.fields['NOEL'].widget = forms.Select()
self.fields['LOEL'].widget = forms.Select()
self.fields['FEL'].widget = forms.Select()
self.fields['system'].widget = selectable.AutoCompleteWidget(
lookup_class=lookups.EndpointSystemLookup,
allow_new=True)
self.fields['organ'].widget = selectable.AutoCompleteWidget(
lookup_class=lookups.EndpointOrganLookup,
allow_new=True)
self.fields['effect'].widget = selectable.AutoCompleteWidget(
lookup_class=lookups.EndpointEffectLookup,
allow_new=True)
self.fields['effect_subtype'].widget = selectable.AutoCompleteWidget(
lookup_class=lookups.EndpointEffectSubtypeLookup,
allow_new=True)
self.fields['statistical_test'].widget = selectable.AutoCompleteWidget(
lookup_class=lookups.EndpointStatisticalTestLookup,
allow_new=True)
if animal_group:
self.instance.animal_group = animal_group
self.instance.assessment = assessment
self.fields["name"].help_text = """
Short-text used to describe the endpoint.
Should include observation-time,
if multiple endpoints have the same observation time."""
self.helper = self.setHelper()
def setHelper(self):
if self.instance.id:
inputs = {
"legend_text": "Update {}".format(self.instance),
"help_text": "Update an existing endpoint.",
"cancel_url": self.instance.get_absolute_url()
}
else:
inputs = {
"legend_text": "Create new endpoint",
"help_text": """
Create a new endpoint. An endpoint may should describe one
measure-of-effect which was measured in the study. It may
or may not contain quantitative data.""",
"cancel_url": self.instance.animal_group.get_absolute_url()
}
helper = BaseFormHelper(self, **inputs)
helper.form_class = None
helper.form_id = "endpoint"
self.fields['diagnostic'].widget.attrs['rows'] = 2
for fld in ('results_notes', 'endpoint_notes', 'power_notes'):
self.fields[fld].widget.attrs['rows'] = 3
# by default take-up the whole row-fluid
for fld in list(self.fields.keys()):
widget = self.fields[fld].widget
if type(widget) != forms.CheckboxInput:
if fld in ["effects"]:
widget.attrs['class'] = 'span10'
else:
widget.attrs['class'] = 'span12'
helper.add_fluid_row('system', 4, "span3")
helper.add_fluid_row('effects', 2, "span6")
helper.add_fluid_row('observation_time', 3, "span4")
helper.add_fluid_row('data_reported', 3, "span4")
helper.add_fluid_row('data_type', 3, "span4")
helper.add_fluid_row('response_units', 3, "span4")
helper.add_fluid_row('NOEL', 4, "span3")
helper.add_fluid_row('statistical_test', 3, ["span6", "span3", "span3"])
url = reverse('assessment:effect_tag_create', kwargs={'pk': self.instance.assessment.pk})
helper.addBtnLayout(helper.layout[4], 0, url, "Add new effect tag", "span6")
return helper
def clean(self):
cleaned_data = super().clean()
obs_time = cleaned_data.get("observation_time")
observation_time_units = cleaned_data.get("observation_time_units")
if obs_time is not None and observation_time_units == 0:
err = "If reporting an endpoint-observation time, time-units must be specified."
self.add_error('observation_time_units', err)
if obs_time is None and observation_time_units > 0:
err = "An observation-time must be reported if time-units are specified"
self.add_error('observation_time', err)
def clean_confidence_interval(self):
confidence_interval = self.cleaned_data['confidence_interval']
data_type = self.cleaned_data.get("data_type")
if data_type == "P" and confidence_interval is None:
raise forms.ValidationError("Confidence-interval is required for"
"percent-difference data")
return confidence_interval
def clean_variance_type(self):
data_type = self.cleaned_data.get("data_type")
variance_type = self.cleaned_data.get("variance_type")
if data_type == "C" and variance_type == 0:
raise forms.ValidationError(
"If entering continuous data, the variance type must be SD"
"(standard-deviation) or SE (standard error)")
return variance_type
def clean_response_units(self):
response_units = self.cleaned_data.get("response_units")
data_extracted = self.cleaned_data.get("data_extracted")
if data_extracted and response_units == "":
raise forms.ValidationError("If data is extracted (see checkbox), response-units are required")
return response_units
class ArtistForm(ModelForm):
class Meta:
model = Artist
fields = ('name', 'real_name', 'aliases', 'type', 'country',
'biography', 'main_image', 'd_tags')
def __init__(self, *args, **kwargs):
self.user = kwargs['initial']['user']
self.instance = kwargs['instance']
print self.instance
print self.user.has_perm("alibrary.edit_release")
print self.user.has_perm("alibrary.admin_release", self.instance)
self.label = kwargs.pop('label', None)
super(ArtistForm, self).__init__(*args, **kwargs)
"""
Prototype function, set some fields to readonly depending on permissions
"""
"""
if not self.user.has_perm("alibrary.admin_release", self.instance):
self.fields['catalognumber'].widget.attrs['readonly'] = 'readonly'
"""
self.helper = FormHelper()
self.helper.form_id = "id_feedback_form_%s" % 'asd'
self.helper.form_class = 'form-horizontal'
self.helper.form_method = 'post'
self.helper.form_action = ''
self.helper.form_tag = False
base_layout = Fieldset(
_('General'),
LookupField('name', css_class='input-xlarge'),
LookupField('real_name', css_class='input-xlarge'),
LookupField('type', css_class='input-xlarge'),
LookupField('country', css_class='input-xlarge'),
)
alias_layout = Fieldset(
_('Alias(es)'),
Field('aliases', css_class='input-xlarge'),
Field('members', css_class='input-xlarge'),
)
catalog_layout = Fieldset(
_('Label/Catalog'),
LookupField('label', css_class='input-xlarge'),
LookupField('catalognumber', css_class='input-xlarge'),
LookupField('release_country', css_class='input-xlarge'),
# LookupField('releasedate', css_class='input-xlarge'),
LookupField('releasedate_approx', css_class='input-xlarge'),
)
meta_layout = Fieldset(
'Meta',
LookupField('biography', css_class='input-xxlarge'),
'main_image',
)
tagging_layout = Fieldset(
'Tags',
'd_tags',
)
layout = Layout(
base_layout,
# artist_layout,
meta_layout,
alias_layout,
tagging_layout,
)
self.helper.add_layout(layout)
main_image = forms.Field(widget=FileInput(), required=False)
#releasedate = forms.DateField(required=False,widget=forms.DateInput(format = '%Y-%m-%d'), input_formats=('%Y-%m-%d',))
#releasedate_approx = ApproximateDateFormField(label="Releasedate", required=False)
d_tags = TagField(widget=TagAutocompleteTagIt(max_tags=9),
required=False,
label=_('Tags'))
#name = forms.CharField(widget=selectable.AutoCompleteWidget(ReleaseNameLookup), required=True)
#label = selectable.AutoCompleteSelectField(ReleaseLabelLookup, allow_new=True, required=False)
biography = forms.CharField(widget=PagedownWidget(),
required=False,
help_text="Markdown enabled text")
aliases = selectable.AutoCompleteSelectMultipleField(ArtistLookup,
required=False)
# aliases = make_ajax_field(Artist,'aliases','aliases',help_text=None)
members = selectable.AutoCompleteSelectMultipleField(ArtistLookup,
required=False)
def clean(self, *args, **kwargs):
cd = super(ArtistForm, self).clean()
print "*************************************"
print cd
print "*************************************"
if 'main_image' in cd and cd['main_image'] != None:
try:
ui = cd['main_image']
dj_file = DjangoFile(open(ui.temporary_file_path()),
name='cover.jpg')
cd['main_image'], created = Image.objects.get_or_create(
original_filename='cover_%s.jpg' % self.instance.pk,
file=dj_file,
folder=self.instance.folder,
is_public=True)
except Exception, e:
print e
pass
else:
class IVEndpointFilterForm(forms.Form):
ORDER_BY_CHOICES = (
('experiment__study__short_citation', 'study'),
('name', 'endpoint name'),
('assay_type', 'assay type'),
('effect', 'effect'),
('chemical__name', 'chemical'),
('category__name', 'category'),
('observation_time', 'observation time'),
)
studies = selectable.AutoCompleteSelectMultipleField(
label='Study reference',
lookup_class=InvitroStudyLookup,
help_text="ex: Smith et al. 2010",
required=False)
name = forms.CharField(label='Endpoint name',
widget=selectable.AutoCompleteWidget(
lookups.IVEndpointByAssessmentTextLookup),
help_text="ex: B cells",
required=False)
chemical = forms.CharField(label='Chemical name',
widget=selectable.AutoCompleteWidget(
lookups.RelatedIVChemicalNameLookup),
help_text="ex: PFOA",
required=False)
cas = forms.CharField(label='CAS',
widget=selectable.AutoCompleteWidget(
lookups.RelatedIVChemicalCASLookup),
help_text="ex: 107-02-8",
required=False)
cell_type = forms.CharField(label='Cell type',
widget=selectable.AutoCompleteWidget(
lookups.RelatedIVCellTypeNameLookup),
help_text='ex: HeLa',
required=False)
tissue = forms.CharField(label='Tissue',
widget=selectable.AutoCompleteWidget(
lookups.RelatedIVCellTypeTissueLookup),
help_text='ex: adipocytes',
required=False)
effect = forms.CharField(label='Effect',
widget=selectable.AutoCompleteWidget(
lookups.RelatedIVEndpointEffectLookup),
help_text="ex: gene expression",
required=False)
response_units = forms.CharField(
label='Response units',
widget=selectable.AutoCompleteWidget(
lookups.RelatedIVEndpointResponseUnitsLookup),
help_text="ex: counts",
required=False)
dose_units = forms.ModelChoiceField(queryset=DoseUnits.objects.all(),
required=False)
order_by = forms.ChoiceField(choices=ORDER_BY_CHOICES, )
paginate_by = forms.IntegerField(label='Items per page',
min_value=1,
initial=25,
max_value=10000,
required=False)
def __init__(self, *args, **kwargs):
assessment_id = kwargs.pop('assessment_id')
super().__init__(*args, **kwargs)
for field in self.fields:
if field not in ('dose_units', 'order_by', 'paginate_by'):
self.fields[field].widget.update_query_parameters(
{'related': assessment_id})
self.helper = self.setHelper()
def setHelper(self):
# by default take-up the whole row-fluid
for fld in list(self.fields.keys()):
widget = self.fields[fld].widget
if type(widget) not in [
forms.CheckboxInput, forms.CheckboxSelectMultiple
]:
widget.attrs['class'] = 'span12'
helper = BaseFormHelper(self)
helper.form_method = "GET"
helper.form_class = None
helper.add_fluid_row('studies', 4, "span3")
helper.add_fluid_row('cell_type', 4, "span3")
helper.add_fluid_row('dose_units', 4, "span3")
helper.layout.append(
cfb.FormActions(cfl.Submit('submit', 'Apply filters'), ))
return helper
def get_query(self):
studies = self.cleaned_data.get('studies')
name = self.cleaned_data.get('name')
chemical = self.cleaned_data.get('chemical')
cas = self.cleaned_data.get('cas')
cell_type = self.cleaned_data.get('cell_type')
tissue = self.cleaned_data.get('tissue')
effect = self.cleaned_data.get('effect')
response_units = self.cleaned_data.get('response_units')
dose_units = self.cleaned_data.get('dose_units')
query = Q()
if studies:
query &= Q(experiment__study__in=studies)
if name:
query &= Q(name__icontains=name)
if chemical:
query &= Q(chemical__name__icontains=chemical)
if cas:
query &= Q(chemical__cas__icontains=cas)
if cell_type:
query &= Q(experiment__cell_type__cell_type__icontains=cell_type)
if tissue:
query &= Q(experiment__cell_type__tissue__icontains=tissue)
if effect:
query &= Q(effect__icontains=effect)
if response_units:
query &= Q(response_units__icontains=response_units)
if dose_units:
query &= Q(experiment__dose_units=dose_units)
return query
def get_order_by(self):
return self.cleaned_data.get('order_by', self.ORDER_BY_CHOICES[0][0])
def get_dose_units_id(self):
if hasattr(self,
"cleaned_data") and self.cleaned_data.get('dose_units'):
return self.cleaned_data.get('dose_units').id
class FruitForm(forms.Form):
autocomplete = forms.CharField(
label='Type the name of a fruit (AutoCompleteWidget)',
widget=selectable.AutoCompleteWidget(FruitLookup),
required=False,
)
newautocomplete = forms.CharField(
label='Type the name of a fruit (AutoCompleteWidget which allows new items)',
widget=selectable.AutoCompleteWidget(FruitLookup, allow_new=True),
required=False,
)
combobox = forms.CharField(
label='Type/select the name of a fruit (AutoComboboxWidget)',
widget=selectable.AutoComboboxWidget(FruitLookup),
required=False,
)
newcombobox = forms.CharField(
label='Type/select the name of a fruit (AutoComboboxWidget which allows new items)',
widget=selectable.AutoComboboxWidget(FruitLookup, allow_new=True),
required=False,
)
# AutoCompleteSelectField (no new items)
autocompleteselect = selectable.AutoCompleteSelectField(
lookup_class=FruitLookup,
label='Select a fruit (AutoCompleteField)',
required=False,
)
# AutoCompleteSelectField (allows new items)
newautocompleteselect = selectable.AutoCompleteSelectField(
lookup_class=FruitLookup,
allow_new=True,
label='Select a fruit (AutoCompleteField which allows new items)',
required=False,
)
# AutoCompleteSelectField (no new items)
comboboxselect = selectable.AutoCompleteSelectField(
lookup_class=FruitLookup,
label='Select a fruit (AutoCompleteSelectField with combobox)',
required=False,
widget=selectable.AutoComboboxSelectWidget
)
# AutoComboboxSelect (allows new items)
newcomboboxselect = selectable.AutoCompleteSelectField(
lookup_class=FruitLookup,
allow_new=True,
label='Select a fruit (AutoCompleteSelectField with combobox which allows new items)',
required=False,
widget=selectable.AutoComboboxSelectWidget
)
# AutoCompleteSelectMultipleField
multiautocompleteselect = selectable.AutoCompleteSelectMultipleField(
lookup_class=FruitLookup,
label='Select a fruit (AutoCompleteSelectMultipleField)',
required=False,
)
# AutoComboboxSelectMultipleField
multicomboboxselect = selectable.AutoCompleteSelectMultipleField(
lookup_class=FruitLookup,
label='Select a fruit (AutoCompleteSelectMultipleField with combobox)',
required=False,
widget=selectable.AutoComboboxSelectMultipleWidget
)
# AutoComboboxSelectMultipleField with disabled attribute
disabledmulticomboboxselect = selectable.AutoCompleteSelectMultipleField(
lookup_class=FruitLookup,
label='Disabled Selectable field',
required=False,
widget=selectable.AutoComboboxSelectMultipleWidget,
initial={'1', '2'},
)
def __init__(self, *args, **kwargs):
super(FruitForm, self).__init__(*args, **kwargs)
self.fields['disabledmulticomboboxselect'].widget.attrs['disabled'] = 'disabled'
class IVEndpointFilterForm(forms.Form):
ORDER_BY_CHOICES = (
("experiment__study__short_citation", "study"),
("experiment__name", "experiment name"),
("name", "endpoint name"),
("assay_type", "assay type"),
("effect", "effect"),
("chemical__name", "chemical"),
("category__name", "category"),
("observation_time", "observation time"),
("experiment__dose_units_id", "dose units"),
("response_units", "response units"),
)
studies = selectable.AutoCompleteSelectMultipleField(
label="Study reference",
lookup_class=InvitroStudyLookup,
help_text="ex: Smith et al. 2010",
required=False,
)
name = forms.CharField(
label="Endpoint name",
widget=selectable.AutoCompleteWidget(
lookups.IVEndpointByAssessmentTextLookup),
help_text="ex: B cells",
required=False,
)
chemical = forms.CharField(
label="Chemical name",
widget=selectable.AutoCompleteWidget(
lookups.RelatedIVChemicalNameLookup),
help_text="ex: PFOA",
required=False,
)
cas = forms.CharField(
label="CAS",
widget=selectable.AutoCompleteWidget(
lookups.RelatedIVChemicalCASLookup),
help_text="ex: 107-02-8",
required=False,
)
cell_type = forms.CharField(
label="Cell type",
widget=selectable.AutoCompleteWidget(
lookups.RelatedIVCellTypeNameLookup),
help_text="ex: HeLa",
required=False,
)
tissue = forms.CharField(
label="Tissue",
widget=selectable.AutoCompleteWidget(
lookups.RelatedIVCellTypeTissueLookup),
help_text="ex: adipocytes",
required=False,
)
effect = forms.CharField(
label="Effect",
widget=selectable.AutoCompleteWidget(
lookups.RelatedIVEndpointEffectLookup),
help_text="ex: gene expression",
required=False,
)
response_units = forms.CharField(
label="Response units",
widget=selectable.AutoCompleteWidget(
lookups.RelatedIVEndpointResponseUnitsLookup),
help_text="ex: counts",
required=False,
)
dose_units = forms.ModelChoiceField(queryset=DoseUnits.objects.all(),
required=False)
order_by = forms.ChoiceField(choices=ORDER_BY_CHOICES, )
paginate_by = forms.IntegerField(label="Items per page",
min_value=1,
initial=25,
max_value=10000,
required=False)
def __init__(self, *args, **kwargs):
assessment = kwargs.pop("assessment")
super().__init__(*args, **kwargs)
for field in self.fields:
if field not in ("dose_units", "order_by", "paginate_by"):
self.fields[field].widget.update_query_parameters(
{"related": assessment.id})
self.helper = self.setHelper()
def setHelper(self):
# by default take-up the whole row-fluid
for fld in list(self.fields.keys()):
widget = self.fields[fld].widget
if type(widget) not in [
forms.CheckboxInput, forms.CheckboxSelectMultiple
]:
widget.attrs["class"] = "span12"
helper = BaseFormHelper(self)
helper.form_method = "GET"
helper.form_class = None
helper.add_fluid_row("studies", 4, "span3")
helper.add_fluid_row("cell_type", 4, "span3")
helper.add_fluid_row("dose_units", 4, "span3")
helper.layout.append(
cfb.FormActions(cfl.Submit("submit", "Apply filters"), ))
return helper
def get_query(self):
studies = self.cleaned_data.get("studies")
name = self.cleaned_data.get("name")
chemical = self.cleaned_data.get("chemical")
cas = self.cleaned_data.get("cas")
cell_type = self.cleaned_data.get("cell_type")
tissue = self.cleaned_data.get("tissue")
effect = self.cleaned_data.get("effect")
response_units = self.cleaned_data.get("response_units")
dose_units = self.cleaned_data.get("dose_units")
query = Q()
if studies:
query &= Q(experiment__study__in=studies)
if name:
query &= Q(name__icontains=name)
if chemical:
query &= Q(chemical__name__icontains=chemical)
if cas:
query &= Q(chemical__cas__icontains=cas)
if cell_type:
query &= Q(experiment__cell_type__cell_type__icontains=cell_type)
if tissue:
query &= Q(experiment__cell_type__tissue__icontains=tissue)
if effect:
query &= Q(effect__icontains=effect)
if response_units:
query &= Q(response_units__icontains=response_units)
if dose_units:
query &= Q(experiment__dose_units=dose_units)
return query
def get_order_by(self):
return self.cleaned_data.get("order_by", self.ORDER_BY_CHOICES[0][0])
def get_dose_units_id(self):
if hasattr(self,
"cleaned_data") and self.cleaned_data.get("dose_units"):
return self.cleaned_data.get("dose_units").id
