def test_update_template(self, client, fake_auth):
"""Authorized user can edit a template."""
user = AuthorizedUser.find_by_uid(coe_advisor_read_write_uid)
fake_auth.login(user.uid)
template = DegreeProgressTemplate.create(
advisor_dept_codes=get_dept_codes(user),
created_by=user.id,
degree_name='Boogie Down Productions',
)
for index in (1, 2, 3):
DegreeProgressUnitRequirement.create(
created_by=user.id,
min_units=index,
name=f'Unit Requirement #{index}',
template_id=template.id,
)
updated_name = 'KRS One'
api_json = self._api_clone_template(client=client,
name=updated_name,
template_id=template.id)
assert api_json['id'] != template.id
assert api_json['name'] == updated_name
assert len(api_json['unitRequirements']) == 3
def _get_api_json(cls, user=None):
calnet_profile = None
departments = []
is_asc = False
is_coe = False
if user:
calnet_profile = calnet.get_calnet_user_for_uid(
app,
user.uid,
force_feed=False,
skip_expired_users=True,
)
for m in user.department_memberships:
dept_code = m.university_dept.dept_code
departments.append({
'code':
dept_code,
'name':
BERKELEY_DEPT_CODE_TO_NAME[dept_code] or dept_code,
'role':
get_dept_role(m),
'isAdvisor':
m.is_advisor,
'isDirector':
m.is_director,
})
dept_codes = get_dept_codes(user) if user else []
is_asc = 'UWASC' in dept_codes
is_coe = 'COENG' in dept_codes
is_active = False
if user:
if not calnet_profile:
is_active = False
elif user.is_admin:
is_active = True
elif len(user.department_memberships):
for m in user.department_memberships:
is_active = m.is_advisor or m.is_director
if is_active:
break
is_admin = user and user.is_admin
return {
**(calnet_profile or {}),
**{
'id': user and user.id,
'canViewAsc': is_asc or is_admin,
'canViewCoe': is_coe or is_admin,
'departments': departments,
'isActive': is_active,
'isAdmin': is_admin,
'isAnonymous': not is_active,
'isAsc': is_asc,
'isAuthenticated': is_active,
'isCoe': is_coe,
'inDemoMode': user and user.in_demo_mode,
'uid': user and user.uid,
},
}
def _get_coe_profiles():
users = list(
filter(lambda user: '******' in get_dept_codes(user),
AuthorizedUser.query.all()))
profiles = []
for user in authorized_users_api_feed(users):
uid = user['uid']
first_name = user.get('firstName')
last_name = user.get('lastName')
name = f'{first_name} {last_name}' if first_name or last_name else uid
profiles.append({'name': name, 'value': uid})
return sorted(profiles, key=lambda p: p['name'])
def is_coe_authorized():
return current_user.is_admin or 'COENG' in get_dept_codes(current_user)
def is_asc_authorized():
return current_user.is_admin or 'UWASC' in get_dept_codes(current_user)
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
def test_zero_dept_codes(self, admin_user, unauthorized_user):
assert berkeley.get_dept_codes(None) is None
assert berkeley.get_dept_codes(admin_user) == []
assert not berkeley.get_dept_codes(unauthorized_user)
def test_asc_dept_codes(self, asc_advisor, coe_advisor):
assert berkeley.get_dept_codes(asc_advisor) == ['UWASC']
assert berkeley.get_dept_codes(coe_advisor) == ['COENG']