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
