def log_in_session_token_create( self, user ): # generate authentication token and add it to the db and the session token = security.generate_random_string( entropy = 128 ) authtoken = EnkiModelTokenAuth( token = token, user_id = user.key.id() ) authtoken.put() self.session[ 'auth_token' ] = token self.session[ 'user_id' ] = user.key.id() self.just_logged_in = True
def log_in_session_token_create(self, user): # generate authentication token and add it to the db and the session token = security.generate_random_string(entropy=128) authtoken = EnkiModelTokenAuth(token=token, user_id=user.key.id()) authtoken.put() self.session['auth_token'] = token self.session['user_id'] = user.key.id() self.just_logged_in = True
def delete_account(self, delete_posts=False, token=''): token_to_save = 'accountdelete' if not token: # there is no token if the user has no email address: they are deleted immediately. They must be logged in. user_to_delete = self.enki_user else: # a user has followed a accountdelete token link. The user account associated with the token will be deleted tokenEntity = EnkiModelTokenVerify.get_by_token(token) user_to_delete = EnkiModelUser.get_by_id(tokenEntity.user_id) # delete all user related tokens except any verify token related to account deletion that's not yet been used if tokenEntity.type == token_to_save: token_to_save = 'accountandpostsdelete' verify_tokens_to_delete = EnkiModelTokenVerify.fetch_keys_by_user_id_except_type( user_to_delete.key.id(), token_to_save) if verify_tokens_to_delete: ndb.delete_multi(verify_tokens_to_delete) email_rollback_tokens_to_delete = EnkiModelTokenEmailRollback.fetch_keys_by_user_id( user_to_delete.key.id()) if email_rollback_tokens_to_delete: ndb.delete_multi(email_rollback_tokens_to_delete) # Delete the user account and log them out. if not HandlerBase.account_is_active(user_to_delete.key.id()): # delete user if the account is inactive display_names = EnkiModelDisplayName.fetch_keys_by_user_id( user_to_delete.key.id()) if display_names: ndb.delete_multi(display_names) user_to_delete.key.delete() else: # anonymise the user if user_to_delete.email: # delete email subscriptions EnkiModelEmailSubscriptions.remove_by_email( user_to_delete.email) user_to_delete.email = None if user_to_delete.password: user_to_delete.password = None if user_to_delete.auth_ids_provider: user_to_delete.auth_ids_provider = [] user_to_delete.put() # keep all historical display_names. Add a new current display_name '[deleted]' (unless it's already been deleted) display_name = EnkiModelDisplayName.get_by_user_id_current( user_to_delete.key.id()) if display_name: if display_name.prefix != EnkiModelDisplayName.DELETED_PREFIX or display_name.suffix != EnkiModelDisplayName.DELETED_SUFFIX: EnkiModelDisplayName.set_display_name( user_to_delete.key.id(), EnkiModelDisplayName.DELETED_PREFIX, EnkiModelDisplayName.DELETED_SUFFIX) # delete user's sent and received messages EnkiModelMessage.delete_user_messages(user_to_delete.key.id()) # delete user's posts if required if delete_posts: EnkiModelPost.delete_user_posts(user_to_delete.key.id()) # log the deleted user out if self.enki_user == user_to_delete.key.id(): self.log_out() EnkiModelTokenAuth.revoke_user_authentications(user_to_delete.key.id())
def exist_AuthToken(user_id, token): count = EnkiModelTokenAuth.query( ndb.AND(EnkiModelTokenAuth.user_id == user_id, EnkiModelTokenAuth.token == token) ).count(1) if count: return True else: return False
def get_AuthToken(user_id, token): entity = EnkiModelTokenAuth.query( ndb.AND(EnkiModelTokenAuth.user_id == user_id, EnkiModelTokenAuth.token == token) ).get() if entity: return entity else: return None
def log_out(self): # log out the currently logged in user self._just_checked_logged_in = False self._am_logged_in = False token = self.session.get('auth_token') token_key = EnkiModelTokenAuth.fetch_keys_by_user_id_token( self.user_id, token) if token_key: # delete the token from the db ndb.delete_multi(token_key) #delete the session self.session.clear()
def is_logged_in(self): # returns true if a session exists and corresponds to a logged in user (i.e. a user with a valid auth token) # get session info if not self._just_checked_logged_in: self._am_logged_in = False self._just_checked_logged_in = True token = self.session.get('auth_token') if token: token_auth = EnkiModelTokenAuth.get_by_user_id_token( self.user_id, token, retry=3) if token_auth: self._am_logged_in = True self._stay_logged_in = token_auth.stay_logged_in token_auth.put_async() # refresh time_updated return self._am_logged_in
def cleanup_item(self): number = random.randint(1, 1000) likelihood = 10 # occurs with a probability of 1% if number < likelihood: ndb.delete_multi_async(self.fetch_keys_old_sessions(3)) ndb.delete_multi_async(EnkiModelBackoffTimer.fetch_keys_old(3)) ndb.delete_multi_async(EnkiModelTokenAuth.fetch_keys_expired()) ndb.delete_multi_async( EnkiModelRestAPIConnectToken.fetch_expired()) ndb.delete_multi_async(EnkiModelRestAPIDataStore.fetch_expired()) ndb.delete_multi_async( EnkiModelTokenVerify.fetch_keys_old_tokens_by_types( 0.007, [ 'loginaddconfirm_1', 'loginaddconfirm_2', 'loginaddconfirm_3' ])) EnkiModelRestAPIDataStore.refresh_non_expiring() ndb.delete_multi_async( EnkiModelTokenVerify.fetch_keys_old_tokens_by_types( 1, ['emailsubscriptionconfirm'])) ndb.delete_multi_async(EnkiModelBackoffTimer.fetch_keys_old(1))
def fetch_keys_AuthToken(user_id): keys = EnkiModelTokenAuth.query(EnkiModelTokenAuth.user_id == user_id).fetch(keys_only=True) if keys: return keys else: return None
def fetch_keys_AuthToken( user_id ): keys = EnkiModelTokenAuth.query( EnkiModelTokenAuth.user_id == user_id ).fetch( keys_only = True ) return keys
def fetch_AuthTokens( user_id ): list = EnkiModelTokenAuth.query( EnkiModelTokenAuth.user_id == user_id ).order( -EnkiModelTokenAuth.time_created ).fetch() return list
def exist_AuthToken( user_id, token ): count = EnkiModelTokenAuth.query( ndb.AND( EnkiModelTokenAuth.user_id == user_id, EnkiModelTokenAuth.token == token )).count( 1 ) return count > 0
def fetch_key_AuthToken_by_user_id_token( user_id, token ): entity = EnkiModelTokenAuth.query( ndb.AND( EnkiModelTokenAuth.user_id == user_id, EnkiModelTokenAuth.token == token )).fetch( keys_only = True ) return entity
def fetch_old_auth_tokens( self, days_old ): list = EnkiModelTokenAuth.query( EnkiModelTokenAuth.time_created <= ( datetime.datetime.now() - datetime.timedelta( days = days_old ))).fetch( keys_only = True) return list
def fetch_old_auth_tokens(self, days_old): list = EnkiModelTokenAuth.query(EnkiModelTokenAuth.time_created <= ( datetime.datetime.now() - datetime.timedelta(days=days_old))).fetch(keys_only=True) return list