def test_to_check(self):
loader = ActiveWkrLoader(BridgeWorker())
person = get_person("affiemp")
self.assertTrue(loader.to_check(person))
person = get_person("leftuw")
self.assertFalse(loader.to_check(person))
person = get_person("alumni")
self.assertFalse(loader.to_check(person))
def test_save_user_withhrp(self):
person = get_person('faculty')
self.assertIsNotNone(person)
user, del_u = save_user(person, include_hrp=False)
self.assertIsNone(del_u)
user, del_u = save_user(person, include_hrp=True)
self.assertIsNone(del_u)
self.assertIsNotNone(user)
self.assertEqual(user.netid, 'faculty')
self.assertFalse(user.is_new())
self.assertTrue(user.is_update())
self.assertTrue(user.has_emp_appointments())
self.assertEqual(user.get_total_emp_apps(), 1)
self.assertEqual(user.emp_appointments_data,
'[{"an":2,"jc":"0191","oc":"2540574070"}]')
apps = user.get_emp_appointments()
self.assertEqual(len(apps), 1)
# the case of no change
user, del_u = save_user(person, include_hrp=True)
self.assertTrue(user.no_action())
self.assertIsNone(del_u)
person = get_person('staff')
user, del_u = save_user(person, include_hrp=True)
self.assertIsNone(del_u)
self.assertIsNotNone(user)
self.assertEqual(user.display_name, "James Staff")
self.assertEqual(user.first_name, "James Average")
self.assertEqual(user.last_name, "Staff")
self.assertTrue(user.has_display_name())
self.assertEqual(user.get_display_name(), "James Staff")
self.assertEqual(user.email, "*****@*****.**")
self.assertEqual(user.get_email(), "*****@*****.**")
self.assertFalse(user.has_emp_appointments())
self.assertEqual(user.emp_appointments_data, "[]")
self.assertIsNone(user.get_emp_appointments_json())
self.assertEqual(len(user.get_emp_appointments()), 0)
self.assertEqual(user.get_total_emp_apps(), 0)
person = get_person('botgrad')
user, del_u = save_user(person, include_hrp=True)
self.assertIsNone(del_u)
self.assertIsNotNone(user)
self.assertEqual(user.netid, 'botgrad')
self.assertEqual(user.regid,
"10000000000000000000000000000003")
self.assertEqual(user.get_display_name(),
"Bothell Graduate Student")
self.assertEqual(user.email, "*****@*****.**")
self.assertTrue(user.has_emp_appointments())
self.assertEqual(user.get_total_emp_apps(), 3)
self.assertIsNotNone(user.emp_appointments_data)
self.assertEqual(user.emp_appointments_data,
_appointments_json_dump(person))
def test_add_new_user(self):
worker = BridgeWorker()
person = get_person('affiemp')
uw_acc = set_uw_account('affiemp')
worker.add_new_user(uw_acc, person, get_worker(person))
self.assertEqual(worker.get_new_user_count(), 1)
person = get_person('javerage')
uw_acc = set_uw_account('javerage')
worker.add_new_user(uw_acc, person, get_worker(person))
self.assertTrue(worker.has_err())
def test_get_person(self):
person = get_person("faculty")
self.assertIsNotNone(person)
self.assertEqual(person.uwnetid, 'faculty')
self.assertEqual(person.uwregid, "10000000000000000000000000000005")
self.assertEqual(person.email_addresses[0], "*****@*****.**")
self.assertEqual(len(person.prior_uwnetids), 1)
self.assertEqual(len(person.prior_uwregids), 1)
self.assertEqual(person.prior_uwnetids[0], "tyler")
self.assertEqual(person.prior_uwregids[0],
"10000000000000000000000000000000")
self.assertEqual(person.display_name, "William E Faculty")
self.assertEqual(person.preferred_first_name, "William E")
self.assertEqual(person.preferred_surname, "Faculty")
self.assertEqual(person.employee_id, "000000005")
self.assertIsNone(get_person("not_in_pws"))
self.assertIsNone(get_person("0 in valid uw netid"))
person = get_person("faculty")
self.assertTrue(person.is_emp_state_current())
person = get_person("ellen")
self.assertTrue(person.is_emp_state_current())
person = get_person("retiree")
self.assertTrue(person.is_emp_state_current())
person = get_person("leftuw")
self.assertFalse(person.is_emp_state_current())
person = get_person("alumni")
self.assertFalse(person.is_emp_state_current())
def test_get_supervisor_bridge_id(self):
set_db_records()
person = get_person('javerage')
hrp_wkr = get_worker(person)
self.assertEqual(get_supervisor_bridge_id(hrp_wkr), 196)
# hrp_wkr is None
self.assertEqual(get_supervisor_bridge_id(None), 0)
# manager employee_id is None
hrp_wkr = Worker(netid="x", regid="111", employee_id="1")
self.assertEqual(get_supervisor_bridge_id(hrp_wkr), 0)
# manager employee_id is the same as the employee's
hrp_wkr = Worker(netid="x",
regid="111",
employee_id="1",
primary_manager_id="1")
self.assertEqual(get_supervisor_bridge_id(hrp_wkr), 0)
# manager employee_id not in local DB
hrp_wkr = Worker(netid="javerage",
regid="111111111111111111111111111111",
employee_id="1",
primary_manager_id="11")
self.assertEqual(get_supervisor_bridge_id(hrp_wkr), 0)
# manager's uw account is the same the user's
hrp_wkr = Worker(netid="javerage",
regid="111111111111111111111111111111",
employee_id="1",
primary_manager_id="123456789")
self.assertEqual(get_supervisor_bridge_id(hrp_wkr), 0)
def test_get_pos_job_class(self):
func_name = GET_POS_ATT_FUNCS[1]
self.assertIsNone(func_name(None, 0))
person = get_person('javerage')
hrp_wkr = get_worker(person)
self.assertEqual(func_name(hrp_wkr, 0), "Undergraduate Student")
self.assertEqual(func_name(hrp_wkr, 1), "Undergraduate Student")
def test_get_attr_list_withhrp(self):
set_db_records()
person = get_person('faculty')
worker = get_worker(person)
user_attr_list = get_attr_list(person, worker)
self.assertEqual(len(user_attr_list), 25)
self.assertEqual(user_attr_list[0], "*****@*****.**")
self.assertEqual(user_attr_list[1], "*****@*****.**")
self.assertEqual(user_attr_list[2], "William E Faculty")
self.assertEqual(user_attr_list[3], "William E")
self.assertEqual(user_attr_list[4], "Faculty")
self.assertEqual(user_attr_list[5], "10000000000000000000000000000005")
self.assertEqual(user_attr_list[6], "000000005")
self.assertEqual(user_attr_list[7], "0000005")
self.assertEqual(user_attr_list[8], "Clinical Associate Professor")
self.assertEqual(user_attr_list[9], 196)
self.assertEqual(user_attr_list[10], "Family Medicine")
self.assertEqual(user_attr_list[11], "3040111000")
self.assertEqual(user_attr_list[12], "Academic Personnel")
self.assertEqual(user_attr_list[13], "21184")
self.assertEqual(user_attr_list[14], "Seattle Campus")
self.assertEqual(user_attr_list[15], "SOM:")
self.assertEqual(user_attr_list[16],
"Family Medicine: Volunteer JM Academic")
self.assertEqual(user_attr_list[17], "00753")
self.assertIsNone(user_attr_list[18])
self.assertIsNone(user_attr_list[19])
self.assertIsNone(user_attr_list[20])
self.assertIsNone(user_attr_list[21])
self.assertIsNone(user_attr_list[22])
self.assertIsNone(user_attr_list[23])
self.assertIsNone(user_attr_list[24])
def test_regid_change(self):
user = UwBridgeUser(netid='retiree',
regid='0136CCB8F66711D5BE060004AC494FFE',
last_visited_at=get_now(),
first_name="Ellen",
last_name="Louise")
user.save()
person = get_person('retiree')
old_user = _get_netid_changed_user([user], person)
self.assertIsNone(old_user)
self.assertTrue(_changed_regid([user], person))
user_upd, user_del = save_user(person, include_hrp=False)
self.assertIsNotNone(user_upd)
self.assertTrue(user_upd.regid_changed())
self.assertFalse(user_upd.netid_changed())
self.assertIsNone(user_del)
self.assertRaises(Exception,
get_user_by_regid,
'0136CCB8F66711D5BE060004AC494FFE')
user_upd.delete()
# user is disabled
user.disabled = True
user.save()
user_upd, user_del = save_user(person, include_hrp=False)
self.assertIsNotNone(user_upd)
self.assertTrue(user_upd.is_restore())
self.assertFalse(user_upd.netid_changed())
self.assertIsNone(user_del)
def test_netid_change(self):
user = UwBridgeUser(netid='changed',
regid="10000000000000000000000000000006",
last_visited_at=get_now(),
first_name="Changed",
last_name="Netid")
user.save()
person = get_person('retiree')
self.assertIsNotNone(person)
old_user = _get_netid_changed_user([user], person)
self.assertEqual(old_user.netid, 'changed')
self.assertFalse(_changed_regid([user], person))
user_upd, user_del = save_user(person, include_hrp=False)
self.assertIsNotNone(user_upd)
self.assertTrue(user_upd.netid_changed())
self.assertFalse(user_upd.regid_changed())
self.assertEqual(user_upd.prev_netid, 'changed')
self.assertIsNone(user_del)
user_upd.delete()
# the case where user is disabled
user.disabled = True
user.save()
user_upd, user_del = save_user(person, include_hrp=False)
self.assertIsNotNone(user_upd)
self.assertTrue(user_upd.netid_changed())
self.assertEqual(user_upd.prev_netid, 'changed')
self.assertTrue(user_upd.is_restore())
self.assertIsNone(user_del)
def process_users(self):
"""
Process exsting users in DB, terminate those left UW and
update those changed.
"""
for uw_acc in self.get_users_to_process():
self.logger.debug("Validate DB record {0}".format(uw_acc))
uwnetid = uw_acc.netid
person = get_person(uwnetid)
if (self.is_invalid_person(uwnetid, person)
or not self.to_check(person)):
continue
if not uw_acc.disabled:
self.total_checked_users += 1
if uwnetid == person.uwnetid:
if self.in_uw_groups(person.uwnetid) is False:
self.process_termination(uw_acc)
continue
if is_prior_netid(uwnetid, person):
cur_uw_acc = get_by_netid(person.uwnetid)
if (cur_uw_acc is not None
and cur_uw_acc.bridge_id != uw_acc.bridge_id):
# the current netid has another account in DB,
# this account will be merged then.
continue
self.take_action(person)
def test_save_user_without_hrp(self):
person = get_person('faculty')
self.assertIsNotNone(person)
user, del_u = save_user(person, include_hrp=False)
self.assertIsNotNone(user)
self.assertEqual(user.netid, person.uwnetid)
self.assertEqual(user.regid, person.uwregid)
self.assertEqual(user.get_display_name(),
"James Faculty")
self.assertTrue(user.is_new())
self.assertFalse(user.is_update())
self.assertEqual(user.email, "")
self.assertEqual(user.get_email(), "*****@*****.**")
self.assertTrue(user.has_display_name())
self.assertEqual(user.get_display_name(), 'James Faculty')
self.assertFalse(user.has_emp_appointments())
self.assertEqual(user.get_total_emp_apps(), 0)
users = UwBridgeUser.objects.filter(Q(regid=person.uwregid) |
Q(netid=person.uwnetid))
self.assertEqual(len(users), 1)
self.assertEqual(users[0], user)
# the case of no change
user, del_u = save_user(person, include_hrp=False)
self.assertTrue(user.no_action())
self.assertIsNone(del_u)
# test restore an disabled
user.disable()
user_upd, user_del = save_user(person, include_hrp=False)
self.assertTrue(user_upd.is_restore())
def test_update_user_wo_uid_change(self):
worker = BridgeWorker()
uw_acc = set_uw_account('staff')
uw_acc.set_bridge_id(196)
person = get_person('staff')
bri_acc = worker.restore_user(uw_acc)
worker.update_user(bri_acc, uw_acc, person, get_worker(person))
self.assertEqual(worker.get_netid_changed_count(), 0)
self.assertEqual(worker.get_updated_count(), 1)
worker = BridgeWorker()
bridge_account = worker.bridge.get_user_by_uwnetid('retiree')
person = get_person('retiree')
worker.update_user(bridge_account, set_uw_account('retiree'), person,
get_worker(person))
self.assertEqual(worker.get_updated_count(), 0)
self.assertTrue(worker.has_err())
def test_get_pos_job_code(self):
func_name = GET_POS_ATT_FUNCS[2]
person = get_person('javerage')
self.assertIsNone(func_name(None, 0))
hrp_wkr = get_worker(person)
self.assertEqual(func_name(hrp_wkr, 0), "10875")
hrp_wkr.primary_position.job_profile = None
self.assertIsNone(func_name(hrp_wkr, 0))
self.assertEqual(func_name(hrp_wkr, 1), "10886")
def process_users(self):
for worker_ref in self.get_users_to_process():
uwnetid = worker_ref.netid
if not self.in_uw_groups(uwnetid):
continue
person = get_person(uwnetid)
if self.is_invalid_person(uwnetid, person):
continue
self.total_checked_users += 1
self.take_action(person)
def test_account_not_changed(self):
with self.settings(BRIDGE_USER_WORK_POSITIONS=2):
set_db_records()
loader = GwsBridgeLoader(BridgeWorker())
person = get_person('javerage')
hrp_wkr = get_worker(person)
bridge_account = loader.get_bridge().get_user_by_uwnetid(
'javerage')
self.assertTrue(
loader.account_not_changed(bridge_account, person, hrp_wkr))
def test_save_uw_accounts(self):
# test a user with multiple accounts
acc1 = self.mock_uw_account('ellen')
acc2 = self.mock_uw_account('retiree')
self.assertEqual(len(get_all_uw_accounts()), 2)
person = get_person('retiree')
acc = save_uw_account(person)
self.assertEqual(acc.netid, person.uwnetid)
self.assertEqual(acc.prev_netid, 'ellen')
self.assertEqual(len(get_all_uw_accounts()), 1)
def test_save_uw_account(self):
acc1 = self.mock_uw_account('tyler')
self.assertEqual(len(get_all_uw_accounts()), 1)
person = get_person('faculty')
acc = save_uw_account(person)
self.assertEqual(acc.netid, person.uwnetid)
self.assertTrue(acc.has_prev_netid())
self.assertEqual(acc.prev_netid, 'tyler')
self.assertEqual(len(get_all_uw_accounts()), 1)
def process_users(self):
"""
Process potential learners in GWS, add new users or update
the exsiting users
"""
for uwnetid in self.get_users_to_process():
person = get_person(uwnetid)
if self.is_invalid_person(uwnetid, person):
continue
self.total_checked_users += 1
self.take_action(person)
def test_get_pos_location(self):
func_name = GET_POS_ATT_FUNCS[3]
self.assertIsNone(func_name(None, 0))
person = get_person('javerage')
hrp_wkr = get_worker(person)
self.assertEqual(func_name(hrp_wkr, 0), "Seattle Campus")
hrp_wkr.primary_position = None
self.assertIsNone(func_name(hrp_wkr, 0))
self.assertEqual(func_name(hrp_wkr, 1), "Seattle Campus")
hrp_wkr.other_active_positions = []
self.assertIsNone(func_name(hrp_wkr, 1))
def test_get_pos_unit_code(self):
func_name = GET_POS_ATT_FUNCS[6]
self.assertIsNone(func_name(None, 0))
person = get_person('javerage')
hrp_wkr = get_worker(person)
self.assertEqual(func_name(hrp_wkr, 0), "00090")
hrp_wkr.primary_position = None
self.assertIsNone(func_name(hrp_wkr, 0))
self.assertEqual(func_name(hrp_wkr, 1), "00652")
hrp_wkr.other_active_positions = []
self.assertIsNone(func_name(hrp_wkr, 1))
def test_get_pos_budget_code(self):
func_name = GET_POS_ATT_FUNCS[0]
self.assertIsNone(func_name(None, 0))
person = get_person('javerage')
hrp_wkr = get_worker(person)
self.assertEqual(func_name(hrp_wkr, 0), "2070001000")
hrp_wkr.primary_position.supervisory_org = None
self.assertIsNone(func_name(hrp_wkr, 0))
self.assertIsNone(func_name(hrp_wkr, 1))
hrp_wkr.other_active_positions[0].supervisory_org = \
SupervisoryOrganization(budget_code="1")
self.assertEqual(func_name(hrp_wkr, 1), "1")
def test_update_user_with_uid_change(self):
worker = BridgeWorker()
uw_acc = set_uw_account('faculty')
uw_acc.prev_netid = 'tyler'
uw_acc.set_bridge_id(198)
self.assertTrue(uw_acc.netid_changed())
person = get_person('faculty')
bri_acc = worker.bridge.get_user_by_uwnetid('tyler')
worker.update_user(bri_acc, uw_acc, person, get_worker(person))
self.assertEqual(worker.get_netid_changed_count(), 1)
self.assertEqual(worker.get_updated_count(), 1)
uw_acc = set_uw_account('retiree')
uw_acc.prev_netid = 'ellen'
uw_acc.set_bridge_id(194)
self.assertTrue(uw_acc.netid_changed())
person = get_person('retiree')
bri_acc = worker.bridge.get_user_by_uwnetid('ellen')
worker.update_user(bri_acc, uw_acc, person, get_worker(person))
self.assertEqual(worker.get_netid_changed_count(), 2)
self.assertEqual(worker.get_updated_count(), 2)
def test_field_not_changed(self):
with self.settings(BRIDGE_USER_WORK_POSITIONS=2):
loader = GwsBridgeLoader(BridgeWorker())
person = get_person('javerage')
hrp_wkr = get_worker(person)
bridge_account = loader.get_bridge().get_user_by_uwnetid(
'javerage')
self.assertTrue(loader.regid_not_changed(bridge_account, person))
self.assertTrue(loader.eid_not_changed(bridge_account, person))
self.assertTrue(loader.sid_not_changed(bridge_account, person))
self.assertTrue(
loader.pos_data_not_changed(bridge_account, hrp_wkr))
person = get_person('faculty')
hrp_wkr = get_worker(person)
bridge_account = loader.get_bridge().get_user_by_uwnetid('tyler')
self.assertFalse(loader.regid_not_changed(bridge_account, person))
self.assertFalse(loader.eid_not_changed(bridge_account, person))
self.assertFalse(loader.sid_not_changed(bridge_account, person))
self.assertFalse(
loader.pos_data_not_changed(bridge_account, hrp_wkr))
def test_get_pos_org_name(self):
func_name = GET_POS_ATT_FUNCS[5]
self.assertIsNone(func_name(None, 0))
person = get_person('javerage')
hrp_wkr = get_worker(person)
self.assertEqual(func_name(hrp_wkr, 0),
"GMMN: Public Services JM Student")
hrp_wkr.primary_position.supervisory_org = None
self.assertIsNone(func_name(hrp_wkr, 0))
self.assertIsNone(func_name(hrp_wkr, 1))
hrp_wkr.other_active_positions[0].supervisory_org = \
SupervisoryOrganization(org_name="A")
self.assertEqual(func_name(hrp_wkr, 1), "A")
def test_get_appointments(self):
person = get_person('staff')
apps = get_appointments(person)
self.assertIsNotNone(apps)
self.assertEqual(len(apps), 0)
person = get_person('faculty')
apps = get_appointments(person)
self.assertIsNotNone(apps)
self.assertEqual(len(apps), 1)
person = get_person('botgrad')
apps = get_appointments(person)
self.assertIsNotNone(apps)
self.assertEqual(len(apps), 3)
self.assertEqual(apps[0].app_number, 1)
self.assertEqual(apps[0].job_class_code, "7777")
self.assertEqual(apps[0].org_code, "5200005000")
self.assertEqual(apps[1].app_number, 2)
self.assertEqual(apps[1].job_class_code, "7940")
self.assertEqual(apps[1].org_code, "5200005000")
self.assertEqual(apps[2].app_number, 3)
self.assertEqual(apps[2].job_class_code, "7926")
self.assertEqual(apps[2].org_code, "5100001000")
def test_apply_change_to_bridge(self):
loader = GwsBridgeLoader(BridgeWorker())
# add new account
uw_acc = set_uw_account("affiemp")
affiemp = get_person("affiemp")
loader.apply_change_to_bridge(uw_acc, affiemp)
self.assertEqual(loader.get_new_user_count(), 1)
self.assertEqual(loader.get_updated_count(), 0)
# restore
uw_acc = set_uw_account("staff")
uw_acc.set_bridge_id(196)
uw_acc.set_disable()
staff = get_person("staff")
loader.apply_change_to_bridge(uw_acc, staff)
self.assertEqual(loader.get_restored_count(), 1)
self.assertEqual(loader.get_updated_count(), 1)
# change uid and update
uw_acc = set_uw_account('faculty')
uw_acc.prev_netid = 'tyler'
uw_acc.set_bridge_id(198)
faculty = get_person("faculty")
loader.apply_change_to_bridge(uw_acc, faculty)
self.assertEqual(loader.get_netid_changed_count(), 1)
self.assertEqual(loader.get_updated_count(), 2)
# change uid and update
uw_acc = set_uw_account("retiree")
uw_acc.bridge_id = 204
uw_acc.prev_netid = "ellen"
retiree = get_person("retiree")
loader.apply_change_to_bridge(uw_acc, retiree)
self.assertEqual(loader.get_netid_changed_count(), 2)
self.assertEqual(loader.get_updated_count(), 3)
def mock_uw_bridge_user(uwnetid):
person = get_person(uwnetid)
buser = UwBridgeUser()
buser.netid = person.uwnetid
buser.regid = person.uwregid
buser.email = normalize_email(person.email1)
buser.display_name = person.display_name
buser.first_name = normalize_name(person.first_name)
buser.last_name = normalize_name(person.surname)
buser.is_alum = person.is_alum
buser.is_employee = person.is_employee
buser.is_faculty = person.is_faculty
buser.is_staff = person.is_staff
buser.is_student = person.is_student
buser.last_visited_at = get_now()
return buser, person
def handle(self, *args, **options):
uwnetid = options['uwnetid']
try:
bridge_dao = BridgeUsers()
uw_acc0 = get_by_netid(uwnetid)
if uw_acc0 is not None:
logger.info("Found existing user {}".format(uw_acc0))
if uw_acc0.has_bridge_id():
bridge_acc = bridge_dao.get_user_by_bridgeid(
uw_acc0.bridge_id)
if bridge_acc is not None:
if bridge_acc.is_deleted():
if not uw_acc0.disabled:
uw_acc0.set_disable()
logger.info(
"Account already disabled {}".format(uw_acc0))
return
if bridge_dao.delete_bridge_user(bridge_acc):
logger.info("DELETE {}".format(bridge_acc))
uw_acc0.set_disable()
logger.info("Disabled {}".format(uw_acc0))
return
bridge_acc = bridge_dao.get_user_by_uwnetid(uwnetid)
person = get_person(uwnetid)
uw_acc = save_uw_account(person)
logger.info("Matched account in DB {}".format(uw_acc))
if bridge_acc is None:
if uw_acc.has_prev_netid():
logger.info("CHANGED NETID {}".format(uw_acc))
bridge_acc = bridge_dao.get_user_by_uwnetid(
uw_acc.prev_netid)
if bridge_acc is not None:
uw_acc.set_ids(bridge_acc.bridge_id,
person.employee_id)
bridge_acc1 = bridge_dao.change_uwnetid(uw_acc)
if bridge_acc1.netid == uw_acc.netid:
if bridge_dao.delete_bridge_user(bridge_acc1):
logger.info("DELETE {}".format(bridge_acc1))
uw_acc.set_disable()
logger.info("Disabled {}".format(uw_acc))
return
except Exception as ex:
logger.error(str(ex))
def make_import_user_csv_files(uw_accounts, filepath):
"""
:param uw_accounts: a list of UwAccount objects
Writes all csv files. Returns number of records wrote out.
"""
if not uw_accounts or len(uw_accounts) == 0:
return 0
file_size = get_csv_file_size()
total_users = len(uw_accounts)
f_index = 1
user_number = 0
csv_headers = get_aline_csv(get_headers())
f = open_file(get_user_file_name(filepath, f_index))
f.write(csv_headers)
for uw_account in uw_accounts:
if uw_account.disabled or uw_account.has_terminate_date():
continue
person = get_person(uw_account.netid)
if (person is None or person.is_test_entity
or not person.is_emp_state_current()):
continue
if person.uwnetid != uw_account.netid:
logger.error("OLD netid, Skip {0}".format(uw_account))
continue
aline = get_aline_csv(get_attr_list(person, get_worker(person)))
try:
f.write(aline)
except Exception:
log_exception(logger,
"{0:d}th file: ({1}), Skip!".format(f_index, aline),
traceback.format_exc())
continue
user_number += 1
if user_number < total_users and (user_number % file_size) == 0:
f.close()
logger.info("Finish writing {0:d} entries.".format(user_number))
f_index += 1
f = open_file(get_user_file_name(filepath, f_index))
f.write(csv_headers)
f.close()
logger.info("Finish writing {0:d} entries.".format(user_number))
return user_number
def load():
total = 0
updated = 0
for uw_acc in get_all_uw_accounts():
uwnetid = uw_acc.netid
person = get_person(uwnetid)
if (person is not None and person.is_employee and
person.is_test_entity is False):
total += 1
if (uw_acc.employee_id is None or
uw_acc.employee_id != person.employee_id):
uw_acc.set_employee_id(person.employee_id)
uw_acc.save()
updated += 1
msg = "Updated employee_ids for {0} out of {1} users".format(
updated, total)
logger.info(msg)
return msg
def add_author_role(self, netid):
action = "SET AUTHOR on {0}".format(netid)
try:
person = get_person(netid)
if not self.is_invalid_person(netid, person):
uw_account = save_uw_account(person)
bridge_acc = self.match_bridge_account(uw_account)
if bridge_acc is None or bridge_acc.netid != uw_account.netid:
self.add_error(
"New author {0}'s account NOT in Bridge!".format(
uw_account))
return
bridge_acc.add_role(self.new_author_role())
self.worker.update_user_role(bridge_acc)
logger.info(action)
except Exception as ex:
self.handle_exception("Failed to {0} ".format(action),
ex, traceback)
def get_validated_user(logger, uwnetid, uwregid=None, users_in_gws=[]):
"""
Validate an existing user.
return the corresponding Person object and a status
raise DataFailureException if failed to access GWS or PWS
"""
try:
if uwregid is None:
person = get_person(uwnetid)
else:
person = get_person_by_regid(uwregid)
# changed takes priority over left UW
if person.uwnetid != uwnetid:
return person, CHANGED
if uwregid is not None and person.uwregid != uwregid:
return person, CHANGED
if _user_left_uw(users_in_gws, uwnetid):
logger.info("validate '%s' has left uw!", uwnetid)
return person, LEFT_UW
return person, VALID
except InvalidNetID:
logger.error("validate_by_netid: '%s' invalid!",
uwnetid)
return None, INVALID
except InvalidRegID:
logger.error("validate_by_regid: '%s' invalid!",
uwregid)
return None, INVALID
except DataFailureException as ex:
if ex.status == 404:
# shared or system netids
logger.info("validate ('%s', %s) not personal netid/regid",
uwnetid, uwregid)
return None, DISALLOWED
log_exception(logger,
"validate ('%s', %s) failed, skip!" % (uwnetid,
uwregid),
traceback.format_exc())
raise
def test_get_work_position(self):
self.assertIsNone(get_work_position(None, -1))
person = get_person('javerage')
hrp_wkr = get_worker(person)
self.assertIsNone(get_work_position(hrp_wkr, -1))
pos1 = get_work_position(hrp_wkr, 0)
self.assertTrue(pos1.is_primary)
self.assertEqual(pos1.title, "Student Reference Specialist - GMM")
hrp_wkr.primary_position = None
self.assertIsNone(get_work_position(hrp_wkr, 0))
pos2 = get_work_position(hrp_wkr, 1)
self.assertFalse(pos2.is_primary)
self.assertEqual(pos2.title, "Reader/Grader")
self.assertIsNone(get_work_position(hrp_wkr, 3))
hrp_wkr.other_active_positions = []
self.assertIsNone(get_work_position(hrp_wkr, 1))
def process_users(self):
for bridge_acc in self.get_users_to_process():
if self.not_accessed(bridge_acc):
continue
logger.info("Validate {0}".format(bridge_acc))
uwnetid = bridge_acc.netid
bridge_id = bridge_acc.bridge_id
person = get_person(uwnetid)
if self.is_invalid_person(uwnetid, person):
continue
self.total_checked_users += 1
if is_prior_netid(uwnetid, person):
cur_bri_acc = self.get_bridge().get_user_by_uwnetid(
person.uwnetid)
if (cur_bri_acc is not None and
bridge_id != cur_bri_acc.bridge_id):
cur_uw_acc = get_by_netid(person.uwnetid)
if cur_uw_acc is not None:
uw_acc = get_by_netid(uwnetid)
if uw_acc is None:
# connect this account with that one
cur_uw_acc.prev_netid = uwnetid
cur_uw_acc.save()
# the current netid has another account in DB
# this account will be merged then.
self.logger.info(
"HOLD prior acc {0} UNTIL {1}".format(
bridge_acc, cur_bri_acc))
continue
# 1. If bridge_acc has a current netid; otherwise
# 2. if the one with current netid NOT exists.
self.take_action(person, bridge_acc)
def test_get_worker(self):
for netid in ['staff', 'faculty']:
person = get_person(netid)
worker = get_worker(person)
self.assertEqual(worker.netid, netid)
person = get_person('javerage')
worker = get_worker(person)
self.assertIsNotNone(worker.primary_position)
self.assertEqual(len(worker.other_active_positions), 1)
person = get_person('affiemp')
self.assertIsNone(get_worker(person))
person = get_person('alumni')
self.assertIsNone(get_worker(person))
person = get_person('bill')
self.assertIsNone(get_worker(person))
person = get_person('error500')
self.assertIsNone(get_worker(person))
def test_2existing_accounts_with_id_changes(self):
user1 = UwBridgeUser(netid='staff',
regid='0136CCB8F66711D5BE060004AC494FFE',
last_visited_at=get_now(),
first_name="Changed",
last_name="Regid")
user1.save()
user2 = UwBridgeUser(netid='changed',
regid="10000000000000000000000000000001",
last_visited_at=get_now(),
first_name="Changed",
last_name="Netid")
user2.save()
self.assertTrue(is_moved_netid('changed'))
self.assertTrue(is_moved_regid('0136CCB8F66711D5BE060004AC494FFE'))
# both records are active
self.assertTrue(_are_all_active([user1, user2]))
self.assertFalse(_are_all_disabled([user1, user2]))
person = get_person('staff')
self.assertIsNotNone(person)
old_user = _get_netid_changed_user([user1, user2], person)
self.assertIsNotNone(old_user)
self.assertEqual(old_user.netid, 'changed')
self.assertTrue(_changed_regid([user1, user2], person))
user_upd, user_del = save_user(person, include_hrp=False)
self.assertIsNotNone(user_upd)
self.assertFalse(user_upd.regid_changed())
self.assertTrue(user_upd.is_update())
self.assertEqual(user_upd.netid, 'staff')
self.assertEqual(user_upd.regid,
"10000000000000000000000000000001")
self.assertIsNotNone(user_del)
self.assertEqual(user_del.netid, 'changed')
self.assertEqual(user_del.regid,
"10000000000000000000000000000001")
user_upd.delete()
# both records are disabled
user1.disabled = True
user1.save()
user2.disabled = True
user2.save()
self.assertTrue(_are_all_disabled([user1, user2]))
user_upd, user_del = save_user(person, include_hrp=False)
self.assertIsNotNone(user_upd)
self.assertFalse(user_upd.netid_changed())
self.assertFalse(user_upd.regid_changed())
self.assertTrue(user_upd.is_restore())
self.assertEqual(user_upd.netid, 'staff')
self.assertEqual(user_upd.regid,
"10000000000000000000000000000001")
self.assertIsNone(user_del)
user_upd.delete()
# the disabled record is with the new netid
user1.disabled = True
user1.save()
user2.disabled = False
user2.save()
self.assertFalse(_are_all_active([user1, user2]))
self.assertFalse(_are_all_disabled([user1, user2]))
user_upd, user_del = save_user(person, include_hrp=False)
self.assertIsNotNone(user_upd)
self.assertTrue(user_upd.netid_changed())
self.assertFalse(user_upd.regid_changed())
self.assertFalse(user_upd.is_restore())
self.assertEqual(user_upd.netid, 'staff')
self.assertEqual(user_upd.prev_netid, 'changed')
self.assertEqual(user_upd.regid,
"10000000000000000000000000000001")
self.assertIsNone(user_del)
user_upd.delete()
# the disabled record is with the old netid
user1.disabled = False
user1.save()
user2.disabled = True
user2.save()
user_upd, user_del = save_user(person, include_hrp=False)
self.assertIsNotNone(user_upd)
self.assertTrue(user_upd.is_update())
self.assertFalse(user_upd.netid_changed())
self.assertFalse(user_upd.regid_changed())
self.assertFalse(user_upd.is_restore())
self.assertEqual(user_upd.netid, 'staff')
self.assertEqual(user_upd.regid,
"10000000000000000000000000000001")
self.assertIsNone(user_del)
user_upd.delete()
def test_get_appointee(self):
person = get_person('staff')
self.assertIsNotNone(person)
appointee = get_appointee(person)
self.assertEqual(appointee.employee_id,
'100000001')
def test_none_appointee(self):
person = get_person('retiree')
self.assertIsNotNone(person)
appointee = get_appointee(person)
self.assertIsNone(appointee)
def test_get_job_title(self):
self.assertIsNone(get_job_title(None))
person = get_person('javerage')
hrp_wkr = get_worker(person)
self.assertEqual(get_job_title(hrp_wkr),
"Student Reference Specialist - GMM")
def test_get_email(self):
person = get_person('retiree')
self.assertEqual(get_email(person), "*****@*****.**")
person.email_addresses.append("[email protected]. ")
self.assertEqual(get_email(person), "*****@*****.**")
