def to_base_json(self):
c = self.filter_criteria
c = c if isinstance(c, dict) else json.loads(c)
user_uid = self.owner.uid if self.owner else None
option_groups = CohortFilterOptions(
user_uid, scope_for_criteria()).get_filter_option_groups()
for label, option_group in option_groups.items():
for option in option_group:
key = option['key']
if key in c:
value = c.get(key)
if option['type']['db'] == 'boolean':
c[key] = util.to_bool_or_none(value)
else:
c[key] = value
def _owner_to_json(owner):
if not owner:
return None
return {
'uid':
owner.uid,
'deptCodes': [
m.university_dept.dept_code
for m in owner.department_memberships
],
}
return {
'id':
self.id,
'domain':
self.domain,
'name':
self.name,
'code':
self.id,
'criteria':
c,
'owner':
_owner_to_json(self.owner),
'teamGroups':
athletics.get_team_groups(c.get('groupCodes'))
if c.get('groupCodes') else [],
'alertCount':
self.alert_count,
}
def to_api_json(
self,
order_by=None,
offset=0,
limit=50,
alert_offset=None,
alert_limit=None,
include_sids=False,
include_students=True,
include_profiles=False,
include_alerts_for_user_id=None,
):
benchmark = get_benchmarker(f'CohortFilter {self.id} to_api_json')
benchmark('begin')
c = self.filter_criteria
c = c if isinstance(c, dict) else json.loads(c)
coe_advisor_ldap_uids = util.get(c, 'coeAdvisorLdapUids')
if not isinstance(coe_advisor_ldap_uids, list):
coe_advisor_ldap_uids = [coe_advisor_ldap_uids
] if coe_advisor_ldap_uids else None
cohort_name = self.name
cohort_json = {
'id': self.id,
'code': self.id,
'name': cohort_name,
'owners': [],
'alertCount': self.alert_count,
}
for owner in self.owners:
cohort_json['owners'].append({
'uid':
owner.uid,
'deptCodes': [
m.university_dept.dept_code
for m in owner.department_memberships
],
})
coe_ethnicities = c.get('coeEthnicities')
coe_genders = c.get('coeGenders')
coe_prep_statuses = c.get('coePrepStatuses')
coe_probation = util.to_bool_or_none(c.get('coeProbation'))
coe_underrepresented = util.to_bool_or_none(
c.get('coeUnderrepresented'))
cohort_owner_academic_plans = util.get(c, 'cohortOwnerAcademicPlans')
entering_terms = c.get('enteringTerms')
ethnicities = c.get('ethnicities')
expected_grad_terms = c.get('expectedGradTerms')
genders = c.get('genders')
gpa_ranges = c.get('gpaRanges')
group_codes = c.get('groupCodes')
in_intensive_cohort = util.to_bool_or_none(c.get('inIntensiveCohort'))
is_inactive_asc = util.to_bool_or_none(c.get('isInactiveAsc'))
is_inactive_coe = util.to_bool_or_none(c.get('isInactiveCoe'))
last_name_ranges = c.get('lastNameRanges')
last_term_gpa_ranges = c.get('lastTermGpaRanges')
levels = c.get('levels')
majors = c.get('majors')
midpoint_deficient_grade = util.to_bool_or_none(
c.get('midpointDeficient'))
team_groups = athletics.get_team_groups(
group_codes) if group_codes else []
transfer = util.to_bool_or_none(c.get('transfer'))
underrepresented = util.to_bool_or_none(c.get('underrepresented'))
unit_ranges = c.get('unitRanges')
cohort_json.update({
'criteria': {
'coeAdvisorLdapUids': coe_advisor_ldap_uids,
'coeEthnicities': coe_ethnicities,
'coeGenders': coe_genders,
'coePrepStatuses': coe_prep_statuses,
'coeProbation': coe_probation,
'coeUnderrepresented': coe_underrepresented,
'cohortOwnerAcademicPlans': cohort_owner_academic_plans,
'enteringTerms': entering_terms,
'ethnicities': ethnicities,
'expectedGradTerms': expected_grad_terms,
'genders': genders,
'gpaRanges': gpa_ranges,
'groupCodes': group_codes,
'inIntensiveCohort': in_intensive_cohort,
'isInactiveAsc': is_inactive_asc,
'isInactiveCoe': is_inactive_coe,
'lastNameRanges': last_name_ranges,
'lastTermGpaRanges': last_term_gpa_ranges,
'levels': levels,
'majors': majors,
'midpointDeficient': midpoint_deficient_grade,
'transfer': transfer,
'unitRanges': unit_ranges,
'underrepresented': underrepresented,
},
'teamGroups': team_groups,
})
if not include_students and not include_alerts_for_user_id and self.student_count is not None:
# No need for a students query; return the database-stashed student count.
cohort_json.update({
'totalStudentCount': self.student_count,
})
benchmark('end')
return cohort_json
benchmark('begin students query')
sids_only = not include_students
# Translate the "My Students" filter, if present, into queryable criteria. Although our database relationships allow
# for multiple cohort owners, we assume a single owner here since the "My Students" filter makes no sense
# in any other scenario.
if cohort_owner_academic_plans:
if self.owners:
owner_sid = get_csid_for_uid(app, self.owners[0].uid)
else:
owner_sid = current_user.get_csid()
advisor_plan_mappings = [{
'advisor_sid': owner_sid,
'academic_plan_code': plan
} for plan in cohort_owner_academic_plans]
else:
advisor_plan_mappings = None
results = query_students(
advisor_plan_mappings=advisor_plan_mappings,
coe_advisor_ldap_uids=coe_advisor_ldap_uids,
coe_ethnicities=coe_ethnicities,
coe_genders=coe_genders,
coe_prep_statuses=coe_prep_statuses,
coe_probation=coe_probation,
coe_underrepresented=coe_underrepresented,
entering_terms=entering_terms,
ethnicities=ethnicities,
expected_grad_terms=expected_grad_terms,
genders=genders,
gpa_ranges=gpa_ranges,
group_codes=group_codes,
in_intensive_cohort=in_intensive_cohort,
include_profiles=(include_students and include_profiles),
is_active_asc=None
if is_inactive_asc is None else not is_inactive_asc,
is_active_coe=None
if is_inactive_coe is None else not is_inactive_coe,
last_name_ranges=last_name_ranges,
last_term_gpa_ranges=last_term_gpa_ranges,
levels=levels,
limit=limit,
majors=majors,
midpoint_deficient_grade=midpoint_deficient_grade,
offset=offset,
order_by=order_by,
sids_only=sids_only,
transfer=transfer,
underrepresented=underrepresented,
unit_ranges=unit_ranges,
)
benchmark('end students query')
if results:
# Cohort might have tens of thousands of SIDs.
if include_sids:
cohort_json['sids'] = results['sids']
cohort_json.update({
'totalStudentCount':
results['totalStudentCount'],
})
# If the cohort is new or cache refresh is underway then store student_count and sids in the db.
if self.student_count is None:
self.update_sids_and_student_count(
results['sids'], results['totalStudentCount'])
if include_students:
cohort_json.update({
'students': results['students'],
})
if include_alerts_for_user_id:
benchmark('begin alerts query')
alert_count_per_sid = Alert.include_alert_counts_for_students(
viewer_user_id=include_alerts_for_user_id,
group=results,
offset=alert_offset,
limit=alert_limit,
)
benchmark('end alerts query')
cohort_json.update({
'alerts': alert_count_per_sid,
})
if self.alert_count is None:
alert_count = sum(student['alertCount']
for student in alert_count_per_sid)
self.update_alert_count(alert_count)
cohort_json.update({
'alertCount': alert_count,
})
benchmark('end')
return cohort_json
def to_api_json(
self,
order_by=None,
offset=0,
limit=50,
include_students=True,
include_profiles=False,
include_alerts_for_uid=None,
):
c = self.filter_criteria
c = c if isinstance(c, dict) else json.loads(c)
advisor_ldap_uids = util.get(c, 'advisorLdapUids')
if not isinstance(advisor_ldap_uids, list):
advisor_ldap_uids = [advisor_ldap_uids
] if advisor_ldap_uids else None
cohort_name = self.label
cohort_json = {
'id': self.id,
'code': self.id,
'label': cohort_name,
'name': cohort_name,
'owners': [user.uid for user in self.owners],
}
coe_prep_statuses = c.get('coePrepStatuses')
ethnicities = c.get('ethnicities')
genders = c.get('genders')
gpa_ranges = c.get('gpaRanges')
group_codes = c.get('groupCodes')
in_intensive_cohort = util.to_bool_or_none(c.get('inIntensiveCohort'))
is_inactive_asc = util.to_bool_or_none(c.get('isInactiveAsc'))
last_name_range = c.get('lastNameRange')
levels = c.get('levels')
majors = c.get('majors')
team_groups = athletics.get_team_groups(
group_codes) if group_codes else []
underrepresented = util.to_bool_or_none(c.get('underrepresented'))
unit_ranges = c.get('unitRanges')
cohort_json.update({
'filterCriteria': {
'advisorLdapUids': advisor_ldap_uids,
'coePrepStatuses': coe_prep_statuses,
'ethnicities': ethnicities,
'genders': genders,
'gpaRanges': gpa_ranges,
'groupCodes': group_codes,
'inIntensiveCohort': in_intensive_cohort,
'isInactiveAsc': is_inactive_asc,
'lastNameRange': last_name_range,
'levels': levels,
'majors': majors,
'unitRanges': unit_ranges,
'underrepresented': underrepresented,
},
'teamGroups': team_groups,
})
if not include_students and not include_alerts_for_uid and self.student_count is not None:
# No need for a students query; return the database-stashed student count.
cohort_json.update({
'totalStudentCount': self.student_count,
})
return cohort_json
owner = self.owners[0] if len(self.owners) else None
if owner and 'UWASC' in get_dept_codes(owner):
is_active_asc = not is_inactive_asc
else:
is_active_asc = None if is_inactive_asc is None else not is_inactive_asc
sids_only = not include_students
results = query_students(
advisor_ldap_uids=advisor_ldap_uids,
coe_prep_statuses=coe_prep_statuses,
ethnicities=ethnicities,
genders=genders,
gpa_ranges=gpa_ranges,
group_codes=group_codes,
in_intensive_cohort=in_intensive_cohort,
include_profiles=(include_students and include_profiles),
is_active_asc=is_active_asc,
last_name_range=last_name_range,
levels=levels,
limit=limit,
majors=majors,
offset=offset,
order_by=order_by,
sids_only=sids_only,
underrepresented=underrepresented,
unit_ranges=unit_ranges,
)
if results:
# If the cohort is newly created or a cache refresh is underway, store the student count in the database
# to save future queries.
if self.student_count is None:
self.update_student_count(results['totalStudentCount'])
cohort_json.update({
'totalStudentCount':
results['totalStudentCount'],
})
if include_students:
cohort_json.update({
'students': results['students'],
})
if include_alerts_for_uid:
alert_counts = Alert.include_alert_counts_for_students(
viewer_uid=include_alerts_for_uid, cohort=results)
cohort_json.update({
'alerts': alert_counts,
})
return cohort_json