def __init__(self, request, response): # pylint: disable=super-init-not-called
# Set self.request, self.response and self.app.
self.initialize(request, response)
self.start_time = datetime.datetime.utcnow()
# Initializes the return dict for the handlers.
self.values = {}
self.user_id = current_user_services.get_current_user_id()
self.username = None
self.partially_logged_in = False
if self.user_id:
user_settings = user_services.get_user_settings(
self.user_id, strict=False)
if user_settings is None:
email = current_user_services.get_current_user_email()
user_settings = user_services.create_new_user(
self.user_id, email)
self.values['user_email'] = user_settings.email
if (self.REDIRECT_UNFINISHED_SIGNUPS and not
user_services.has_fully_registered(self.user_id)):
_clear_login_cookies(self.response.headers)
self.partially_logged_in = True
self.user_id = None
else:
self.username = user_settings.username
self.values['username'] = self.username
# In order to avoid too many datastore writes, we do not bother
# recording a log-in if the current time is sufficiently close
# to the last log-in time.
if (user_settings.last_logged_in is None or
not utils.are_datetimes_close(
datetime.datetime.utcnow(),
user_settings.last_logged_in)):
user_services.record_user_logged_in(self.user_id)
self.role = (
feconf.ROLE_ID_GUEST
if self.user_id is None else user_settings.role)
self.user = user_services.UserActionsInfo(self.user_id)
self.is_super_admin = (
current_user_services.is_current_user_super_admin())
self.values['iframed'] = False
self.values['is_moderator'] = user_services.is_at_least_moderator(
self.user_id)
self.values['is_admin'] = user_services.is_admin(self.user_id)
self.values['is_topic_manager'] = (
user_services.is_topic_manager(self.user_id))
self.values['is_super_admin'] = self.is_super_admin
if self.request.get('payload'):
self.payload = json.loads(self.request.get('payload'))
else:
self.payload = None
def test_set_and_get_user_email_preferences(self):
user_id = 'someUser'
username = '******'
user_email = '*****@*****.**'
user_services.create_new_user(user_id, user_email)
user_services.set_username(user_id, username)
# When UserEmailPreferencesModel is yet to be created,
# the value returned by get_email_preferences() should be True.
email_preferences = user_services.get_email_preferences(user_id)
self.assertEquals(
email_preferences.can_receive_editor_role_email,
feconf.DEFAULT_EDITOR_ROLE_EMAIL_PREFERENCE)
email_preferences = user_services.get_email_preferences(user_id)
self.assertEquals(
email_preferences.can_receive_feedback_message_email,
feconf.DEFAULT_FEEDBACK_MESSAGE_EMAIL_PREFERENCE)
# The user retrieves their email preferences. This initializes
# a UserEmailPreferencesModel instance with the default values.
user_services.update_email_preferences(
user_id, feconf.DEFAULT_EMAIL_UPDATES_PREFERENCE,
feconf.DEFAULT_EDITOR_ROLE_EMAIL_PREFERENCE,
feconf.DEFAULT_FEEDBACK_MESSAGE_EMAIL_PREFERENCE,
feconf.DEFAULT_SUBSCRIPTION_EMAIL_PREFERENCE)
email_preferences = user_services.get_email_preferences(user_id)
self.assertEquals(
email_preferences.can_receive_editor_role_email,
feconf.DEFAULT_EDITOR_ROLE_EMAIL_PREFERENCE)
self.assertEquals(
email_preferences.can_receive_feedback_message_email,
feconf.DEFAULT_FEEDBACK_MESSAGE_EMAIL_PREFERENCE)
# The user sets their membership email preference to False.
user_services.update_email_preferences(
user_id, feconf.DEFAULT_EMAIL_UPDATES_PREFERENCE, False, False,
False)
email_preferences = user_services.get_email_preferences(user_id)
self.assertFalse(email_preferences.can_receive_editor_role_email)
self.assertFalse(email_preferences.can_receive_feedback_message_email)
self.assertFalse(email_preferences.can_receive_subscription_email)
def test_update_user_creator_dashboard_display(self):
user_id = 'test_id'
username = '******'
user_email = '*****@*****.**'
user_services.create_new_user(user_id, user_email)
user_services.set_username(user_id, username)
user_setting = user_services.get_user_settings(user_id)
self.assertEqual(
user_setting.creator_dashboard_display_pref,
constants.ALLOWED_CREATOR_DASHBOARD_DISPLAY_PREFS['CARD'])
user_services.update_user_creator_dashboard_display(
user_id, constants.ALLOWED_CREATOR_DASHBOARD_DISPLAY_PREFS['LIST'])
user_setting = user_services.get_user_settings(user_id)
self.assertEqual(
user_setting.creator_dashboard_display_pref,
constants.ALLOWED_CREATOR_DASHBOARD_DISPLAY_PREFS['LIST'])
def test_get_usernames(self):
user_ids = ['test1', feconf.SYSTEM_COMMITTER_ID, 'test2']
usernames = ['name1', feconf.SYSTEM_COMMITTER_ID, 'name2']
user_emails = [
'*****@*****.**', feconf.SYSTEM_EMAIL_ADDRESS, '*****@*****.**'
]
for uid, email, name in zip(user_ids, user_emails, usernames):
if uid != feconf.SYSTEM_COMMITTER_ID:
user_services.create_new_user(uid, email)
user_services.set_username(uid, name)
# Handle usernames that exists.
self.assertEqual(usernames, user_services.get_usernames(user_ids))
# Return empty list when no user id passed.
self.assertEqual([], user_services.get_usernames([]))
# Return None for usernames that don't exists.
self.assertEqual([None, 'name1'],
user_services.get_usernames(['fakeUser', 'test1']))
def test_get_human_readable_user_ids_with_nonexistent_id_non_strict_passes(
self):
user_id = user_services.create_new_user('auth_id',
'*****@*****.**').user_id
user_services.set_username(user_id, 'username')
user_services.mark_user_for_deletion(user_id)
human_readable_user_ids = user_services.get_human_readable_user_ids(
[user_id], strict=False)
self.assertEqual(human_readable_user_ids,
[user_services.LABEL_FOR_USER_BEING_DELETED])
def test_get_user_id_from_username(self):
user_id = 'someUser'
username = '******'
user_email = '*****@*****.**'
user_services.create_new_user(user_id, user_email)
user_services.set_username(user_id, username)
self.assertEquals(user_services.get_username(user_id), username)
# Handle usernames that exist.
self.assertEquals(user_services.get_user_id_from_username(username),
user_id)
# Handle usernames in the same equivalence class correctly.
self.assertEquals(user_services.get_user_id_from_username('USERNAME'),
user_id)
# Return None for usernames which don't exist.
self.assertIsNone(
user_services.get_user_id_from_username('fakeUsername'))
def test_default_dashboard_for_new_users(self):
self.login(self.EDITOR_EMAIL)
self.get_html_response(feconf.SIGNUP_URL + '?return_url=/')
csrf_token = self.get_new_csrf_token()
# This user should have the creator dashboard as default.
self.post_json(feconf.SIGNUP_DATA_URL, {
'agreed_to_terms': True,
'username': self.EDITOR_USERNAME,
'default_dashboard': constants.DASHBOARD_TYPE_CREATOR,
'can_receive_email_updates': None
},
csrf_token=csrf_token)
user_id = user_services.get_user_id_from_username(self.EDITOR_USERNAME)
user_settings = user_services.get_user_settings(user_id)
self.assertEqual(user_settings.default_dashboard,
constants.DASHBOARD_TYPE_CREATOR)
self.logout()
user_services.create_new_user(
self.get_gae_id_from_email(self.VIEWER_EMAIL), self.VIEWER_EMAIL)
self.login(self.VIEWER_EMAIL)
csrf_token = self.get_new_csrf_token()
# This user should have the learner dashboard as default.
self.post_json(feconf.SIGNUP_DATA_URL, {
'agreed_to_terms': True,
'username': self.VIEWER_USERNAME,
'default_dashboard': constants.DASHBOARD_TYPE_LEARNER,
'can_receive_email_updates': None
},
csrf_token=csrf_token)
user_id = user_services.get_user_id_from_username(self.VIEWER_USERNAME)
user_settings = user_services.get_user_settings(user_id)
self.assertEqual(user_settings.default_dashboard,
constants.DASHBOARD_TYPE_LEARNER)
self.logout()
def test_email_truncation(self):
email_addresses = [
('[email protected]', '[email protected]'),
('[email protected]', '[email protected]'),
('*****@*****.**', '*****@*****.**'),
('[email protected]', '[email protected]'),
('[email protected]', '[email protected]'),
]
for ind, (actual_email, expected_email) in enumerate(email_addresses):
user_settings = user_services.create_new_user(
str(ind), actual_email)
self.assertEqual(user_settings.truncated_email, expected_email)
def test_username_check(self):
self.signup('*****@*****.**', 'abc')
user_services.create_new_user(
self.get_auth_id_from_email(self.EDITOR_EMAIL), self.EDITOR_EMAIL)
self.login(self.EDITOR_EMAIL)
csrf_token = self.get_new_csrf_token()
response_dict = self.post_json(
feconf.USERNAME_CHECK_DATA_URL, {'username': '******'},
csrf_token=csrf_token)
self.assertEqual(
response_dict, {
'username_is_taken': True
})
response_dict = self.post_json(
feconf.USERNAME_CHECK_DATA_URL, {'username': '******'},
csrf_token=csrf_token)
self.assertEqual(
response_dict, {
'username_is_taken': False
})
response_dict = self.post_json(
feconf.USERNAME_CHECK_DATA_URL, {'username': '******'},
csrf_token=csrf_token, expected_status_int=400)
self.assertIn(
'can only have alphanumeric characters', response_dict['error'])
response_dict = self.post_json(
feconf.USERNAME_CHECK_DATA_URL,
{'username': self.UNICODE_TEST_STRING},
csrf_token=csrf_token, expected_status_int=400)
self.assertIn(
'can only have alphanumeric characters', response_dict['error'])
self.logout()
def test_created_on_gets_updated_correctly(self):
# created_on should not be updated upon updating other attributes of
# the user settings model.
user_settings = user_services.create_new_user('auth_id',
'*****@*****.**')
user_settings_model = user_models.UserSettingsModel.get_by_id(
user_settings.user_id)
time_of_creation = user_settings_model.created_on
user_services.update_user_bio(user_settings.user_id, 'New bio.')
user_settings_model = user_models.UserSettingsModel.get_by_id(
user_settings.user_id)
self.assertEqual(user_settings_model.created_on, time_of_creation)
def test_get_user_ids_by_role(self):
user_ids = ['test1', 'test2', 'test3', 'test4']
usernames = ['name1', 'name2', 'name3', 'name4']
user_emails = [
'*****@*****.**', '*****@*****.**', '*****@*****.**',
'*****@*****.**'
]
for uid, email, name in zip(user_ids, user_emails, usernames):
user_services.create_new_user(uid, email)
user_services.set_username(uid, name)
user_services.update_user_role(user_ids[0], feconf.ROLE_ID_MODERATOR)
user_services.update_user_role(user_ids[1], feconf.ROLE_ID_MODERATOR)
user_services.update_user_role(user_ids[2], feconf.ROLE_ID_BANNED_USER)
user_services.update_user_role(user_ids[3], feconf.ROLE_ID_BANNED_USER)
self.assertEqual(
set(user_services.get_user_ids_by_role(feconf.ROLE_ID_MODERATOR)),
set(['test1', 'test2']))
self.assertEqual(
set(user_services.get_user_ids_by_role(
feconf.ROLE_ID_BANNED_USER)), set(['test3', 'test4']))
def test_get_exploration_user_data(self) -> None:
auth_id = 'test_id'
username = '******'
user_email = '*****@*****.**'
user_id = user_services.create_new_user(auth_id, user_email).user_id
user_services.set_username(user_id, username)
user_services.update_learner_checkpoint_progress(
user_id, self.EXP_1_ID, 'Introduction', 1)
expected_user_data_dict = {
'rating':
None,
'rated_on':
None,
'draft_change_list':
None,
'draft_change_list_last_updated':
None,
'draft_change_list_exp_version':
None,
'draft_change_list_id':
0,
'mute_suggestion_notifications':
(feconf.DEFAULT_SUGGESTION_NOTIFICATIONS_MUTED_PREFERENCE),
'mute_feedback_notifications':
(feconf.DEFAULT_FEEDBACK_NOTIFICATIONS_MUTED_PREFERENCE),
'furthest_reached_checkpoint_exp_version':
1,
'furthest_reached_checkpoint_state_name':
'Introduction',
'most_recently_reached_checkpoint_exp_version':
1,
'most_recently_reached_checkpoint_state_name':
'Introduction'
}
exp_user_data = exp_fetchers.get_exploration_user_data(
user_id, self.EXP_1_ID)
# Ruling out the possibility of None for mypy type checking.
assert exp_user_data is not None
self.assertEqual(expected_user_data_dict, exp_user_data.to_dict())
def setUp(self):
super(SearchServicesUnitTests, self).setUp()
self.owner_id = self.get_user_id_from_email(self.OWNER_EMAIL)
self.editor_id = self.get_user_id_from_email(self.EDITOR_EMAIL)
self.translator_id = self.get_user_id_from_email(self.TRANSLATOR_EMAIL)
self.viewer_id = self.get_user_id_from_email(self.VIEWER_EMAIL)
user_services.create_new_user(self.owner_id, self.OWNER_EMAIL)
user_services.create_new_user(self.editor_id, self.EDITOR_EMAIL)
user_services.create_new_user(self.translator_id, self.TRANSLATOR_EMAIL)
user_services.create_new_user(self.viewer_id, self.VIEWER_EMAIL)
self.signup(self.OWNER_EMAIL, self.OWNER_USERNAME)
self.signup(self.EDITOR_EMAIL, self.EDITOR_USERNAME)
self.signup(self.TRANSLATOR_EMAIL, self.TRANSLATOR_USERNAME)
self.signup(self.VIEWER_EMAIL, self.VIEWER_USERNAME)
self.signup(self.ADMIN_EMAIL, self.ADMIN_USERNAME)
self.owner = user_services.UserActionsInfo(self.owner_id)
self.set_admins([self.ADMIN_USERNAME])
self.user_id_admin = self.get_user_id_from_email(self.ADMIN_EMAIL)
def setUp(self):
super(FeedbackThreadDomainUnitTests, self).setUp()
self.viewer_id = self.get_user_id_from_email(self.VIEWER_EMAIL)
user_services.create_new_user(self.viewer_id, self.VIEWER_EMAIL)
self.signup(self.VIEWER_EMAIL, self.VIEWER_USERNAME)
def __init__(self, request, response): # pylint: disable=super-init-not-called
# Set self.request, self.response and self.app.
self.initialize(request, response)
self.start_time = datetime.datetime.utcnow()
# Initializes the return dict for the handlers.
self.values = {}
# This try-catch block is intended to log cases where getting the
# request payload errors with ValueError: Invalid boundary in multipart
# form: b''. This is done to gather sufficient data to help debug the
# error if it arises in the future.
try:
payload_json_string = self.request.get('payload')
except ValueError as e:
logging.error('%s: request %s', e, self.request)
raise e
# TODO(#13155): Remove the if-else part once all the handlers have had
# schema validation implemented.
if payload_json_string:
self.payload = json.loads(payload_json_string)
else:
self.payload = None
self.iframed = False
self.user_id = None
self.username = None
self.email = None
self.partially_logged_in = False
self.user_is_scheduled_for_deletion = False
self.current_user_is_super_admin = False
# Once the attribute `normalized_request` is type annotated here, make
# sure to fix all the subclasses using normalized_request.get() method
# by removing their type: ignore[union-attr] and using a type cast
# instead to eliminate the possibility on union types.
# e.g. ClassroomAccessValidationHandler.
self.normalized_request = None
self.normalized_payload = None
try:
auth_claims = auth_services.get_auth_claims_from_request(request)
except auth_domain.StaleAuthSessionError:
auth_services.destroy_auth_session(self.response)
self.redirect(user_services.create_login_url(self.request.uri))
return
except auth_domain.UserDisabledError:
auth_services.destroy_auth_session(self.response)
self.redirect('/logout?redirect_url=%s' %
feconf.PENDING_ACCOUNT_DELETION_URL)
return
except auth_domain.InvalidAuthSessionError:
logging.exception('User session is invalid!')
auth_services.destroy_auth_session(self.response)
self.redirect(user_services.create_login_url(self.request.uri))
return
else:
self.current_user_is_super_admin = (
auth_claims is not None and auth_claims.role_is_super_admin)
if auth_claims:
auth_id = auth_claims.auth_id
user_settings = user_services.get_user_settings_by_auth_id(auth_id)
if user_settings is None:
# If the user settings are not yet created and the request leads
# to signup page create a new user settings. Otherwise logout
# the not-fully registered user.
email = auth_claims.email
if 'signup?' in self.request.uri:
user_settings = (user_services.create_new_user(
auth_id, email))
else:
logging.exception(
'Cannot find user %s with email %s on page %s' %
(auth_id, email, self.request.uri))
auth_services.destroy_auth_session(self.response)
return
self.email = user_settings.email
self.values['user_email'] = user_settings.email
self.user_id = user_settings.user_id
if user_settings.deleted:
self.user_is_scheduled_for_deletion = user_settings.deleted
elif (self.REDIRECT_UNFINISHED_SIGNUPS
and not user_services.has_fully_registered_account(
self.user_id)):
self.partially_logged_in = True
else:
self.username = user_settings.username
self.values['username'] = self.username
# In order to avoid too many datastore writes, we do not bother
# recording a log-in if the current time is sufficiently close
# to the last log-in time.
if (user_settings.last_logged_in is None
or not utils.are_datetimes_close(
datetime.datetime.utcnow(),
user_settings.last_logged_in)):
user_services.record_user_logged_in(self.user_id)
self.roles = ([feconf.ROLE_ID_GUEST]
if self.user_id is None else user_settings.roles)
self.user = user_services.get_user_actions_info(self.user_id)
if not self._is_requested_path_currently_accessible_to_user():
auth_services.destroy_auth_session(self.response)
return
self.values['is_super_admin'] = self.current_user_is_super_admin
def test_is_username_taken_different_case(self):
user_id = 'someUser'
username = '******'
user_services.create_new_user(user_id, '*****@*****.**')
user_services.set_username(user_id, username)
self.assertTrue(user_services.is_username_taken('CaMeLcAsE'))
def test_invalid_emails(self):
bad_email_addresses = ['@', '@@', 'abc', '', None, ['a', '@', 'b.com']]
for email in bad_email_addresses:
with self.assertRaises(utils.ValidationError):
user_services.create_new_user('user_id', email)
def test_get_username_none(self):
user_services.create_new_user('fakeUser', '*****@*****.**')
self.assertEquals(None, user_services.get_username('fakeUser'))
def test_exploration_user_data_is_none_before_starting_exploration(self):
auth_id = 'test_id'
user_email = '*****@*****.**'
user_id = user_services.create_new_user(auth_id, user_email).user_id
self.assertIsNone(exp_fetchers.get_exploration_user_data(
user_id, self.EXP_1_ID))
def __init__(self, request, response): # pylint: disable=super-init-not-called
# Set self.request, self.response and self.app.
self.initialize(request, response)
self.start_time = datetime.datetime.utcnow()
# Initializes the return dict for the handlers.
self.values = {}
self.user = current_user_services.get_current_user()
self.user_id = current_user_services.get_user_id(
self.user) if self.user else None
self.username = None
self.has_seen_editor_tutorial = False
self.partially_logged_in = False
self.values['profile_picture_data_url'] = None
self.preferred_site_language_code = None
if self.user_id:
user_settings = user_services.get_user_settings(
self.user_id, strict=False)
if user_settings is None:
email = current_user_services.get_user_email(self.user)
user_settings = user_services.create_new_user(
self.user_id, email)
self.values['user_email'] = user_settings.email
if (self.REDIRECT_UNFINISHED_SIGNUPS and not
user_services.has_fully_registered(self.user_id)):
_clear_login_cookies(self.response.headers)
self.partially_logged_in = True
self.user_id = None
else:
self.username = user_settings.username
self.preferred_site_language_code = (
user_settings.preferred_site_language_code)
self.values['username'] = self.username
self.values['profile_picture_data_url'] = (
user_settings.profile_picture_data_url)
if user_settings.last_started_state_editor_tutorial:
self.has_seen_editor_tutorial = True
# In order to avoid too many datastore writes, we do not bother
# recording a log-in if the current time is sufficiently close
# to the last log-in time.
if (user_settings.last_logged_in is None or
not utils.are_datetimes_close(
datetime.datetime.utcnow(),
user_settings.last_logged_in)):
user_services.record_user_logged_in(self.user_id)
rights_mgr_user = rights_manager.Actor(self.user_id)
self.is_moderator = rights_mgr_user.is_moderator()
self.is_admin = rights_mgr_user.is_admin()
self.is_super_admin = (
current_user_services.is_current_user_super_admin())
self.values['is_moderator'] = self.is_moderator
self.values['is_admin'] = self.is_admin
self.values['is_super_admin'] = self.is_super_admin
if self.request.get('payload'):
self.payload = json.loads(self.request.get('payload'))
else:
self.payload = None
def __init__(self, request, response): # pylint: disable=super-init-not-called
# Set self.request, self.response and self.app.
self.initialize(request, response)
self.start_time = datetime.datetime.utcnow()
# Initializes the return dict for the handlers.
self.values = {}
if self.request.get('payload'):
self.payload = json.loads(self.request.get('payload'))
else:
self.payload = None
self.iframed = False
auth_claims = auth_services.get_auth_claims_from_request(request)
self.current_user_is_super_admin = (auth_claims is not None and
auth_claims.role_is_super_admin)
if (feconf.ENABLE_MAINTENANCE_MODE
and not self.current_user_is_super_admin):
return
self.user_id = None
self.username = None
self.partially_logged_in = False
self.user_is_scheduled_for_deletion = False
if auth_claims:
auth_id = auth_claims.auth_id
user_settings = user_services.get_user_settings_by_auth_id(auth_id)
if user_settings is None:
# If the user settings are not yet created and the request leads
# to signup page create a new user settings. Otherwise logout
# the not-fully registered user.
email = auth_claims.email
if 'signup?' in self.request.uri:
user_settings = (user_services.create_new_user(
auth_id, email))
else:
logging.error(
'Cannot find user %s with email %s on page %s' %
(auth_id, email, self.request.uri))
auth_services.destroy_auth_session(self.response)
return
self.values['user_email'] = user_settings.email
self.user_id = user_settings.user_id
if user_settings.deleted:
self.user_is_scheduled_for_deletion = user_settings.deleted
elif (self.REDIRECT_UNFINISHED_SIGNUPS
and not user_services.has_fully_registered_account(
self.user_id)):
self.partially_logged_in = True
else:
self.username = user_settings.username
self.values['username'] = self.username
# In order to avoid too many datastore writes, we do not bother
# recording a log-in if the current time is sufficiently close
# to the last log-in time.
if (user_settings.last_logged_in is None
or not utils.are_datetimes_close(
datetime.datetime.utcnow(),
user_settings.last_logged_in)):
user_services.record_user_logged_in(self.user_id)
self.role = (feconf.ROLE_ID_GUEST
if self.user_id is None else user_settings.role)
self.user = user_services.get_user_actions_info(self.user_id)
self.values['is_moderator'] = (user_services.is_at_least_moderator(
self.user_id))
self.values['is_admin'] = user_services.is_admin(self.user_id)
self.values['is_topic_manager'] = (user_services.is_topic_manager(
self.user_id))
self.values['is_super_admin'] = self.current_user_is_super_admin
def test_set_and_get_user_email_preferences_for_exploration(self):
user_id = 'someUser'
exploration_id = 'someExploration'
username = '******'
user_email = '*****@*****.**'
user_services.create_new_user(user_id, user_email)
user_services.set_username(user_id, username)
# When ExplorationUserDataModel is yet to be created, the value
# of mute_feedback_notifications and mute_suggestion_notifications
# should match the default values.
exploration_user_model = (
user_services.user_models.ExplorationUserDataModel.get(
user_id, exploration_id))
self.assertIsNone(exploration_user_model)
email_preferences = user_services.get_email_preferences_for_exploration(
user_id, exploration_id)
self.assertEquals(
email_preferences.mute_feedback_notifications,
feconf.DEFAULT_FEEDBACK_NOTIFICATIONS_MUTED_PREFERENCE)
self.assertEquals(
email_preferences.mute_suggestion_notifications,
feconf.DEFAULT_SUGGESTION_NOTIFICATIONS_MUTED_PREFERENCE)
# This initializes a ExplorationUserDataModel instance with
# the default mute values.
user_services.set_email_preferences_for_exploration(
user_id,
exploration_id,
mute_feedback_notifications=(
feconf.DEFAULT_FEEDBACK_NOTIFICATIONS_MUTED_PREFERENCE),
mute_suggestion_notifications=(
feconf.DEFAULT_SUGGESTION_NOTIFICATIONS_MUTED_PREFERENCE))
email_preferences = user_services.get_email_preferences_for_exploration(
user_id, exploration_id)
self.assertEquals(
email_preferences.mute_feedback_notifications,
feconf.DEFAULT_FEEDBACK_NOTIFICATIONS_MUTED_PREFERENCE)
self.assertEquals(
email_preferences.mute_suggestion_notifications,
feconf.DEFAULT_SUGGESTION_NOTIFICATIONS_MUTED_PREFERENCE)
# This sets only mute_suggestion_notifications property to True.
# mute_feedback_notifications should remain same as before.
user_services.set_email_preferences_for_exploration(
user_id, exploration_id, mute_suggestion_notifications=True)
email_preferences = user_services.get_email_preferences_for_exploration(
user_id, exploration_id)
self.assertEquals(
email_preferences.mute_feedback_notifications,
feconf.DEFAULT_FEEDBACK_NOTIFICATIONS_MUTED_PREFERENCE)
self.assertTrue(email_preferences.mute_suggestion_notifications)
# This sets only mute_feedback_notifications property to True.
# mute_suggestion_notifications should remain same as before.
user_services.set_email_preferences_for_exploration(
user_id, exploration_id, mute_feedback_notifications=True)
email_preferences = user_services.get_email_preferences_for_exploration(
user_id, exploration_id)
self.assertTrue(email_preferences.mute_feedback_notifications)
self.assertTrue(email_preferences.mute_suggestion_notifications)
def setUp(self):
super(FeedbackMessageDomainUnitTests, self).setUp()
self.owner_id = self.get_user_id_from_email(self.OWNER_EMAIL)
user_services.create_new_user(self.owner_id, self.OWNER_EMAIL)
self.signup(self.OWNER_EMAIL, self.OWNER_USERNAME)
def test_is_username_taken_true(self):
user_id = 'someUser'
username = '******'
user_services.create_new_user(user_id, '*****@*****.**')
user_services.set_username(user_id, username)
self.assertTrue(user_services.is_username_taken(username))
def __init__(self, request, response): # pylint: disable=super-init-not-called
# Set self.request, self.response and self.app.
self.initialize(request, response)
self.start_time = datetime.datetime.utcnow()
# Initializes the return dict for the handlers.
self.values = {}
if self.request.get('payload'):
self.payload = json.loads(self.request.get('payload'))
else:
self.payload = None
self.iframed = False
self.is_super_admin = user_services.is_current_user_super_admin()
if feconf.ENABLE_MAINTENANCE_MODE and not self.is_super_admin:
return
self.gae_id = user_services.get_current_gae_id()
self.user_id = None
self.username = None
self.partially_logged_in = False
self.user_is_scheduled_for_deletion = False
# TODO(#11462): This part should be moved to the service layer when we
# migrate to Firebase.
if self.gae_id:
user_settings = user_services.get_user_settings_by_gae_id(
self.gae_id, strict=False)
if user_settings is None:
# If the user settings are not yet created and the request leads
# to signup page create a new user settings. Otherwise logout
# the not-fully registered user.
email = user_services.get_current_user_email()
if 'signup?' in self.request.uri:
user_settings = user_services.create_new_user(
self.gae_id, email)
else:
logging.error(
'Cannot find user %s with email %s on page %s' %
(self.gae_id, email, self.request.uri))
_clear_login_cookies(self.response.headers)
return
self.values['user_email'] = user_settings.email
self.user_id = user_settings.user_id
if user_settings.deleted:
self.user_is_scheduled_for_deletion = user_settings.deleted
elif (self.REDIRECT_UNFINISHED_SIGNUPS
and not user_services.has_fully_registered_account(
user_settings.user_id)):
self.partially_logged_in = True
else:
self.username = user_settings.username
self.values['username'] = self.username
# In order to avoid too many datastore writes, we do not bother
# recording a log-in if the current time is sufficiently close
# to the last log-in time.
if (user_settings.last_logged_in is None
or not utils.are_datetimes_close(
datetime.datetime.utcnow(),
user_settings.last_logged_in)):
user_services.record_user_logged_in(self.user_id)
self.role = (feconf.ROLE_ID_GUEST
if self.user_id is None else user_settings.role)
self.user = user_services.UserActionsInfo(self.user_id)
self.values['is_moderator'] = user_services.is_at_least_moderator(
self.user_id)
self.values['is_admin'] = user_services.is_admin(self.user_id)
self.values['is_topic_manager'] = (user_services.is_topic_manager(
self.user_id))
self.values['is_super_admin'] = self.is_super_admin
def __init__(self, request, response): # pylint: disable=super-init-not-called
# Set self.request, self.response and self.app.
self.initialize(request, response)
self.start_time = datetime.datetime.utcnow()
# Initializes the return dict for the handlers.
self.values = {}
# TODO(#13155): Remove the if-else part once all the handlers have had
# schema validation implemented.
if self.request.get('payload'):
self.payload = json.loads(self.request.get('payload'))
else:
self.payload = None
self.iframed = False
self.user_id = None
self.username = None
self.email = None
self.partially_logged_in = False
self.user_is_scheduled_for_deletion = False
self.current_user_is_super_admin = False
self.normalized_request = None
self.normalized_payload = None
try:
auth_claims = auth_services.get_auth_claims_from_request(request)
except auth_domain.StaleAuthSessionError:
auth_services.destroy_auth_session(self.response)
self.redirect(user_services.create_login_url(self.request.uri))
return
except auth_domain.InvalidAuthSessionError:
logging.exception('User session is invalid!')
auth_services.destroy_auth_session(self.response)
self.redirect(user_services.create_login_url(self.request.uri))
return
else:
self.current_user_is_super_admin = (
auth_claims is not None and auth_claims.role_is_super_admin)
if auth_claims:
auth_id = auth_claims.auth_id
user_settings = user_services.get_user_settings_by_auth_id(auth_id)
if user_settings is None:
# If the user settings are not yet created and the request leads
# to signup page create a new user settings. Otherwise logout
# the not-fully registered user.
email = auth_claims.email
if 'signup?' in self.request.uri:
user_settings = (
user_services.create_new_user(auth_id, email))
else:
logging.exception(
'Cannot find user %s with email %s on page %s' % (
auth_id, email, self.request.uri))
auth_services.destroy_auth_session(self.response)
return
self.email = user_settings.email
self.values['user_email'] = user_settings.email
self.user_id = user_settings.user_id
if user_settings.deleted:
self.user_is_scheduled_for_deletion = user_settings.deleted
elif (self.REDIRECT_UNFINISHED_SIGNUPS and
not user_services.has_fully_registered_account(self.user_id)):
self.partially_logged_in = True
else:
self.username = user_settings.username
self.values['username'] = self.username
# In order to avoid too many datastore writes, we do not bother
# recording a log-in if the current time is sufficiently close
# to the last log-in time.
if (user_settings.last_logged_in is None or
not utils.are_datetimes_close(
datetime.datetime.utcnow(),
user_settings.last_logged_in)):
user_services.record_user_logged_in(self.user_id)
self.roles = (
[feconf.ROLE_ID_GUEST]
if self.user_id is None else user_settings.roles)
self.user = user_services.get_user_actions_info(self.user_id)
if not self._is_requested_path_currently_accessible_to_user():
auth_services.destroy_auth_session(self.response)
return
self.values['is_super_admin'] = self.current_user_is_super_admin
def setUp(self):
super(ExplorationRetrievalTests, self).setUp()
self.owner_id = self.get_user_id_from_email(self.OWNER_EMAIL)
user_services.create_new_user(self.owner_id, self.OWNER_EMAIL)
self.signup(self.OWNER_EMAIL, self.OWNER_USERNAME)
