def get_latest_spl_audio() -> Optional[Dict]:
db = get_db_read_replica()
with db.scoped_session() as session:
token_tx = session.query(SPLTokenTransaction).first()
if token_tx:
return helpers.model_to_dictionary(token_tx)
return None
def _get_db_block_state(latest_blocknum, latest_blockhash):
db = get_db_read_replica()
with db.scoped_session() as session:
# Fetch latest block from DB
db_block_query = session.query(Block).filter(
Block.is_current == True).all()
assert len(
db_block_query) == 1, "Expected SINGLE row marked as current"
health_results = {
"web": {
"blocknumber": latest_blocknum,
"blockhash": latest_blockhash,
},
"db": helpers.model_to_dictionary(db_block_query[0]),
"git": os.getenv("GIT_SHA"),
}
block_difference = abs(health_results["web"]["blocknumber"] -
health_results["db"]["number"])
health_results["block_difference"] = block_difference
health_results[
"maximum_healthy_block_difference"] = default_healthy_block_diff
health_results.update(disc_prov_version)
return health_results
def _get_db_block_state():
db = db_session.get_db_read_replica()
with db.scoped_session() as session:
# Fetch latest block from DB
db_block_query = session.query(Block).filter(
Block.is_current == True).all()
assert len(db_block_query) == 1, "Expected SINGLE row marked as current"
return helpers.model_to_dictionary(db_block_query[0])
def get_latest_sol_user_bank() -> Optional[Dict]:
db = get_db_read_replica()
with db.scoped_session() as session:
user_bank_tx = (session.query(UserBankTransaction).order_by(
desc(UserBankTransaction.slot)).first())
if user_bank_tx:
return helpers.model_to_dictionary(user_bank_tx)
return None
def get_latest_sol_rewards_manager() -> Optional[Dict]:
db = get_db_read_replica()
with db.scoped_session() as session:
rewards_manager_tx = (
session.query(RewardManagerTransaction)
.order_by(desc(RewardManagerTransaction.slot))
.first()
)
if rewards_manager_tx:
return helpers.model_to_dictionary(rewards_manager_tx)
return None
def get_sol_play(sol_tx_signature):
db = get_db_read_replica()
sol_play = None
with db.scoped_session() as session:
base_query = (session.query(Play).filter(
Play.signature == sol_tx_signature))
query_results = base_query.first()
if query_results:
sol_play = helpers.model_to_dictionary(query_results)
return sol_play
def get_sol_play(sol_tx_signature):
if not sol_tx_signature:
raise exceptions.ArgumentError("Missing tx signature")
db = get_db_read_replica()
sol_play = None
with db.scoped_session() as session:
base_query = (session.query(Play).filter(
Play.signature == sol_tx_signature))
query_results = base_query.first()
if query_results:
sol_play = helpers.model_to_dictionary(query_results)
return sol_play
def get_block_confirmation(blockhash, blocknumber):
db = db_session.get_db_read_replica()
with db.scoped_session() as session:
blockhash_query = (
session.query(Block).filter(Block.blockhash == blockhash).all()
)
latest_block_query = session.query(Block).filter(Block.is_current == True).all()
if len(latest_block_query) != 1:
raise Exception("Expected SINGLE row marked as current")
latest_block_record = helpers.model_to_dictionary(latest_block_query[0])
latest_block_number = latest_block_record["number"] or 0
return {
"block_found": len(blockhash_query) > 0,
"block_passed": latest_block_number >= blocknumber,
}
def get_users_account(args):
db = get_db_read_replica()
with db.scoped_session() as session:
# Create initial query
base_query = session.query(User)
# Don't return the user if they have no wallet or handle (user creation did not finish properly on chain)
base_query = base_query.filter(
User.is_current == True, User.wallet != None, User.handle != None)
if "wallet" not in args:
raise exceptions.ArgumentError("Missing wallet param")
wallet = args.get("wallet")
wallet = wallet.lower()
if len(wallet) == 42:
base_query = base_query.filter_by(wallet=wallet)
base_query = base_query.order_by(asc(User.created_at))
else:
raise exceptions.ArgumentError("Invalid wallet length")
# If user cannot be found, exit early and return empty response
user = base_query.first()
if not user:
return None
user = helpers.model_to_dictionary(user)
user_id = user['user_id']
# bundle peripheral info into user results
users = populate_user_metadata(
session, [user_id], [user], user_id, True)
user = users[0]
# Get saved playlists / albums ids
saved_query = session.query(Save.save_item_id).filter(
Save.user_id == user_id,
Save.is_current == True,
Save.is_delete == False,
or_(Save.save_type == SaveType.playlist,
Save.save_type == SaveType.album)
)
saved_query_results = saved_query.all()
save_collection_ids = [item[0] for item in saved_query_results]
# Get Playlist/Albums saved or owned by the user
playlist_query = session.query(Playlist).filter(
or_(
and_(Playlist.is_current == True, Playlist.is_delete ==
False, Playlist.playlist_owner_id == user_id),
and_(Playlist.is_current == True, Playlist.is_delete ==
False, Playlist.playlist_id.in_(save_collection_ids))
)
).order_by(desc(Playlist.created_at))
playlists = playlist_query.all()
playlists = helpers.query_result_to_list(playlists)
playlist_owner_ids = list(
set([playlist['playlist_owner_id'] for playlist in playlists]))
# Get Users for the Playlist/Albums
user_query = session.query(User).filter(
and_(User.is_current == True, User.user_id.in_(playlist_owner_ids))
)
users = user_query.all()
users = helpers.query_result_to_list(users)
user_map = {}
stripped_playlists = []
# Map the users to the playlists/albums
for playlist_owner in users:
user_map[playlist_owner['user_id']] = playlist_owner
for playlist in playlists:
playlist_owner = user_map[playlist['playlist_owner_id']]
stripped_playlists.append({
'id': playlist['playlist_id'],
'name': playlist['playlist_name'],
'is_album': playlist['is_album'],
'user': {'id': playlist_owner['user_id'], 'handle': playlist_owner['handle']}
})
user['playlists'] = stripped_playlists
return user
def get_remixable_tracks(args):
"""Gets a list of remixable tracks"""
db = get_db_read_replica()
limit = args.get("limit", 25)
current_user_id = args.get("current_user_id", None)
StemTrack = aliased(Track)
with db.scoped_session() as session:
# Subquery to get current tracks that have stems
remixable_tracks_subquery = (session.query(Track).join(
Stem, Stem.parent_track_id == Track.track_id).join(
StemTrack, Stem.child_track_id == StemTrack.track_id).filter(
Track.is_current == True,
Track.is_unlisted == False,
Track.is_delete == False,
StemTrack.is_current == True,
StemTrack.is_unlisted == False,
StemTrack.is_delete == False,
).distinct(Track.track_id).subquery())
track_alias = aliased(Track, remixable_tracks_subquery)
count_subquery = session.query(
AggregateTrack.track_id.label("id"),
(AggregateTrack.repost_count +
AggregateTrack.save_count).label("count"),
).subquery()
query = (session.query(
track_alias,
count_subquery.c["count"],
decayed_score(count_subquery.c["count"],
track_alias.created_at).label("score"),
).join(
count_subquery,
count_subquery.c["id"] == track_alias.track_id,
).order_by(desc("score"), desc(track_alias.track_id)).limit(limit))
results = query.all()
tracks = []
for result in results:
track = result[0]
score = result[-1]
track = helpers.model_to_dictionary(track)
track["score"] = score
tracks.append(track)
track_ids = list(map(lambda track: track["track_id"], tracks))
# Get user specific data for tracks
tracks = populate_track_metadata(session, track_ids, tracks,
current_user_id)
if args.get("with_users", False):
add_users_to_tracks(session, tracks, current_user_id)
else:
# Remove the user from the tracks
tracks = [{key: val
for key, val in dict.items() if key != "user"}
for dict in tracks]
return tracks
def test_handle_event(app):
setup_challenges(app)
with app.app_context():
db = get_db()
populate_mock_db_blocks(db, 99, 110)
with db.scoped_session() as session:
my_challenge = ChallengeManager("test_challenge_1", TestUpdater())
# First try an event with a insufficient block_number
# to ensure that nothing happens
my_challenge.process(
session,
"test_event",
[
{
"user_id": 1,
"block_number": 99,
"extra": {}
},
],
)
session.flush()
actual = (session.query(UserChallenge).filter(
UserChallenge.challenge_id == "test_challenge_1",
UserChallenge.user_id == 1,
).first())
expected = {
"challenge_id": "test_challenge_1",
"user_id": 1,
"specifier": "1",
"is_complete": False,
"current_step_count": 1,
"completed_blocknumber": None,
}
assert model_to_dictionary(actual) == expected
# Now process events and make sure things change as expected
my_challenge.process(
session,
"test_event",
[
{
"user_id": 1,
"block_number": 100,
"extra": {}
},
{
"user_id": 2,
"block_number": 100,
"extra": {}
},
{
"user_id": 3,
"block_number": 100,
"extra": {}
},
# Attempt to add id 6 twice to
# ensure that it doesn't cause a collision
{
"user_id": 6,
"block_number": 100,
"extra": {}
},
{
"user_id": 6,
"block_number": 100,
"extra": {}
},
],
)
session.flush()
updated_complete = (session.query(UserChallenge).filter(
UserChallenge.challenge_id == "test_challenge_1").all())
res_dicts = list(map(model_to_dictionary, updated_complete))
expected = [
# Should have incremented step count + 1
{
"challenge_id": "test_challenge_1",
"user_id": 1,
"specifier": "1",
"is_complete": False,
"current_step_count": 2,
"completed_blocknumber": None,
},
# Should be unchanged b/c it was already complete
{
"challenge_id": "test_challenge_1",
"user_id": 2,
"specifier": "2",
"is_complete": True,
"current_step_count": 3,
"completed_blocknumber": 100,
},
# Should be newly complete
{
"challenge_id": "test_challenge_1",
"user_id": 3,
"specifier": "3",
"is_complete": True,
"current_step_count": 3,
"completed_blocknumber": 100,
},
# Should be untouched bc user 5 wasn't included
{
"challenge_id": "test_challenge_1",
"user_id": 5,
"specifier": "5",
"is_complete": False,
"current_step_count": 2,
"completed_blocknumber": None,
},
# Should have created a brand new user 6
{
"challenge_id": "test_challenge_1",
"user_id": 6,
"specifier": "6",
"is_complete": False,
"current_step_count": 1,
"completed_blocknumber": None,
},
]
assert expected == res_dicts