def add_appointment_scheduler_to_dept(dept_code):
_verify_membership_and_appointments_enabled(current_user, dept_code)
params = request.get_json() or {}
scheduler_uid = params.get('uid', None)
if not scheduler_uid:
raise errors.BadRequestError('Scheduler UID missing')
calnet_user = calnet.get_calnet_user_for_uid(app,
scheduler_uid,
skip_expired_users=True)
if not calnet_user or not calnet_user.get('csid'):
raise errors.BadRequestError('Invalid scheduler UID')
user = AuthorizedUser.create_or_restore(
scheduler_uid,
created_by=current_user.get_uid(),
is_admin=False,
is_blocked=False,
can_access_canvas_data=False,
)
Scheduler.create_or_update_membership(
dept_code,
user.id,
drop_in=True,
same_day=True,
)
_create_department_memberships(user, [{
'code': dept_code,
'role': 'scheduler',
'automateMembership': False
}])
UserSession.flush_cache_for_id(user.id)
return tolerant_jsonify(
_get_appointment_scheduler_list(current_user, dept_code))
def refresh_department_memberships():
from boac.models.authorized_user import AuthorizedUser
from boac.models.university_dept import UniversityDept
from boac.models.university_dept_member import UniversityDeptMember
depts = UniversityDept.query.all()
for dept in depts:
dept.delete_automated_members()
std_commit(allow_test_environment=True)
for dept in depts:
for membership in dept.memberships_from_loch():
# A non-numeric "uid" indicates a row from SIS advising tables best ignored.
if not re.match(r'^\d+$', membership['uid']):
continue
user = AuthorizedUser.create_or_restore(
uid=membership['uid'],
created_by='0',
can_access_canvas_data=membership['can_access_canvas_data'],
)
if user:
UniversityDeptMember.create_or_update_membership(
dept,
user,
is_advisor=True,
is_director=False,
is_scheduler=False,
)
def test_create_or_restore_new(self):
"""Creates a new user if it doesn't already exist."""
new_user = AuthorizedUser.create_or_restore(unknown_uid, created_by='0', is_admin=False, can_access_canvas_data=False)
assert new_user.is_admin is False
assert new_user.can_access_canvas_data is False
assert new_user.in_demo_mode is False
assert new_user.created_by == '0'
def test_deletes_drop_in_advisor_orphans(self):
"""Cleans up drop-in advisor record for a department membership that no longer exists."""
from boac.models.authorized_user_extension import DropInAdvisor
dept_ucls = UniversityDept.query.filter_by(
dept_code='QCADVMAJ').first()
bad_user = AuthorizedUser.create_or_restore(uid='666',
created_by='2040')
UniversityDeptMember.create_or_update_membership(
dept_ucls.id,
bad_user.id,
role='advisor',
)
DropInAdvisor.create_or_update_membership(dept_ucls.dept_code,
bad_user.id)
std_commit(allow_test_environment=True)
ucls_drop_in_advisors = DropInAdvisor.advisors_for_dept_code(
dept_ucls.dept_code)
assert len(ucls_drop_in_advisors) == 2
assert bad_user.id in [
d.authorized_user_id for d in ucls_drop_in_advisors
]
from boac.api.cache_utils import refresh_department_memberships
refresh_department_memberships()
std_commit(allow_test_environment=True)
ucls_drop_in_advisors = DropInAdvisor.advisors_for_dept_code(
dept_ucls.dept_code)
assert len(ucls_drop_in_advisors) == 1
def test_removes_coe_advisors(self, app):
"""Removes COE advisors not found in the loch."""
dept_coe = UniversityDept.query.filter_by(dept_code='COENG').first()
bad_user = AuthorizedUser.create_or_restore(uid='666',
created_by='2040')
UniversityDeptMember.create_or_update_membership(
dept_coe.id,
bad_user.id,
role='advisor',
)
std_commit(allow_test_environment=True)
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 == '666')
assert AuthorizedUser.query.filter_by(
uid='666').first().deleted_at 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 == '666'), None) is None
assert AuthorizedUser.query.filter_by(uid='666').first().deleted_at
def test_respects_automate_memberships_flag(self, app, db):
dept_coe = UniversityDept.query.filter_by(dept_code='COENG').first()
manually_added_user = AuthorizedUser.create_or_restore(
uid='1024', created_by='2040')
manual_membership = UniversityDeptMember.create_or_update_membership(
dept_coe,
manually_added_user,
is_advisor=True,
is_director=False,
is_scheduler=False,
automate_membership=False,
)
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) == 6
assert next(u for u in coe_users if u.uid == '1024')
assert AuthorizedUser.query.filter_by(
uid='1024').first().deleted_at is None
manual_membership.automate_membership = True
db.session.add(manual_membership)
std_commit(allow_test_environment=True)
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) == 5
assert next((u for u in coe_users if u.uid == '1024'), None) is None
assert AuthorizedUser.query.filter_by(uid='1024').first().deleted_at
def refresh_department_memberships():
from boac.models.authorized_user import AuthorizedUser
from boac.models.authorized_user_extension import DropInAdvisor, SameDayAdvisor, Scheduler
from boac.models.university_dept import UniversityDept
from boac.models.university_dept_member import UniversityDeptMember
depts = UniversityDept.query.all()
for dept in depts:
dept.delete_automated_members()
std_commit(allow_test_environment=True)
for dept in depts:
for membership in dept.memberships_from_loch():
# A non-numeric "uid" indicates a row from SIS advising tables best ignored.
if not re.match(r'^\d+$', membership['uid']):
continue
user = AuthorizedUser.create_or_restore(
uid=membership['uid'],
created_by='0',
can_access_advising_data=membership['can_access_advising_data'],
can_access_canvas_data=membership['can_access_canvas_data'],
degree_progress_permission=membership['degree_progress_permission'],
)
if user:
UniversityDeptMember.create_or_update_membership(
university_dept_id=dept.id,
authorized_user_id=user.id,
role='advisor',
)
DropInAdvisor.delete_orphans()
SameDayAdvisor.delete_orphans()
Scheduler.delete_orphans()
def test_create_or_restore_blocked(self):
"""Does not restore a user if they have been blocked."""
blocked_user = AuthorizedUser.find_by_uid(uid=coe_advisor_uid)
blocked_user.is_blocked = True
assert not AuthorizedUser.create_or_restore(coe_advisor_uid,
created_by='0')
def _update_or_create_authorized_user(memberships,
profile,
include_deleted=False):
user_id = profile.get('id')
automate_degree_progress_permission = profile.get(
'automateDegreeProgressPermission')
can_access_canvas_data = to_bool_or_none(
profile.get('canAccessCanvasData'))
can_access_advising_data = to_bool_or_none(
profile.get('canAccessAdvisingData'))
degree_progress_permission = profile.get('degreeProgressPermission')
if (automate_degree_progress_permission or degree_progress_permission
) and 'COENG' not in dept_codes_where_advising(
{'departments': memberships}):
raise errors.BadRequestError(
'Degree Progress feature is only available to the College of Engineering.'
)
is_admin = to_bool_or_none(profile.get('isAdmin'))
is_blocked = to_bool_or_none(profile.get('isBlocked'))
if user_id:
user = AuthorizedUser.update_user(
automate_degree_progress_permission=
automate_degree_progress_permission,
can_access_advising_data=can_access_advising_data,
can_access_canvas_data=can_access_canvas_data,
degree_progress_permission=degree_progress_permission,
include_deleted=include_deleted,
is_admin=is_admin,
is_blocked=is_blocked,
user_id=user_id,
)
UserSession.flush_cache_for_id(user_id=user_id)
return user
else:
uid = profile.get('uid')
if AuthorizedUser.get_id_per_uid(uid, include_deleted=True):
raise errors.BadRequestError(
f'User with UID {uid} is already in the BOA database.')
calnet_user = calnet.get_calnet_user_for_uid(app,
uid,
skip_expired_users=True)
if calnet_user and calnet_user.get('csid', None):
return AuthorizedUser.create_or_restore(
automate_degree_progress_permission=
automate_degree_progress_permission,
can_access_advising_data=can_access_advising_data,
can_access_canvas_data=can_access_canvas_data,
created_by=current_user.get_uid(),
degree_progress_permission=degree_progress_permission,
is_admin=is_admin,
is_blocked=is_blocked,
uid=uid,
)
else:
raise errors.BadRequestError('Invalid UID')
def test_create_or_restore_existing(self):
"""Updates an existing user, replacing existing attributes that are False with any attributes passed in as True."""
user = AuthorizedUser.find_by_uid(uid=admin_uid)
user.can_access_canvas_data = False
user.created_by = admin_uid
updated_user = AuthorizedUser.create_or_restore(admin_uid, created_by='0', is_admin=False, can_access_canvas_data=True)
assert updated_user.is_admin is True
assert updated_user.can_access_canvas_data is True
assert updated_user.created_by == '0'
def test_create_or_restore_deleted(self):
"""Restores a deleted user to a non-deleted state, updating with any passed-in attributes."""
user = AuthorizedUser.find_by_uid(uid=coe_advisor_uid)
user.created_by = '0'
user.deleted_at = datetime.now()
assert user.can_access_canvas_data is True
restored_user = AuthorizedUser.create_or_restore(coe_advisor_uid, created_by=admin_uid, can_access_canvas_data=False)
assert restored_user.can_access_canvas_data is False
assert restored_user.created_by == admin_uid
assert restored_user.deleted_at is None
def refresh_department_memberships():
from boac.models.authorized_user import AuthorizedUser
from boac.models.university_dept import UniversityDept
from boac.models.db_relationships import UniversityDeptMember
depts = UniversityDept.query.filter_by(automate_memberships=True).all()
for dept in depts:
dept.delete_all_members()
std_commit(allow_test_environment=True)
for dept in depts:
for membership in dept.memberships_from_loch():
user = AuthorizedUser.create_or_restore(uid=membership['uid'])
UniversityDeptMember.create_membership(dept,
user,
is_advisor=True,
is_director=False)
def test_respects_automate_memberships_flag(self, app, db):
dept_coe = UniversityDept.query.filter_by(dept_code='COENG').first()
manually_added_user = AuthorizedUser.create_or_restore(
uid='1024',
created_by='2040',
degree_progress_permission='read_write',
)
manual_membership = UniversityDeptMember.create_or_update_membership(
dept_coe.id,
manually_added_user.id,
role='advisor',
automate_membership=False,
)
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]
coe_user_count = len(coe_users)
assert coe_user_count
assert next(u for u in coe_users if u.uid == '1024')
user = AuthorizedUser.find_by_uid(uid='1024')
assert user
assert user.degree_progress_permission == 'read_write'
manual_membership.automate_membership = True
db.session.add(manual_membership)
std_commit(allow_test_environment=True)
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 == '1024'), None) is None
assert not AuthorizedUser.find_by_uid(uid='1024')
