class MeasurementFilter(filters.FilterSet):
active = django_filters.BooleanFilter(field_name="active")
created_before = django_filters.IsoDateTimeFilter(
field_name="update_ref__mod_time", lookup_expr="lte"
)
created_after = django_filters.IsoDateTimeFilter(
field_name="update_ref__mod_time", lookup_expr="gte"
)
compartment = django_filters.ChoiceFilter(
field_name="compartment", choices=models.Measurement.Compartment.CHOICE
)
line = django_filters.ModelChoiceFilter(
field_name="assay__line", queryset=models.Line.objects.all()
)
measurement_format = django_filters.ChoiceFilter(
field_name="measurement_format", choices=models.Measurement.Format.CHOICE
)
class Meta:
model = models.Measurement
fields = {
"assay": ["exact", "in"],
"measurement_type": ["exact", "in"],
"x_units": ["exact", "in"],
"y_units": ["exact", "in"],
}
class productFilters(django_filters.FilterSet):
CHOICE = [('avgScore', 'avgScore'), ('dateTime', 'dateTime')]
ordering = django_filters.ChoiceFilter(label='ordering',
choices=CHOICE,
method='filter_by_order')
def filter_by_order(self, queryset, name, value):
expression = '-avgScore' if value == 'avgScore' else '-dtm_crt'
return queryset.order_by(expression)
brandList = Brand.objects.order_by('brandName').all()
brand_choice = [[obj.brandId, obj.brandName] for obj in brandList]
categoryList = Category.objects.order_by('categoryName').all()
category_choice = [[obj.categoryId, obj.categoryName]
for obj in categoryList]
productName = filters.CharFilter(label='Product Name',
lookup_expr='icontains')
brandId = filters.ChoiceFilter(
label='Brand Name',
choices=brand_choice,
widget=forms.Select(attrs={'class': 'chosen'}))
categoryId = filters.ChoiceFilter(label='Category',
choices=category_choice)
class Meta:
model = Product
fields = ['productName', 'brandId', 'categoryId']
class SubmissionFilter(FilterSet):
SHORTLIST = (
('not-shortlisted', _("未入选")),
('shortlisted', _("已入选")),
)
first_name = filters.CharFilter(field_name='submissionUserId__firstNameEN',
lookup_expr='istartswith',
label=_("英文名"))
last_name = filters.CharFilter(field_name='submissionUserId__lastNameEN',
lookup_expr='istartswith',
label=_("英文姓"))
device_type = filters.ChoiceFilter(field_name='deviceType',
choices=models.Submission.DEVICE_CHOICE,
label=_("使用设备"))
category_type = filters.ChoiceFilter(
field_name='categoryType',
choices=models.Submission.CATEGORY_CHOICE,
label=_("题材类型"))
theme_type = filters.ChoiceFilter(field_name='themeType',
choices=models.Submission.THEME_CHOICE,
label=('主题类型'))
shortlist_status = filters.ChoiceFilter(field_name='shortlistType',
choices=SHORTLIST,
label=_("是否入选"),
method="pesudo_filter")
def pesudo_filter(self, queryset, name, value):
return queryset
class MeasurementFilter(filters.FilterSet):
active = django_filters.BooleanFilter(name='active')
created_before = django_filters.IsoDateTimeFilter(
name='update_ref__mod_time',
lookup_expr='lte',
)
created_after = django_filters.IsoDateTimeFilter(
name='update_ref__mod_time',
lookup_expr='gte',
)
compartment = django_filters.ChoiceFilter(
name='compartment',
choices=models.Measurement.Compartment.CHOICE,
)
line = django_filters.ModelChoiceFilter(
name='assay__line',
queryset=models.Line.objects.all(),
)
measurement_format = django_filters.ChoiceFilter(
name='measurement_format',
choices=models.Measurement.Format.CHOICE,
)
class Meta:
model = models.Measurement
fields = {
'assay': ['exact', 'in'],
'measurement_type': ['exact', 'in'],
'x_units': ['exact', 'in'],
'y_units': ['exact', 'in']
}
class SaleFilter(FilterSet):
sale_date_year = filters.ChoiceFilter(
field_name="sale_date", lookup_expr='year', label='年検索', choices=YEAR_CHOICES)
sale_date_month = filters.ChoiceFilter(
field_name="sale_date", lookup_expr='month', label='月検索', choices=MONTH_CHOICES)
class Meta:
model = Sale
fields = ('store', 'sale_date_year', 'sale_date_month',)
class DisplaySubmissionFilter(FilterSet):
device_type = filters.ChoiceFilter(field_name='deviceType',
choices=models.Submission.DEVICE_CHOICE,
label=_("使用设备"))
category_type = filters.ChoiceFilter(
field_name='categoryType',
choices=models.Submission.CATEGORY_CHOICE,
label=_("题材类型"))
theme_type = filters.ChoiceFilter(field_name='themeType',
choices=models.Submission.THEME_CHOICE,
label=('主题类型'))
class MovieFilter(FilterSet):
movi_character_id = filters.ChoiceFilter(('first'), ('3fa85f64-5717-4562-b3fc-2c963f66afa6'))
movi_director = filters.ChoiceFilter(lookup_expr='eq')
movi_producers = filters.ChoiceFilter(lookup_expr='eq')
movi_planet_id = filters.CharFilter(lookup_expr='eq')
class Meta:
model = MovieModel
fields = [
'movi_character_id',
'movi_director',
'movi_producers',
'movi_planet_id'
]
class NotificationFilter(django_filters.FilterSet):
unread_choices = (
(True, _('unread')),
(False, _('read'))
)
all = filters.ChoiceFilter(name='unread', choices=unread_choices, empty_label=_('All'))
level = filters.ChoiceFilter(name='level', choices=Notification.LEVELS, empty_label=_('Level'))
description = filters.CharFilter(name='description', lookup_expr='contains')
timestamp = filters.DateFromToRangeFilter(name='timestamp', widget=RangeWidget)
class Meta:
model = Notification
fields = []
class ObjectTypeFilterSet(FilterSet):
dataClassification = filters.ChoiceFilter(
field_name="data_classification",
choices=DataClassificationChoices.choices,
help_text=get_help_text("core.ObjectType", "data_classification"),
)
class Meta:
model = ObjectType
fields = ("dataClassification", )
class OrderFilter(FilterSet):
order_cost = filters.RangeFilter(label='фівфів')
order_date = filters.DateFromToRangeFilter()
order_payment = filters.ChoiceFilter(choices=Order.payment_list)
order_shipment = filters.ChoiceFilter(choices=Order.shipment_list)
order_status = filters.MultipleChoiceFilter(choices=Order.status_list)
def filter_search(self, qs, search, value):
search_fields = Q(order_number__icontains=value) | Q(
orderitem__product__name__icontains=value)
result = qs.filter(search_fields).distinct()
return result
search = filters.CharFilter(method='filter_search')
#qs = Order.objects.filter(user=?)
class Meta:
model = Order
fields = ['id']
class ItemFilter(FilterSet):
station_name= filters.CharFilter(label='駅名', lookup_expr='contains')
furigana = filters.CharFilter(label='ふりがな', lookup_expr='contains')
organization1 = filters.ChoiceFilter(choices=Item.OGName_CHICES)
organization2 = filters.ChoiceFilter(choices=Item.OGName_CHICES)
organization3 = filters.ChoiceFilter(choices=Item.OGName_CHICES)
organization4 = filters.ChoiceFilter(choices=Item.OGName_CHICES)
organization5 = filters.ChoiceFilter(choices=Item.OGName_CHICES)
organization6 = filters.ChoiceFilter(choices=Item.OGName_CHICES)
memo = filters.CharFilter(label='備考', lookup_expr='contains')
order_by = MyOrderingFilter(
# tuple-mapping retains order
fields=(
('station_name', 'station_name'),
('furigana', 'furigana'),
),
field_labels={
'station_name': '駅名',
'furigana': 'ふりがな',
},
label='並び順'
)
class Meta:
model = Item
fields = ('station_name', 'furigana', 'organization1', 'organization2', 'organization3', 'organization4', 'organization5', 'organization6', 'memo',)
class OrderFilter(FilterSet):
start_date = filters.DateTimeFilter(
field_name='order_created_datetime', lookup_expr='lt', input_formats=['%d-%m-%Y %H:%M']
)
end_date = filters.DateTimeFilter(
field_name='order_created_datetime', lookup_expr='gt', input_formats=['%d-%m-%Y %H:%M']
)
date_range = filters.DateRangeFilter(field_name='order_created_datetime')
status = filters.ChoiceFilter(field_name='status', choices=StatusChoice.choices())
class Meta:
model = Order
fields = ['start_date', 'end_date', 'date_range', 'status']
class ItemFilter(FilterSet):
mon = filters.ChoiceFilter(label='提出月', lookup_expr='contains')
name = filters.CharFilter(label='氏名', lookup_expr='contains')
order_by = MyOrderingFilter(
# tuple-mapping retains order
fields=(
('mon', '提出月'),
('name', '氏名'),
),
field_labels={
'mon': '提出年月',
'name': '氏名',
},
label='並び順'
)
class DataHistoryFilter(rest_framework.FilterSet):
content_type_name = filters.ChoiceFilter(method='filter_by_content_type',
choices=[
('device', 'Dispositivo'),
('sensor', 'Sensor'),
('actuator', 'Actuador'),
('controller', 'Controlador')
])
def filter_by_content_type(self, queryset, key, value, *args, **kwargs):
ct = ContentType.objects.get(model=value)
return queryset.filter(content_type=ct)
class Meta:
model = DataHistory
fields = ['content_type_name', 'object_id']
class AllSightingFilter(MultiOrderFilterSet):
year = filters.ChoiceFilter(required=False,
choices=year_choices,
widget=forms.Select(
attrs={
'style': 'width: 200px',
'data-placeholder': 'Filter by Year',
'class': 'chosen-select-deselect'
}))
make = filters.CharFilter(required=False,
widget=forms.TextInput(
attrs={
'style': 'width: 200px; height: 28px;',
'placeholder': 'Filter by Make',
'class': ''
}))
model = filters.CharFilter(required=False,
widget=forms.TextInput(
attrs={
'style': 'width: 200px; height: 28px;',
'placeholder': 'Filter by Model',
'class': ''
}))
class Meta:
model = Sighting
fields = [
'make',
'model',
'year',
]
order_by = [
'make',
'-make',
'model',
'-model',
'year',
'-year',
'frame_number',
'-frame_number',
'engine_number',
'-engine_number',
]
class AnalysisJobFilter(RunFilter):
accession = django_filters.CharFilter(
method='filter_analysisjob_accession',
distinct=True,
label='Analyses job accession',
help_text='Analyses job accession')
def filter_analysisjob_accession(self, qs, name, value):
return qs.filter(*emg_utils.analysisjob_accession_query(value))
pipeline_version = filters.ChoiceFilter(
choices=pipeline_version,
field_name='pipeline__release_version',
distinct=True,
label='Pipeline version',
help_text='Pipeline version')
class Meta:
model = emg_models.AnalysisJob
fields = ('biome_name', 'lineage', 'experiment_type', 'species',
'sample_accession', 'pipeline_version')
class MetadataTypesFilter(filters.FilterSet):
for_context = django_filters.ChoiceFilter(
choices=models.MetadataType.CONTEXT_SET,
field_name="for_context",
help_text=_(
"Context for metadata, 'S' for metadata on a Study, "
"'L' for metadata on a Line, 'A' for metadata on an Assay."),
)
group = django_filters.CharFilter(
field_name="group__group_name",
help_text=_(
"Runs a regular expression search on the metadata type group name"
),
lookup_expr="iregex",
)
in_study = django_filters.CharFilter(
help_text=_("An identifier for the study; can use ID, UUID, or Slug"),
method="used_in_study",
)
class Meta:
model = models.MetadataType
fields = ["id"]
def used_in_study(self, queryset, name, value):
# lines and assays in the study
lines = filter_in_study(models.Line.objects.all(), name, value)
assays = filter_in_study(models.Assay.objects.all(), name, value)
# define the keys used in metadata
keys_field = Func(F("metadata"), function="jsonb_object_keys")
# make sure the keys are integers
keys = Cast(keys_field, IntegerField())
# get the distinct keys used
line_keys_qs = lines.values_list(keys, flat=True).distinct()
assay_keys_qs = assays.values_list(keys, flat=True).distinct()
keys_qs = line_keys_qs.union(assay_keys_qs)
# get all keys used in the study
return queryset.filter(pk__in=keys_qs)
class MeasurementTypesFilter(filters.FilterSet):
type_name = django_filters.CharFilter(
field_name="type_name",
help_text=_(
"Runs a regular expression search on the measurement type name"),
lookup_expr="iregex",
)
type_group = django_filters.ChoiceFilter(
choices=models.MeasurementType.Group.GROUP_CHOICE,
field_name="type_group",
help_text=_("One of the measurement type codes: '_', 'm', 'g', 'p'"),
)
in_study = django_filters.CharFilter(
help_text=_("An identifier for the study; can use ID, UUID, or Slug"),
method="used_in_study",
)
class Meta:
model = models.MeasurementType
fields = []
def used_in_study(self, queryset, name, value):
pk = fuzzy_study_subquery(value)
return queryset.filter(measurement__study_id__in=pk).distinct()
class PublicationFilter(django_filters.FilterSet):
doi = django_filters.CharFilter(field_name='doi',
distinct=True,
label='DOI',
help_text='DOI')
isbn = django_filters.CharFilter(field_name='isbn',
distinct=True,
label='ISBN',
help_text='ISBN')
published_year = filters.ChoiceFilter(choices=published_year,
field_name='published_year',
distinct=True,
label='Published year',
help_text='Published year')
# include
include = django_filters.CharFilter(
method='filter_include',
distinct=True,
label='Include',
help_text='Include related studies in the same response')
def filter_include(self, qs, name, value):
return qs
class Meta:
model = emg_models.Publication
fields = (
'doi',
'isbn',
'published_year',
'include',
)
class InvoiceFilter(FilterSet):
customer = filters.CharFilter(name='customer',
label='顧客名',
lookup_expr='contains')
created_by = filters.ChoiceFilter(
name='created_by',
label='担当者',
choices=lambda: [(user.id, user.get_full_name())
for user in User.objects.all()])
order_by = MyOrderingFilter(
# tuple-mapping retains order
fields=(('created_at', 'created_at'), ),
field_labels={
'created_at': '登録時間',
},
label='並び順')
class Meta:
model = Invoice
fields = (
'customer',
'created_by',
)
class LearningUnitFilter(FilterSet):
academic_year = filters.ModelChoiceFilter(
queryset=AcademicYear.objects.all(),
required=False,
label=_('Ac yr.'),
empty_label=pgettext_lazy("plural", "All"),
)
acronym = filters.CharFilter(
field_name="acronym",
lookup_expr="iregex",
max_length=40,
required=False,
label=_('Code'),
)
requirement_entity = filters.CharFilter(
method='filter_entity',
max_length=20,
label=_('Req. Entity'),
)
allocation_entity = filters.CharFilter(
method='filter_entity',
max_length=20,
label=_('Alloc. Entity'),
)
with_entity_subordinated = filters.BooleanFilter(
method=lambda queryset, *args, **kwargs: queryset,
label=_('Include subordinate entities'),
widget=forms.CheckboxInput,
initial='True'
)
tutor = filters.CharFilter(
method="filter_tutor",
max_length=40,
label=_('Tutor'),
)
quadrimester = filters.ChoiceFilter(
choices=quadrimesters.LEARNING_UNIT_YEAR_QUADRIMESTERS,
required=False,
field_name="quadrimester",
label=_('Quadri'),
empty_label=pgettext_lazy("plural", "All"),
)
container_type = filters.ChoiceFilter(
choices=LearningContainerYearType.choices() + MOBILITY_CHOICE,
required=False,
field_name="learning_container_year__container_type",
label=_('Type'),
empty_label=pgettext_lazy("plural", "All"),
method="filter_container_type"
)
subtype = filters.ChoiceFilter(
choices=learning_unit_year_subtypes.LEARNING_UNIT_YEAR_SUBTYPES,
required=False,
field_name="subtype",
label=_('Subtype'),
empty_label=pgettext_lazy("plural", "All")
)
status = filters.ChoiceFilter(
choices=active_status.ACTIVE_STATUS_LIST_FOR_FILTER,
required=False,
label=_('Status'),
field_name="status",
empty_label=pgettext_lazy("plural", "All")
)
title = filters.CharFilter(
field_name="full_title",
method="filter_learning_unit_year_field",
max_length=40,
label=_('Title'),
)
search_type = filters.CharFilter(
field_name="acronym",
method=lambda request, *args, **kwargs: request,
widget=forms.HiddenInput,
required=False,
initial=SearchTypes.SIMPLE_SEARCH.value
)
order_by_field = 'ordering'
ordering = OrderingFilter(
fields=(
('academic_year__year', 'academic_year'),
('acronym', 'acronym'),
('full_title', 'title'),
('learning_container_year__container_type', 'type'),
('subtype', 'subtype'),
('entity_requirement', 'requirement_entity'),
('entity_allocation', 'allocation_entity'),
('credits', 'credits'),
('status', 'status'),
('has_proposal', 'has_proposal'),
),
widget=forms.HiddenInput
)
class Meta:
model = LearningUnitYear
fields = [
"academic_year",
"acronym",
"title",
"container_type",
"subtype",
"requirement_entity",
"allocation_entity",
"credits",
"status",
]
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.queryset = self.get_queryset()
self.form.fields["academic_year"].initial = starting_academic_year()
def filter_tutor(self, queryset, name, value):
for tutor_name in value.split():
queryset = queryset.filter(
Q(learningcomponentyear__attributionchargenew__attribution__tutor__person__first_name__iregex=tutor_name
) |
Q(learningcomponentyear__attributionchargenew__attribution__tutor__person__last_name__iregex=tutor_name)
).distinct()
return queryset
def filter_container_type(self, queryset, name, value):
if value == MOBILITY:
return queryset.filter(externallearningunityear__mobility=True)
elif value == learning_container_year_types.EXTERNAL:
return queryset.filter(externallearningunityear__co_graduation=True)
return queryset.filter(learning_container_year__container_type=value)
def filter_entity(self, queryset, name, value):
return filter_by_entities(name, queryset, value, self.form.cleaned_data['with_entity_subordinated'])
def get_queryset(self):
# Need this close so as to return empty query by default when form is unbound
if not self.data:
return LearningUnitYear.objects.none()
has_proposal = ProposalLearningUnit.objects.filter(
learning_unit_year=OuterRef('pk'),
)
queryset = LearningUnitYear.objects_with_container.select_related(
'academic_year',
'learning_container_year__academic_year',
'language',
'proposallearningunit',
'externallearningunityear'
).order_by('academic_year__year', 'acronym').annotate(
has_proposal=Exists(has_proposal),
)
queryset = LearningUnitYearQuerySet.annotate_full_title_class_method(queryset)
queryset = LearningUnitYearQuerySet.annotate_entities_allocation_and_requirement_acronym(queryset)
return queryset
def filter_learning_unit_year_field(self, queryset, name, value):
return filter_field_by_regex(queryset, name, value)
class StatusMessageTemplateFilterSet(FilterSet):
state = filters.ChoiceFilter(choices=status_choices)
order_by = OrderingFilter(fields=(('order', 'order')))
class EducationGroupFilter(FilterSet):
academic_year = filters.ModelChoiceFilter(
queryset=AcademicYear.objects.all(),
required=False,
empty_label=pgettext_lazy("plural", "All"),
label=_('Ac yr.'))
category = filters.ChoiceFilter(
choices=list(Categories.choices()),
required=False,
label=_('Category'),
field_name='education_group_type__category',
empty_label=pgettext_lazy("plural", "All"))
education_group_type = filters.ModelChoiceFilter(
queryset=EducationGroupType.objects.none(),
required=False,
empty_label=pgettext_lazy("plural", "All"),
label=_('Type'),
widget=SelectWithData)
management_entity = filters.CharFilter(
method='filter_with_entity_subordinated', label=_('Entity'))
with_entity_subordinated = filters.BooleanFilter(
method=lambda queryset, *args, **kwargs: queryset,
label=_('With subord. ent.'),
widget=forms.CheckboxInput)
acronym = filters.CharFilter(
field_name="acronym",
lookup_expr='icontains',
max_length=40,
required=False,
label=_('Acronym/Short title'),
)
title = filters.CharFilter(field_name="title",
lookup_expr='icontains',
max_length=255,
required=False,
label=_('Title'))
partial_acronym = filters.CharFilter(
field_name="partial_acronym",
lookup_expr='icontains',
max_length=15,
required=False,
label=_('Code'),
)
order_by_field = 'ordering'
ordering = OrderingFilter(
fields=(('acronym', 'acronym'), ('partial_acronym', 'code'),
('academic_year__year', 'academic_year'), ('title', 'title'),
('education_group_type__name',
'type'), ('management_entity__entityversion__acronym',
'management_entity')),
widget=forms.HiddenInput)
class Meta:
model = EducationGroupYear
fields = [
'acronym',
'partial_acronym',
'title',
'education_group_type__name',
'management_entity',
'with_entity_subordinated',
]
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.form.fields[
'education_group_type'].queryset = EducationGroupType.objects.all(
).order_by_translated_name()
self.form.fields['academic_year'].initial = current_academic_year()
self.form.fields[
'category'].initial = education_group_categories.TRAINING
def filter_with_entity_subordinated(self, queryset, name, value):
with_subordinated = self.form.cleaned_data['with_entity_subordinated']
if value:
entity_ids = get_entities_ids(value, with_subordinated)
queryset = queryset.filter(management_entity__in=entity_ids)
return queryset
'caller',
'created',
'started',
'ended',
'status',
], ),
crudlfap.DetailView,
],
).register()
crudlfap.Router(
Caller,
material_icon='assignment_ind',
views=[
crudlfap.ListView.clone(
filterset_extra_class_attributes=dict(status=filters.ChoiceFilter(
choices=Caller.STATUS_CHOICES)),
table_fields=[
'id',
'callback',
'spooled',
'status',
],
search_fields=[
'callback',
],
),
crudlfap.UpdateView,
crudlfap.DeleteObjectsView,
crudlfap.DeleteView,
crudlfap.DetailView,
]).register()
class SampleFilter(FilterSet):
gut_usage = filters.ChoiceFilter(choices=make_choice('gut_usage'))
sample_phylum = filters.ChoiceFilter(choices=make_choice('sample_phylum'))
sample_class = filters.ChoiceFilter(choices=make_choice('sample_class'))
sample_order = filters.ChoiceFilter(choices=make_choice('sample_order'))
sample_family = filters.ChoiceFilter(choices=make_choice('sample_family'))
sample_genus = filters.ChoiceFilter(choices=make_choice('sample_genus'))
sample_species = filters.ChoiceFilter(
choices=make_choice('sample_species'))
sample_subspecies = filters.ChoiceFilter(
choices=make_choice('sample_subspecies'))
sample_breed = filters.ChoiceFilter(choices=make_choice('sample_breed'))
identifier_name = filters.ChoiceFilter(
choices=make_choice('identifier_name'))
exact_site = filters.ChoiceFilter(choices=make_choice('exact_site'))
continent_ocean = filters.ChoiceFilter(
choices=make_choice('continent_ocean'))
country = filters.ChoiceFilter(choices=make_choice('country'))
state_province = filters.ChoiceFilter(
choices=make_choice('state_province'))
city = filters.ChoiceFilter(choices=make_choice('city'))
county = filters.ChoiceFilter(choices=make_choice('county'))
latitude = filters.ChoiceFilter(choices=make_choice('latitude'))
longitude = filters.ChoiceFilter(choices=make_choice('longitude'))
elevation = filters.ChoiceFilter(choices=make_choice('elevation'))
collector_name = filters.ChoiceFilter(
choices=make_choice('collector_name'))
class Meta:
model = Sample
fields = '__all__'
class EducationGroupFilter(FilterSet):
academic_year = filters.ModelChoiceFilter(
queryset=AcademicYear.objects.all(),
required=False,
label=_('Ac yr.'),
empty_label=pgettext_lazy("plural", "All"),
)
category = filters.ChoiceFilter(
choices=list(Categories.choices()),
required=False,
label=_('Category'),
field_name='education_group_type__category',
empty_label=pgettext_lazy("plural", "All"))
education_group_type = filters.ModelMultipleChoiceFilter(
queryset=EducationGroupType.objects.none(),
required=False,
label=_('Type'),
widget=autocomplete.ModelSelect2Multiple(
url='education_group_type_autocomplete',
forward=['category'],
),
)
management_entity = filters.CharFilter(
method='filter_with_entity_subordinated', label=_('Entity'))
with_entity_subordinated = filters.BooleanFilter(
method=lambda queryset, *args, **kwargs: queryset,
label=_('Include subordinate entities'),
widget=forms.CheckboxInput)
acronym = filters.CharFilter(
field_name="acronym",
method="filter_education_group_year_field",
max_length=40,
required=False,
label=_('Acronym/Short title'),
)
title = filters.CharFilter(field_name="title",
method='filter_education_group_year_field',
max_length=255,
required=False,
label=_('Title'))
partial_acronym = filters.CharFilter(
field_name="partial_acronym",
method='filter_education_group_year_field',
max_length=15,
required=False,
label=_('Code'),
)
order_by_field = 'ordering'
ordering = OrderingFilter(
fields=(('acronym', 'acronym'), ('partial_acronym', 'code'),
('academic_year__year', 'academic_year'), ('title', 'title'),
('type_ordering', 'type'), ('entity_management_version',
'management_entity')),
widget=forms.HiddenInput)
class Meta:
model = EducationGroupYear
fields = [
'acronym',
'partial_acronym',
'title',
'education_group_type__name',
'management_entity',
'with_entity_subordinated',
]
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.queryset = self.get_queryset()
self.form.fields[
'education_group_type'].queryset = EducationGroupType.objects.all(
).order_by_translated_name()
self.form.fields['academic_year'].initial = starting_academic_year()
self.form.fields[
'category'].initial = education_group_categories.TRAINING
self.form.fields["with_entity_subordinated"].initial = kwargs.pop(
'with_entity_subordinated', True)
def filter_with_entity_subordinated(self, queryset, name, value):
with_subordinated = self.form.cleaned_data['with_entity_subordinated']
if value:
entity_ids = get_entities_ids(value, with_subordinated)
queryset = queryset.filter(management_entity__in=entity_ids)
return queryset
@staticmethod
def filter_education_group_year_field(queryset, name, value):
return filter_field_by_regex(queryset, name, value)
def get_queryset(self):
# Need this close so as to return empty query by default when form is unbound
if not self.data:
return EducationGroupYear.objects.none()
management_entity = entity_version.EntityVersion.objects.filter(
entity=OuterRef('management_entity'), ).current(
OuterRef('academic_year__start_date')).values('acronym')[:1]
return EducationGroupYear.objects.all().annotate(type_ordering=Case(
*[
When(education_group_type__name=key, then=Value(str(_(val))))
for i, (key, val) in enumerate(education_group_types.ALL_TYPES)
],
default=Value(''),
output_field=CharField())).annotate(
entity_management_version=Subquery(management_entity))
def filter_queryset(self, queryset):
# Order by id to always ensure same order when objects have same values for order field (ex: title)
qs = super().filter_queryset(queryset)
order_fields = qs.query.order_by + ('id', )
return qs.order_by(*order_fields)
class QFilter(django_filters.FilterSet):
search = MultiFieldSearchFilter(
name=['qtext', 'answer', 'comment'],
lookup_expr='icontains',
label='Искать',
widget=forms.TextInput(
attrs={
'class': 'form-control',
'placeholder': 'поиск по вопросу, ответу или комментарию'
}))
author = filters.CharFilter(
lookup_expr='icontains',
label='Автор',
widget=forms.TextInput(attrs={
'class': 'form-control',
'placeholder': 'поиск по автору'
}))
q_has_img = filters.ChoiceFilter(
label='Картинка',
widget=forms.Select(
attrs={'class': 'btn btn-default btn-sm dropdown-toggle'}),
choices=((True, 'есть'), (False, 'нет')))
q_has_video = filters.ChoiceFilter(
label='Видео',
widget=forms.Select(
attrs={'class': 'btn btn-default btn-sm dropdown-toggle'}),
choices=((True, 'есть'), (False, 'нет')))
q_has_audio = filters.ChoiceFilter(
label='Аудио',
widget=forms.Select(
attrs={'class': 'btn btn-default btn-sm dropdown-toggle'}),
choices=((True, 'есть'), (False, 'нет')))
q_has_media = filters.ChoiceFilter(
label='Есть медиа',
widget=forms.Select(
attrs={'class': 'btn btn-default btn-sm dropdown-toggle'}),
choices=((True, 'есть'), (False, 'нет')))
is_played = filters.ChoiceFilter(widget=forms.Select(
attrs={'class': 'btn btn-default btn-sm dropdown-toggle'}),
choices=((True, 'да'), (False, 'нет')))
is_bb = filters.ChoiceFilter(widget=forms.Select(
attrs={'class': 'btn btn-default btn-sm dropdown-toggle'}),
choices=((True, 'да'), (False, 'нет')))
wow = filters.ChoiceFilter(widget=forms.Select(
attrs={'class': 'btn btn-sm btn-default dropdown-toggle'}),
choices=(('WOW', 'WOW'), ('-', 'не указано'),
('FOO', 'FOO')))
qtype = filters.ChoiceFilter(
label='Тип вопроса',
widget=forms.Select(
attrs={'class': 'btn btn-sm btn-default dropdown-toggle'}),
choices=(('chgk', 'ЧГК'), ('br', 'Брэйн'), ('tele', 'Теледомик')))
is_blitz = filters.ChoiceFilter(widget=forms.Select(
attrs={'class': 'btn btn-default btn-sm dropdown-toggle'}),
choices=((True, 'да'), (False, 'нет')))
o = filters.OrderingFilter(
fields=(('created_date', 'created_date'), ),
field_labels={
'created_date': 'дата создания',
},
label='Сортировка',
)
class Meta:
model = Question
exclude = [
'qtext', 'answer', 'altanswer', 'comment', 'source',
'created_date', 'qlink1', 'qlink2', 'qlink3', 'alink1', 'alink2',
'alink3'
]
class ProposalLearningUnitFilter(FilterSet):
academic_year = filters.ModelChoiceFilter(
queryset=AcademicYear.objects.all(),
required=False,
label=_('Ac yr.'),
empty_label=pgettext_lazy("plural", "All"),
)
acronym = filters.CharFilter(
field_name="acronym",
lookup_expr="iregex",
max_length=40,
required=False,
label=_('Code'),
)
requirement_entity = filters.CharFilter(
method='filter_entity',
max_length=20,
label=_('Req. Entity'),
)
with_entity_subordinated = filters.BooleanFilter(
method=lambda queryset, *args, **kwargs: queryset,
label=_('Include subordinate entities'),
widget=forms.CheckboxInput,
initial='True')
tutor = filters.CharFilter(
method="filter_tutor",
max_length=40,
label=_('Tutor'),
)
entity_folder = filters.ChoiceFilter(
field_name="proposallearningunit__entity_id",
label=_('Folder entity'),
required=False,
empty_label=pgettext_lazy("plural", "All"),
)
folder = filters.NumberFilter(field_name="proposallearningunit__folder_id",
min_value=0,
required=False,
label=_('Folder num.'),
widget=forms.TextInput())
proposal_type = filters.ChoiceFilter(
field_name="proposallearningunit__type",
label=_('Proposal type'),
choices=_get_sorted_choices(ProposalType.choices()),
required=False,
empty_label=pgettext_lazy("plural", "All"),
)
proposal_state = filters.ChoiceFilter(
field_name="proposallearningunit__state",
label=_('Proposal status'),
choices=_get_sorted_choices(ProposalState.choices()),
required=False,
empty_label=pgettext_lazy("plural", "All"),
)
search_type = filters.CharFilter(
field_name="acronym",
method=lambda request, *args, **kwargs: request,
widget=forms.HiddenInput,
required=False,
initial=SearchTypes.PROPOSAL_SEARCH.value)
order_by_field = 'ordering'
ordering = ProposalLearningUnitOrderingFilter(
fields=(
('academic_year__year', 'academic_year'),
('acronym', 'acronym'),
('full_title', 'title'),
('learning_container_year__container_type', 'type'),
('entity_requirement', 'requirement_entity'),
('proposallearningunit__type', 'proposal_type'),
('proposallearningunit__state', 'proposal_state'),
('proposallearningunit__folder_id',
'folder'), # Overrided by ProposalLearningUnitOrderingFilter
),
widget=forms.HiddenInput)
class Meta:
model = LearningUnitYear
fields = [
"academic_year",
"acronym",
"subtype",
"requirement_entity",
]
def __init__(self, *args, person=None, **kwargs):
super().__init__(*args, **kwargs)
self.person = person
self.queryset = self.get_queryset
self._get_entity_folder_id_linked_ordered_by_acronym(self.person)
# Academic year default value = n+1 for proposals search -> use event having n+1 as first open academic year
event_perm = event_perms.EventPermCreationOrEndDateProposalFacultyManager(
)
self.form.fields[
"academic_year"].initial = event_perm.get_academic_years().first()
def _get_entity_folder_id_linked_ordered_by_acronym(self, person):
most_recent_acronym = EntityVersion.objects.filter(entity__id=OuterRef(
'id'), ).order_by("-start_date").values('acronym')[:1]
entities = Entity.objects.filter(
proposallearningunit__isnull=False).annotate(
entity_acronym=Subquery(
most_recent_acronym)).distinct().order_by("entity_acronym")
self.form.fields['entity_folder'].choices = [
(ent.pk, ent.entity_acronym) for ent in entities
]
def filter_entity(self, queryset, name, value):
with_subordinated = self.form.cleaned_data['with_entity_subordinated']
lookup_expression = "__".join(["learning_container_year", name, "in"])
if value:
entity_ids = get_entities_ids(value, with_subordinated)
queryset = queryset.filter(**{lookup_expression: entity_ids})
return queryset
def filter_tutor(self, queryset, name, value):
for tutor_name in value.split():
filter_by_first_name = Q(
learningcomponentyear__attributionchargenew__attribution__tutor__person__first_name__iregex
=tutor_name)
filter_by_last_name = Q(
learningcomponentyear__attributionchargenew__attribution__tutor__person__last_name__iregex
=tutor_name)
queryset = queryset.filter(filter_by_first_name
| filter_by_last_name).distinct()
return queryset
@property
def get_queryset(self):
# Need this close so as to return empty query by default when form is unbound
if not self.data:
return LearningUnitYear.objects.none()
entity_folder = EntityVersion.objects.filter(
entity=OuterRef('proposallearningunit__entity'), ).current(
OuterRef('academic_year__start_date')).values('acronym')[:1]
has_proposal = ProposalLearningUnit.objects.filter(
learning_unit_year=OuterRef('pk'), )
queryset = LearningUnitYear.objects_with_container.filter(
proposallearningunit__isnull=False).select_related(
'academic_year',
'learning_container_year__academic_year',
'language',
'externallearningunityear',
'campus',
'proposallearningunit',
'campus__organization',
).prefetch_related("learningcomponentyear_set", ).annotate(
has_proposal=Exists(has_proposal),
entity_folder=Subquery(entity_folder),
)
queryset = LearningUnitYearQuerySet.annotate_full_title_class_method(
queryset)
queryset = LearningUnitYearQuerySet.annotate_entities_allocation_and_requirement_acronym(
queryset)
return queryset
class ExternalLearningUnitFilter(FilterSet):
academic_year = filters.ModelChoiceFilter(
queryset=AcademicYear.objects.all(),
required=False,
label=_('Ac yr.'),
empty_label=pgettext_lazy("plural", "All"),
)
acronym = filters.CharFilter(
field_name="acronym",
lookup_expr="iregex",
max_length=40,
required=False,
label=_('Code'),
)
title = filters.CharFilter(
field_name="full_title",
method="filter_learning_unit_year_field",
max_length=40,
label=_('Title'),
)
status = filters.ChoiceFilter(
choices=active_status.ACTIVE_STATUS_LIST_FOR_FILTER,
required=False,
label=_('Status'),
field_name="status",
empty_label=pgettext_lazy("plural", "All"))
country = filters.ModelChoiceFilter(
queryset=Country.objects.filter(
organizationaddress__isnull=False).distinct().order_by('name'),
field_name="campus__organization__organizationaddress__country",
required=False,
label=_("Country"))
city = filters.ChoiceFilter(
choices=BLANK_CHOICE_DASH,
field_name="campus__organization__organizationaddress__city",
required=False,
label=_("City"),
help_text=_("Please select a country first"))
campus = filters.ChoiceFilter(
choices=BLANK_CHOICE_DASH,
required=False,
label=_("Institution"),
help_text=_("Please select a country and a city first"))
search_type = filters.CharFilter(
field_name="acronym",
method=lambda request, *args, **kwargs: request,
widget=forms.HiddenInput,
required=False,
initial=SearchTypes.EXTERNAL_SEARCH.value)
order_by_field = 'ordering'
ordering = OrderingFilter(fields=(
('academic_year__year', 'academic_year'),
('acronym', 'acronym'),
('full_title', 'title'),
('status', 'status'),
('campus__organization__name', 'campus'),
('credits', 'credits'),
),
widget=forms.HiddenInput)
class Meta:
model = LearningUnitYear
fields = [
"academic_year",
"acronym",
"title",
"credits",
"status",
]
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.queryset = self.get_queryset()
self.form.fields["academic_year"].initial = starting_academic_year()
if self.data.get('country'):
self._init_dropdown_list()
def _init_dropdown_list(self):
if self.data.get('country'):
self._init_cities_choices()
if self.data.get('city'):
self._init_campus_choices()
def _init_cities_choices(self):
cities_choices = OrganizationAddress.objects.filter(
country=self.data["country"]).distinct('city').order_by(
'city').values_list('city', 'city')
self.form.fields['city'].choices = cities_choices
def _init_campus_choices(self):
campus_choices = Campus.objects.filter(
organization__organizationaddress__city=self.data['city']
).distinct('organization__name').order_by(
'organization__name').values_list('pk', 'organization__name')
self.form.fields['campus'].choices = campus_choices
def get_queryset(self):
# Need this close so as to return empty query by default when form is unbound
if not self.data:
return LearningUnitYear.objects.none()
has_proposal = ProposalLearningUnit.objects.filter(
learning_unit_year=OuterRef('pk'), )
qs = LearningUnitYear.objects_with_container.filter(
externallearningunityear__co_graduation=True,
externallearningunityear__mobility=False,
).select_related(
'academic_year',
'learning_container_year__academic_year',
'language',
'externallearningunityear',
'campus',
'proposallearningunit',
'campus__organization',
).prefetch_related("learningcomponentyear_set").annotate(
has_proposal=Exists(has_proposal)).order_by(
'academic_year__year', 'acronym')
qs = LearningUnitYearQuerySet.annotate_full_title_class_method(qs)
qs = LearningUnitYearQuerySet.annotate_entities_allocation_and_requirement_acronym(
qs)
return qs
def filter_learning_unit_year_field(self, queryset, name, value):
return filter_field_by_regex(queryset, name, value)
class LearningUnitDescriptionFicheFilter(FilterSet):
academic_year = filters.ModelChoiceFilter(
queryset=AcademicYear.objects.all(), required=True, label=_('Ac yr.'))
acronym = filters.CharFilter(
field_name="acronym",
lookup_expr='icontains',
max_length=40,
required=False,
label=_('Code'),
)
learning_unit_title = filters.CharFilter(
field_name='full_title',
lookup_expr='icontains',
label=_('Title'),
)
container_type = filters.ChoiceFilter(
field_name='learning_container_year__container_type',
choices=LearningContainerYearType.choices() +
((MOBILITY, _('Mobility')), ),
label=_('Type'),
empty_label=pgettext_lazy("plural", "All"))
subtype = filters.ChoiceFilter(
choices=learning_unit_year_subtypes.LEARNING_UNIT_YEAR_SUBTYPES,
label=_('Subtype'),
empty_label=pgettext_lazy("plural", "All"))
status = filters.TypedChoiceFilter(
choices=(('', _("All")), ('true', _("Active")), ('false',
_("Inactive"))),
label=_('Status'),
coerce=strtobool,
)
quadrimester = filters.ChoiceFilter(
choices=quadrimesters.LEARNING_UNIT_YEAR_QUADRIMESTERS,
label=_('Quadri'),
empty_label=pgettext_lazy("plural", "All"))
tutor = filters.CharFilter(
method='filter_tutor',
label=_('Tutor'),
)
requirement_entity = filters.CharFilter(
method='filter_requirement_entity_with_entity_subordinated',
label=_('Req. Entity'))
allocation_entity = filters.CharFilter(
method='filter_allocation_entity_with_entity_subordinated',
label=_('Alloc. Ent.'))
with_entity_subordinated = filters.BooleanFilter(
method=lambda queryset, *args, **kwargs: queryset,
label=_('Include subordinate entities'),
widget=forms.CheckboxInput)
class Meta:
model = LearningUnitYear
fields = []
def __init__(self, data=None, queryset=None, *, request=None, prefix=None):
translated_text_qs = TranslatedText.objects.filter(
entity=LEARNING_UNIT_YEAR,
text_label__label__in=CMS_LABEL_PEDAGOGY,
changed__isnull=False,
reference=OuterRef('pk')).order_by("-changed")
queryset = LearningUnitYear.objects.all().annotate(
full_title=Case(
When(Q(learning_container_year__common_title__isnull=True)
| Q(learning_container_year__common_title__exact=''),
then='specific_title'),
When(Q(specific_title__isnull=True)
| Q(specific_title__exact=''),
then='learning_container_year__common_title'),
default=Concat('learning_container_year__common_title',
Value(' - '), 'specific_title'),
output_field=CharField(),
),
last_translated_text_changed=Subquery(
translated_text_qs.values('changed')[:1]),
)
super(LearningUnitDescriptionFicheFilter, self).__init__(
data=data,
queryset=queryset,
request=request,
prefix=prefix,
)
self.form.fields['academic_year'].initial = starting_academic_year()
self.form.fields['with_entity_subordinated'].initial = True
def filter_tutor(self, queryset, name, value):
return queryset.filter(
Q(learningcomponentyear__attributionchargenew__attribution__tutor__person__first_name__icontains
=value)
|
Q(learningcomponentyear__attributionchargenew__attribution__tutor__person__last_name__icontains
=value))
def filter_requirement_entity_with_entity_subordinated(
self, queryset, name, value):
with_subordinated = self.form.cleaned_data['with_entity_subordinated']
if value:
entity_ids = get_entities_ids(value, with_subordinated)
queryset = queryset.filter(
learning_container_year__requirement_entity__in=entity_ids)
return queryset
def filter_allocation_entity_with_entity_subordinated(
self, queryset, name, value):
with_subordinated = self.form.cleaned_data['with_entity_subordinated']
if value:
entity_ids = get_entities_ids(value, with_subordinated)
queryset = queryset.filter(
learning_container_year__allocation_entity__in=entity_ids)
return queryset
@property
def qs(self):
queryset = super(LearningUnitDescriptionFicheFilter, self).qs
if self.is_bound:
queryset = self._compute_summary_status(queryset)
queryset = queryset.select_related(
'learning_container_year__academic_year', 'academic_year')
return queryset
def _compute_summary_status(self, queryset):
"""
This function will compute the summary status. First, we will take the entity calendar
(or entity calendar parent and so one) of the requirement entity. If not found, the summary status is
computed with the general Academic Calendar Object
"""
entity_calendars_computed = entity_calendar.build_calendar_by_entities(
self.form.cleaned_data['academic_year'].past(),
SUMMARY_COURSE_SUBMISSION,
)
requirement_entities_ids = queryset.values_list(
'learning_container_year__requirement_entity', flat=True)
summary_status_case_statment = [
When(last_translated_text_changed__isnull=True, then=False)
]
for requirement_entity_id in set(requirement_entities_ids):
start_summary_course_submission = entity_calendars_computed.get(
requirement_entity_id, {}).get('start_date')
if start_summary_course_submission is None:
continue
summary_status_case_statment.append(
When(learning_container_year__requirement_entity=
requirement_entity_id,
last_translated_text_changed__gte=
start_summary_course_submission,
then=True))
queryset = queryset.annotate(
summary_status=Case(*summary_status_case_statment,
default=Value(False),
output_field=BooleanField()))
return queryset
