def test_restores_coe_advisors(self, app):
"""Restores previously deleted COE advisors found in the loch."""
deleted_user = AuthorizedUser.delete(uid=coe_advisor_uid)
UniversityDeptMember.query.filter_by(
authorized_user_id=deleted_user.id).delete()
std_commit(allow_test_environment=True)
dept_coe = UniversityDept.find_by_dept_code(dept_code='COENG')
coe_users = [au.authorized_user for au in dept_coe.authorized_users]
coe_user_count = len(coe_users)
assert coe_user_count
assert next(
(u for u in coe_users if u.uid == coe_advisor_uid), None) is None
from boac.api.cache_utils import refresh_department_memberships
refresh_department_memberships()
std_commit(allow_test_environment=True)
coe_users = [au.authorized_user for au in dept_coe.authorized_users]
assert len(coe_users) == coe_user_count + 1
assert next(u for u in coe_users if u.uid == coe_advisor_uid)
user = AuthorizedUser.find_by_uid(uid=coe_advisor_uid,
ignore_deleted=False)
assert user.can_access_canvas_data is False
assert user.can_access_advising_data is False
# And degree_progress_permission persists
assert user.degree_progress_permission == 'read_write'
assert user.deleted_at is None
assert user.created_by == '0'
assert user.department_memberships[0].automate_membership is True
def load_development_data():
for name, code in BERKELEY_DEPT_NAME_TO_CODE.items():
UniversityDept.create(code, name, False)
for test_user in _test_users:
# This script can be run more than once. Do not create user if s/he exists in BOAC db.
uid = test_user[0]
csid = test_user[1]
user = AuthorizedUser.find_by_uid(uid=uid)
if uid != no_calnet_record_for_uid:
# Put mock CalNet data in our json_cache for all users EXCEPT the test "no_calnet_record" user.
first_name = ''.join(random.choices(string.ascii_uppercase, k=6))
last_name = ''.join(random.choices(string.ascii_uppercase, k=6))
calnet_feed = {
'uid': uid,
# Mock CSIDs are random unless we need them to correspond to test data elsewhere.
'csid': csid or datetime.now().strftime('%H%M%S%f'),
'firstName': first_name,
'lastName': last_name,
'name': f'{first_name} {last_name}',
}
if len(test_user) > 4:
calnet_feed['departments'] = [
{
'code': test_user[4],
'name': BERKELEY_DEPT_CODE_TO_NAME.get(test_user[4]),
},
]
insert_in_json_cache(f'calnet_user_for_uid_{uid}', calnet_feed)
if not user:
user = AuthorizedUser(uid=uid,
is_admin=test_user[2],
in_demo_mode=test_user[3])
db.session.add(user)
for dept_code, dept_membership in _university_depts.items():
university_dept = UniversityDept.find_by_dept_code(dept_code)
university_dept.automate_memberships = dept_membership[
'automate_memberships']
db.session.add(university_dept)
for user in dept_membership['users']:
authorized_user = AuthorizedUser.find_by_uid(user['uid'])
UniversityDeptMember.create_membership(
university_dept,
authorized_user,
user['is_advisor'],
user['is_director'],
)
std_commit(allow_test_environment=True)
def _api_delete(cls, client, expected_status_code=200):
university_dept_id = UniversityDept.find_by_dept_code('ZZZZZ').id
authorized_user_id = AuthorizedUser.find_by_uid(coe_advisor_uid).id
response = client.delete(
f'/api/user/dept_membership/delete/{university_dept_id}/{authorized_user_id}',
)
assert response.status_code == expected_status_code
return response.json
def test_add_university_dept_membership(self, client, fake_auth):
"""Creates a UniversityDeptMember record."""
fake_auth.login(admin_uid)
membership = self._api_add(client)
assert membership[
'universityDeptId'] == UniversityDept.find_by_dept_code('ZZZZZ').id
assert membership['authorizedUserId'] == AuthorizedUser.find_by_uid(
coe_advisor_uid).id
assert membership['isAdvisor'] is True
assert membership['isDirector'] is False
assert membership['automateMembership'] is False
def get_departments():
exclude_empty = to_bool_or_none(
util.get(request.args, 'excludeEmpty', None))
api_json = []
for d in UniversityDept.get_all(exclude_empty=exclude_empty):
api_json.append({
'id': d.id,
'code': d.dept_code,
'name': d.dept_name,
})
return tolerant_jsonify(api_json)
def add_university_dept_membership():
params = request.get_json() or {}
dept = UniversityDept.find_by_dept_code(params.get('deptCode', None))
user = AuthorizedUser.find_by_uid(params.get('uid', None))
membership = UniversityDeptMember.create_or_update_membership(
university_dept_id=dept.id,
authorized_user_id=user.id,
role=params.get('role', None),
automate_membership=params.get('automateMembership', True),
)
return tolerant_jsonify(membership.to_api_json())
def load_development_data():
for name, code in BERKELEY_DEPT_NAME_TO_CODE.items():
UniversityDept.create(code, name)
for test_user in _test_users:
# This script can be run more than once. Do not create user if s/he exists in BOAC db.
user = AuthorizedUser.find_by_uid(uid=test_user[0])
if not user:
user = AuthorizedUser(uid=test_user[0], is_admin=test_user[1])
db.session.add(user)
for dept_code, users in _users_per_dept.items():
university_dept = UniversityDept.find_by_dept_code(dept_code)
for user in users:
authorized_user = AuthorizedUser.find_by_uid(user['uid'])
UniversityDeptMember.create_membership(
university_dept,
authorized_user,
user['is_advisor'],
user['is_director'],
)
std_commit(allow_test_environment=True)
def add_university_dept_membership():
params = request.get_json() or {}
dept = UniversityDept.find_by_dept_code(params.get('deptCode', None))
user = AuthorizedUser.find_by_uid(params.get('uid', None))
membership = UniversityDeptMember.create_or_update_membership(
university_dept=dept,
authorized_user=user,
is_advisor=params.get('isAdvisor', False),
is_director=params.get('isDirector', False),
is_scheduler=params.get('isScheduler', False),
automate_membership=params.get('automateMembership', True),
)
return tolerant_jsonify(membership.to_api_json())
def update_university_dept_membership():
params = request.get_json() or {}
dept = UniversityDept.find_by_dept_code(params.get('deptCode', None))
user = AuthorizedUser.find_by_uid(params.get('uid', None))
membership = UniversityDeptMember.update_membership(
university_dept_id=dept.id,
authorized_user_id=user.id,
role=params.get('role', None),
automate_membership=params.get('automateMembership', None),
)
if not membership:
raise errors.BadRequestError(
f'Failed to update university dept membership: university_dept_id={dept.id} authorized_user_id={user.id}'
)
return tolerant_jsonify(membership.to_api_json())
def _create_department_memberships(authorized_user, memberships):
for membership in [
m for m in memberships
if m['role'] in ('advisor', 'director', 'scheduler')
]:
university_dept = UniversityDept.find_by_dept_code(membership['code'])
role = membership['role']
UniversityDeptMember.create_or_update_membership(
university_dept_id=university_dept.id,
authorized_user_id=authorized_user.id,
role=role,
automate_membership=to_bool_or_none(
membership['automateMembership']),
)
if role == 'scheduler':
_delete_drop_in_advisor_status(authorized_user,
university_dept.dept_code)
UserSession.flush_cache_for_id(authorized_user.id)
def _create_department_memberships():
for dept_code, dept_membership in _university_depts.items():
university_dept = UniversityDept.find_by_dept_code(dept_code)
db.session.add(university_dept)
for user in dept_membership['users']:
authorized_user = AuthorizedUser.find_by_uid(user['uid'])
UniversityDeptMember.create_or_update_membership(
university_dept_id=university_dept.id,
authorized_user_id=authorized_user.id,
role=user['role'],
automate_membership=user['automate_membership'],
)
if user['isDropInAdvisor']:
DropInAdvisor.create_or_update_membership(
dept_code=dept_code,
authorized_user_id=authorized_user.id,
is_available=True,
)
def _create_department_memberships():
for dept_code, dept_membership in _university_depts.items():
university_dept = UniversityDept.find_by_dept_code(dept_code)
db.session.add(university_dept)
for user in dept_membership['users']:
authorized_user = AuthorizedUser.find_by_uid(user['uid'])
UniversityDeptMember.create_or_update_membership(
university_dept=university_dept,
authorized_user=authorized_user,
is_advisor=user['isAdvisor'],
is_director=user['isDirector'],
is_scheduler=user['isScheduler'],
automate_membership=user['automate_membership'],
)
if user['isDropInAdvisor']:
DropInAdvisor.create_or_update_status(
university_dept=university_dept,
authorized_user=authorized_user,
is_available=True,
)
def _load_users_and_departments():
for code, name in BERKELEY_DEPT_CODE_TO_NAME.items():
UniversityDept.create(code, name)
_create_users()
_create_department_memberships()
