def create_or_update_user_profile():
params = request.get_json()
profile = params.get('profile', None)
memberships = params.get('memberships', None)
delete_action = to_bool_or_none(util.get(params, 'deleteAction'))
if not profile or not profile.get('uid') or memberships is None:
raise errors.BadRequestError('Required parameters are missing')
authorized_user = _update_or_create_authorized_user(memberships,
profile,
include_deleted=True)
_delete_existing_memberships(authorized_user)
_create_department_memberships(authorized_user, memberships)
if delete_action is True and not authorized_user.deleted_at:
AuthorizedUser.delete(authorized_user.uid)
elif delete_action is False and authorized_user.deleted_at:
AuthorizedUser.un_delete(authorized_user.uid)
user_id = authorized_user.id
UserSession.flush_cache_for_id(user_id)
updated_user = AuthorizedUser.find_by_id(user_id, include_deleted=True)
users_json = authorized_users_api_feed([updated_user])
return tolerant_jsonify(users_json and users_json[0])
def _create_users():
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['uid']
# Mock CSIDs and names are random unless we need them to correspond to test data elsewhere.
csid = test_user['csid'] or datetime.now().strftime('%H%M%S%f')
first_name = test_user.get(
'firstName', ''.join(random.choices(string.ascii_uppercase, k=6)))
last_name = test_user.get(
'lastName', ''.join(random.choices(string.ascii_uppercase, k=6)))
# Put mock CalNet data in our json_cache for all users EXCEPT the test "no_calnet_record" user.
if uid != no_calnet_record_for_uid:
calnet_feed = {
'uid': uid,
'csid': csid,
'firstName': first_name,
'lastName': last_name,
'name': f'{first_name} {last_name}',
}
if 'calnetDeptCodes' in test_user:
calnet_feed['departments'] = []
for dept_code in test_user['calnetDeptCodes']:
calnet_feed['departments'].append({
'code':
dept_code,
'name':
BERKELEY_DEPT_CODE_TO_NAME.get(dept_code),
})
if 'title' in test_user:
calnet_feed['title'] = test_user['title']
insert_in_json_cache(f'calnet_user_for_uid_{uid}', calnet_feed)
# Add user to authorized_users table if not already present.
user = AuthorizedUser.find_by_uid(uid=uid)
if not user:
user = AuthorizedUser(
uid=uid,
created_by='2040',
is_admin=test_user['isAdmin'],
in_demo_mode=test_user['inDemoMode'],
can_access_advising_data=test_user['canAccessAdvisingData'],
can_access_canvas_data=test_user['canAccessCanvasData'],
degree_progress_permission=test_user.get(
'degreeProgressPermission'),
search_history=test_user.get('searchHistory', []),
)
if test_user.get('deleted'):
user.deleted_at = utc_now()
db.session.add(user)
AuthorizedUser.delete(delete_this_admin_uid)
AuthorizedUser.delete(delete_this_uid)
std_commit(allow_test_environment=True)
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 remove_appointment_scheduler_from_dept(dept_code):
_verify_membership_and_appointments_enabled(current_user, dept_code)
params = request.get_json() or {}
uid = params.get('uid')
user = uid and AuthorizedUser.find_by_uid(uid)
if not user:
raise errors.BadRequestError(f'UID {uid} missing or invalid')
scheduler_membership = next((
d for d in user.department_memberships
if d.university_dept.dept_code == dept_code and d.role == 'scheduler'),
None)
if not scheduler_membership:
raise errors.BadRequestError(
f'UID {uid} is not a scheduler for department {dept_code}')
UniversityDeptMember.delete_membership(
university_dept_id=scheduler_membership.university_dept_id,
authorized_user_id=user.id,
)
Scheduler.delete(authorized_user_id=user.id, dept_code=dept_code)
if not len(user.department_memberships):
AuthorizedUser.delete(uid)
return tolerant_jsonify(
_get_appointment_scheduler_list(current_user, dept_code))
