def update_token(user_id, access_token, refresh_token, expires_at): """ Update token for user with specified LB user ID. Args: user_id (int): the ListenBrainz row ID of the user access_token (str): the new access token, refresh_token (str): the new token used to refresh access tokens, expires_at (int): the unix timestamp at which the access token expires Returns: the new token in dict form """ token_expires = utils.unix_timestamp_to_datetime(expires_at) with db.engine.connect() as connection: connection.execute( sqlalchemy.text(""" UPDATE spotify_auth SET user_token = :user_token , refresh_token = :refresh_token , token_expires = :token_expires WHERE user_id = :user_id """), { "user_token": access_token, "refresh_token": refresh_token, "token_expires": token_expires, "user_id": user_id, })
def create_spotify(user_id, user_token, refresh_token, token_expires_ts, record_listens, permission): """ Add a row to the spotify table for specified user with corresponding Spotify tokens and information. Args: user_id (int): the ListenBrainz row ID of the user user_token (str): the Spotify access token used to access the user's Spotify listens. refresh_token (str): the token used to refresh Spotify access tokens once they expire token_expires_ts (int): the unix timestamp at which the user_token will expire record_listens (bool): True if user wishes to import listens from Spotify, False otherwise permission (str): the scope of the permissions granted to us by the user as a space seperated string """ token_expires = utils.unix_timestamp_to_datetime(token_expires_ts) with db.engine.connect() as connection: connection.execute( sqlalchemy.text(""" INSERT INTO spotify_auth (user_id, user_token, refresh_token, token_expires, record_listens, permission) VALUES (:user_id, :user_token, :refresh_token, :token_expires, :record_listens, :permission) """), { "user_id": user_id, "user_token": user_token, "refresh_token": refresh_token, "token_expires": token_expires, "record_listens": record_listens, "permission": permission, })
def update_token(user_id: int, service: ExternalServiceType, access_token: str, refresh_token: str, expires_at: int): """ Update the token for user with specified LB user ID and external service. Args: user_id: the ListenBrainz row ID of the user service: the service for which the token should be updated access_token: the new access token refresh_token: the new token used to refresh access tokens expires_at: the unix timestamp at which the access token expires """ token_expires = utils.unix_timestamp_to_datetime(expires_at) with db.engine.connect() as connection: connection.execute( sqlalchemy.text(""" UPDATE external_service_oauth SET access_token = :access_token , refresh_token = :refresh_token , token_expires = :token_expires , last_updated = now() WHERE user_id = :user_id AND service = :service """), { "access_token": access_token, "refresh_token": refresh_token, "token_expires": token_expires, "user_id": user_id, "service": service.value })
def update_token(user_id, access_token, refresh_token, expires_at): """ Update token for user with specified LB user ID. Args: user_id (int): the ListenBrainz row ID of the user access_token (str): the new access token, refresh_token (str): the new token used to refresh access tokens, expires_at (int): the unix timestamp at which the access token expires Returns: the new token in dict form """ token_expires = utils.unix_timestamp_to_datetime(expires_at) with db.engine.connect() as connection: connection.execute(sqlalchemy.text(""" UPDATE spotify_auth SET user_token = :user_token , refresh_token = :refresh_token , token_expires = :token_expires WHERE user_id = :user_id """), { "user_token": access_token, "refresh_token": refresh_token, "token_expires": token_expires, "user_id": user_id })
def save_token(user_id: int, service: ExternalServiceType, access_token: str, refresh_token: str, token_expires_ts: int, record_listens: bool, scopes: List[str]): """ Add a row to the external_service_oauth table for specified user with corresponding tokens and information. Args: user_id: the ListenBrainz row ID of the user service: the service for which the token can be used access_token: the access token used to access the user's listens refresh_token: the token used to refresh access tokens once they expire token_expires_ts: the unix timestamp at which the user_token will expire record_listens: True if user wishes to import listens, False otherwise scopes: the oauth scopes """ token_expires = utils.unix_timestamp_to_datetime(token_expires_ts) with db.engine.connect() as connection: result = connection.execute( sqlalchemy.text(""" INSERT INTO external_service_oauth (user_id, service, access_token, refresh_token, token_expires, scopes) VALUES (:user_id, :service, :access_token, :refresh_token, :token_expires, :scopes) ON CONFLICT (user_id, service) DO UPDATE SET user_id = EXCLUDED.user_id, service = EXCLUDED.service, access_token = EXCLUDED.access_token, refresh_token = EXCLUDED.refresh_token, token_expires = EXCLUDED.token_expires, scopes = EXCLUDED.scopes RETURNING id """), { "user_id": user_id, "service": service.value, "access_token": access_token, "refresh_token": refresh_token, "token_expires": token_expires, "scopes": scopes, }) if record_listens: external_service_oauth_id = result.fetchone()['id'] connection.execute( sqlalchemy.text(""" INSERT INTO listens_importer (external_service_oauth_id, user_id, service) VALUES (:external_service_oauth_id, :user_id, :service) ON CONFLICT (user_id, service) DO UPDATE SET external_service_oauth_id = EXCLUDED.external_service_oauth_id, user_id = EXCLUDED.user_id, service = EXCLUDED.service """), { "external_service_oauth_id": external_service_oauth_id, "user_id": user_id, "service": service.value })
def update_latest_listened_at(user_id, timestamp): """ Update the timestamp of the last listen imported for the user with specified LB user ID. Args: user_id (int): the ListenBrainz row ID of the user timestamp (int): the unix timestamp of the latest listen imported for the user """ with db.engine.connect() as connection: connection.execute(sqlalchemy.text(""" UPDATE spotify_auth SET latest_listened_at = :timestamp WHERE user_id = :user_id """), { 'user_id': user_id, 'timestamp': utils.unix_timestamp_to_datetime(timestamp), })
def update_latest_listened_at(user_id, timestamp): """ Update the timestamp of the last listen imported for the user with specified LB user ID. Args: user_id (int): the ListenBrainz row ID of the user timestamp (int): the unix timestamp of the latest listen imported for the user """ with db.engine.connect() as connection: connection.execute( sqlalchemy.text(""" UPDATE spotify_auth SET latest_listened_at = :timestamp WHERE user_id = :user_id """), { 'user_id': user_id, 'timestamp': utils.unix_timestamp_to_datetime(timestamp), })
def update_latest_listened_at(user_id: int, service: ExternalServiceType, timestamp: int): """ Update the timestamp of the last listen imported for the user with specified LB user ID. Args: user_id (int): the ListenBrainz row ID of the user service (data.model.ExternalServiceType): service to update latest listen timestamp for timestamp (int): the unix timestamp of the latest listen imported for the user """ with db.engine.connect() as connection: connection.execute(sqlalchemy.text(""" UPDATE listens_importer SET last_updated = now() , latest_listened_at = :timestamp WHERE user_id = :user_id AND service = :service """), { 'user_id': user_id, 'service': service.value, 'timestamp': utils.unix_timestamp_to_datetime(timestamp), })
def create_spotify(user_id, user_token, refresh_token, token_expires_ts): """ Add a row to the spotify table for specified user with corresponding Spotify tokens and information. Args: user_id (int): the ListenBrainz row ID of the user user_token (str): the Spotify access token used to access the user's Spotify listens. refresh_token (str): the token used to refresh Spotify access tokens once they expire token_expires_ts (int): the unix timestamp at which the user_token will expire """ token_expires = utils.unix_timestamp_to_datetime(token_expires_ts) with db.engine.connect() as connection: connection.execute(sqlalchemy.text(""" INSERT INTO spotify_auth (user_id, user_token, refresh_token, token_expires) VALUES (:user_id, :user_token, :refresh_token, :token_expires) """), { "user_id": user_id, "user_token": user_token, "refresh_token": refresh_token, "token_expires": token_expires, })
def update_latest_listened_at(user_id: int, service: ExternalServiceType, timestamp: Union[int, float]): """ Update the timestamp of the last listen imported for the user with specified LB user ID. Args: user_id (int): the ListenBrainz row ID of the user service (data.model.ExternalServiceType): service to update latest listen timestamp for timestamp (int): the unix timestamp of the latest listen imported for the user """ with db.engine.connect() as connection: connection.execute(sqlalchemy.text(""" INSERT INTO listens_importer (user_id, service, last_updated, latest_listened_at) VALUES (:user_id, :service, now(), :timestamp) ON CONFLICT (user_id, service) DO UPDATE SET last_updated = now() , latest_listened_at = :timestamp """), { 'user_id': user_id, 'service': service.value, 'timestamp': utils.unix_timestamp_to_datetime(timestamp), })
def create_spotify(user_id, user_token, refresh_token, token_expires_ts): """ Add a row to the spotify table for specified user with corresponding Spotify tokens and information. Args: user_id (int): the ListenBrainz row ID of the user user_token (str): the Spotify access token used to access the user's Spotify listens. refresh_token (str): the token used to refresh Spotify access tokens once they expire token_expires_ts (int): the unix timestamp at which the user_token will expire """ token_expires = utils.unix_timestamp_to_datetime(token_expires_ts) with db.engine.connect() as connection: connection.execute( sqlalchemy.text(""" INSERT INTO spotify_auth (user_id, user_token, refresh_token, token_expires) VALUES (:user_id, :user_token, :refresh_token, :token_expires) """), { "user_id": user_id, "user_token": user_token, "refresh_token": refresh_token, "token_expires": token_expires, })
def test_unix_timestamp_to_datetime(self): t = int(time.time()) x = utils.unix_timestamp_to_datetime(t) self.assertIsInstance(x, datetime) self.assertEqual(int(x.strftime('%s')), t)