def test_update_current_employees(minimal_database, data_source):
create_new_employees_from_list(data_source)
user = User.query(User.email == '*****@*****.**').get()
assert user.photo_url == 'www.cdn.com/SamSmith.png'
assert user.metadata == {
'department': 'Engineering',
'title': 'Engineer',
'floor': '10',
'desk': '100',
'manager': 'Bo Demillo'
}
local_data_employee = {user.email: user for user in User.query().fetch()}
remote_data_employee = hash_employee_data(data_source)
remote_data_employee['*****@*****.**']['photo_url'] = 'new'
remote_data_employee['*****@*****.**']['department'] = 'Sales'
remote_data_employee['*****@*****.**']['metadata'][
'department'] = 'Sales'
update_current_employees(local_data_employee, remote_data_employee)
user = User.query(User.email == '*****@*****.**').get()
assert user.photo_url == 'new'
assert user.metadata['department'] == 'Sales'
assert user.metadata == {
'department': 'Sales',
'title': 'Engineer',
'floor': '10',
'desk': '100',
'manager': 'Bo Demillo'
}
def test_sync_marks_employee_as_terminated(database, data_source):
"""
Data source contains a list of active users for beans. If the user
is not present in the data source, but present in our database we
mark the employee as terminated
"""
sync_employees(data_source)
user = User.query(User.email == '*****@*****.**').get()
assert not user.terminated
sync_employees({})
user = User.query(User.email == '*****@*****.**').get()
assert user.terminated
def get_users_from_spec(meeting_spec):
logging.info('Meeting subscription for spec:')
logging.info(meeting_spec.meeting_subscription)
logging.info('All Preferences')
logging.info(UserSubscriptionPreferences.query().fetch())
user_sub_preferences = UserSubscriptionPreferences.query(
UserSubscriptionPreferences.subscription ==
meeting_spec.meeting_subscription).fetch()
logging.info('User Preferences')
logging.info(user_sub_preferences)
users = []
for user_preference in user_sub_preferences:
if user_preference.preference:
logging.info('User Preference')
logging.info(user_preference.preference)
logging.info(user_preference.preference.get())
preference_dt = user_preference.preference.get().datetime
if preference_dt.hour == meeting_spec.datetime.hour and \
preference_dt.minute == meeting_spec.datetime.minute and \
preference_dt.weekday() == meeting_spec.datetime.weekday():
user = User.query(User.subscription_preferences ==
user_preference.key).get()
logging.info('user added: ')
logging.info(user)
users.append(user)
return users
def test_sync_creates_new_employee(database, data_source):
"""
Data source contains a user that we don't have in our database,
we must create a new user in our database.
"""
sync_employees(data_source)
user = User.query(User.email == '*****@*****.**').get()
assert user.first_name == 'Sam'
def test_sync_updates_current_employee(database, data_source):
"""
Data source contains a user that we are already tracking in our database,
we must update the user in the database to reflect new information.
Returns
"""
sync_employees(data_source)
user = User.query(User.email == '*****@*****.**').get()
assert user.first_name == 'Sam'
assert user.metadata['department'] == 'Engineering'
data = data_source[0]
data['first_name'] = 'John'
data['department'] = 'Design'
data['metadata']['department'] = 'Design'
sync_employees(data_source)
user = User.query(User.email == '*****@*****.**').get()
assert user.first_name == 'John'
assert user.metadata['department'] == 'Design'
def test_create_new_employees_from_list(minimal_database, data_source):
create_new_employees_from_list(data_source)
user = User.query(User.email == '*****@*****.**').get()
assert user.email == '*****@*****.**'
assert user.metadata == {
'department': 'Engineering',
'title': 'Engineer',
'floor': '10',
'desk': '100',
'manager': 'Bo Demillo'
}
def create_dev_data():
email = FAKE_USER[0]['email']
user = User.query(User.email == email).get()
if not user:
_subscription()
time.sleep(2)
_fake_user()
subscription = MeetingSubscription.query().get()
week_start, specs = get_specs_from_subscription(subscription)
store_specs_from_subscription(subscription.key, week_start, specs)
logging.info('generated fake date for dev')
def get_subscribers():
users = User.query().fetch()
subscriptions = MeetingSubscription.query().fetch()
metrics = defaultdict(set)
# creates metrics keys for all subscriptions including ones without users
for subscription in subscriptions:
metrics[subscription.key.urlsafe()] = []
# creates metrics keys for all subscriptions that have users with user data
for user in users:
for preference in user.subscription_preferences:
metrics[preference.get().subscription.urlsafe()].append(user.email)
return metrics
def test_mark_terminated_employees(database, fake_user):
mark_termed_employees([fake_user])
user = User.query().get()
assert user.terminated
def sync_employees(employee_data):
"""
Employee data must include:
- email
- first_name
- last_name
- photo_url
All other information will be included in the data store as
metadata.
Parameters
----------
remote_data = json
Returns
-------
success: integer, 0 successful, 1 failure
"""
validate_employee_data(employee_data)
remote_employee_data = hash_employee_data(employee_data)
# get data from local database
local_employee_data = {
employee.email: employee
for employee in User.query().fetch()
}
local_employees = set(local_employee_data.keys())
remote_employees = set(remote_employee_data.keys())
new_employees = remote_employees - local_employees
if new_employees:
logging.info('Creating new employees.')
new_employees_list = [
remote_employee_data[employee] for employee in new_employees
]
create_new_employees_from_list(new_employees_list)
logging.info('{} employees added'.format(len(new_employees)))
logging.info(new_employees)
termed_employees = local_employees - remote_employees
if termed_employees:
logging.info('Marking termed employees')
termed_employees_ndb = [
local_employee_data[employee] for employee in termed_employees
]
mark_termed_employees(termed_employees_ndb)
logging.info('{} employees marked as termed'.format(
len(termed_employees)))
logging.info(termed_employees)
current_employees = remote_employees.intersection(local_employees)
if current_employees:
logging.info('Updating current employees')
remote_employee_data = {
employee: remote_employee_data[employee]
for employee in current_employees
}
local_employee_data = {
employee: local_employee_data[employee]
for employee in current_employees
}
update_current_employees(local_employee_data, remote_employee_data)
logging.info('{} employees updated'.format(len(current_employees)))
logging.info(current_employees)
def get_user(email=None):
if email is None:
current_user = google_user_api.get_current_user()
email = current_user.email()
return User.query(User.email == email).get()
