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)