def _create_follower(self, args):
if args['leader_oid'] == args['follower_oid']:
return self._404("User can't follow ownself.")
leader_user = models.User().get_by_oid(args['leader_oid'])
follower_user = models.User().get_by_oid(args['follower_oid'])
followerObj = models.Follower()
followerExists = followerObj.query.filter(
models.Follower.leader == leader_user,
models.Follower.follower == follower_user).all()
if not followerExists:
follower = models.Follower().create_follower(
args['leader_oid'], args['follower_oid'])
return self._success()
else:
return self._404("User is already a follower")
def _get_user(self, oid):
user = models.User().get_by_oid(oid)
if user is None:
return self._404("User doesn't exist.")
return self._success({
'oid': user.oid,
'name': user.name,
'email': user.email
})
def register():
form = Forms.RegisterForm(request.form, csrf_enabled=False)
users = DB_Models.User.query.filter_by(email=form.email.data).all()
if form.validate_on_submit():
new_user = DB_Models.User(email=form.email.data,
user_name=form.username.data,
password=form.password.data,
role_id=0)
database.session.add(new_user)
return redirect(url_for('login'))
return render_template('signup.html', form=form)
def seed():
'''
Assumes you have already have sleeportant database
db init, and upgrade the databases
method to create some initial users locally and insert to database
make sleep records for each user for a large date range ~100-200 days
:return:
'''
print("Seeding database with initial users")
user1 = models.User(name="Rick")
user2 = models.User(name="Talia")
user3 = models.User(name="Christina")
sleepStateList = ["GOOD", "OKAY", "BAD"]
db.session.add_all([user1, user2, user3])
db.session.flush()
db.session.commit()
print("Users created!")
print("Seeding database for users sleep records")
return
async def init_login(uid, nick, gender, city, photo, province, session_key):
session_key = init_secret_key(session_key)
flag, user = await models.User.get(uid=uid)
if not flag:
print('create')
data = dict(uid=uid,
nick=nick,
gender=gender,
city=city,
photo=photo,
province=province,
secret_key=session_key)
user = models.User(**data)
await user.save()
else:
print('update')
user['secret_key'] = session_key
user = models.User(**user)
await user.save()
return user.to_dict(detail=True)
def post(self):
args = request.form
user = models.User().get_by_oid(args['oid'])
if user is None:
return self._404("User doesn't exist.")
tweet = models.Tweet(user, args['content'])
try:
tweet.save()
except Exception as e:
return self._404('Encountered error while saving')
return self._success()
def user_add(self,*args):
"""
增加系统用户
:param args:
:return:
"""
name=self.fomatter.input_str_format("请输入系统用户名")
password=self.fomatter.input_str_format("请输入系统用户密码")
user_obj=models.User(username=name,password=password)
try:
self.session_add(user_obj)
except Exception as e:
print(e)
def _get_users(self):
users = models.User().query.all()[:100]
if not users:
return self._404("No users found.")
result = []
for user in users:
result.append({
'oid': user.oid,
'name': user.name,
'email': user.email
})
return self._success(result)
def _get_tweets_of_user(self, oid):
user = models.User().get_by_oid(oid)
tweets = []
if user.tweets is not None:
for t in user.tweets:
tweets.append({
'created_at': t.created_at,
'tweet': t.tweet,
'oid': t.oid,
'name': user.name,
'email': user.email
})
return self._success(list(reversed(tweets)))
def _authenticate_user(self, email, password):
user = models.User().get_by_email(email)
if user is None:
return self._404('User does\'t exist.')
if user.authenticate(password):
access_token, refresh_token = self._create_tokens(user.oid)
return self._success({
'access_token': access_token,
'refresh_token': refresh_token
})
else:
return self._404('Invalid credentials.')
def _create_user(self, args):
user = models.User(name=args['name'],
email=args['email'],
password=args['password'])
try:
user.save()
except Exception as e:
return self._404('User already exists')
return self._success({
'name': user.name,
'email': user.email,
'oid': user.oid
})
def _get_followers_of_user(self, oid):
user = models.User().get_by_oid(oid)
if user is None:
return self._404("User doesn't exist.")
followers = models.Follower().get_by_user(user)
result = []
for follower in followers:
result.append({
'name': follower.follower.name,
'email': follower.follower.email,
'oid': follower.follower.oid
})
return self._success(result)
def init_db(app):
"""Init the DB with some fake data."""
with app.app_context():
DB.create_all()
users = [
m.User(username=FAKER.word(),
password=FAKER.password(),
nick="".join(FAKER.words())) for number in range(10)
]
# We need at least one we can predict
users.append(m.User(username="******", password="******",
nick="foobar"))
db_items = [
*users, *[
m.Message(username=random.choice(users).username,
message_text=FAKER.catch_phrase())
for number in range(10000)
]
]
for item in db_items:
# pylint: disable=no-member
DB.session.merge(item)
DB.session.commit()
async def register(user_to_create: UserCreate, session: AsyncSession = Depends(Session)):
for i in count():
try:
user = models.User(**user_to_create.dict())
async with session.begin():
session.add(user)
break
except IntegrityError as e:
# try 10 times
if i > 9:
raise HTTPException(status.HTTP_409_CONFLICT, e)
async with session.begin():
session.add(models.Channel(owner_id=user.id, type=models.ChannelType.USER))
return schemas.UserExternal(**user.__dict__)
def register():
username = request.form["username"]
user = models.User.query.filter(models.User.username == username).first()
if user is not None:
logging.info("Trying to register existed user = {}".format(username))
return "Already exists", 409, {
"Access-Control-Allow-Credentials": "true"
}
else:
user = models.User(username=username,
password=request.form["password"],
first_name=request.form["firstName"],
last_name=request.form["lastName"])
db.session.add(user)
db.session.commit()
logging.info("New user registered = {}".format(username))
return "Created", 201, {"Access-Control-Allow-Credentials": "true"}
def populatedb():
if models.User.query.count() == 0:
print("Importing users...")
with open('resources/users.json') as f:
user_list = json.load(f)
for u in user_list:
pw_hash = bcrypt.generate_password_hash(
u['password']).decode('utf-8')
usr = models.User(u['email'], pw_hash, u['country'],
u['currency'])
db.session.add(usr)
db.session.commit()
if db.session.query(models.Product).count() == 0:
print("Importing products...")
with open('resources/products.json') as f:
product_list = json.load(f)
for p in product_list:
prod = models.Product(p['user'], p['description'], p['price'])
db.session.add(prod)
db.session.commit()
def _get_tweets_of_followers(self, oid):
user = models.User().get_by_oid(oid)
if user is None:
return self._404("User doesn't exist.")
followers = models.Follower().get_by_user(user)
tweets = []
for follower in followers:
for tweet in follower.follower.tweets:
tweets.append({
'created_at': tweet.created_at,
'tweet': tweet.tweet,
'oid': tweet.oid,
'follower': {
'name': follower.follower.name,
'email': follower.follower.email,
'oid': follower.follower.oid
}
})
return self._success(
list(reversed(sorted(tweets, key=lambda x: x['created_at']))))
def registration():
try:
name = request.form["name"]
email = request.form["email"]
password_hash = request.form["password"]
user_type_id = 1
created_at = datetime.datetime.now()
create_user = models.User(
name=name,
email=email,
password_hash=ph.hash(password_hash),
email_validated=False,
user_type_id=user_type_id,
created_at=created_at,
)
db_session.add(create_user)
db_session.flush()
except Exception as e:
print(e)
print("failed to create user")
return redirect(url_for("view.register"))
try:
db_session.commit()
res = verification_mail.send_mail(create_user.id,
create_user.name,
create_user.email,
email_type="new-user")
if not res:
print("invalid email or server failed to send verification mail")
return redirect(url_for("view.register"))
return redirect(url_for("view.user"))
except Exception as e:
print(e)
print("failed to store user in database")
db_session.rollback()
return redirect(url_for("view.register"))
def add_user():
if not request.is_json:
return jsonify({"msg": "Missing JSON in request"}), 400
firstname = request.json.get('firstname', None)
lastname = request.json.get('lastname', None)
email = request.json.get('email', None)
password = request.json.get('password', None)
hashPassword = bcrypt.generate_password_hash(str(password),
10).decode('utf-8')
# role = request.json['role']
role = 'user'
if email is None:
return 'Missing email', 400
if password is None:
return 'Missing password', 400
new_user = models.User(firstname, lastname, email, hashPassword, role)
models.db.session.add(new_user)
models.db.session.commit()
dump_data = models.user_schema.dump(new_user)
return dump_data
import src.models as models
from src.app import create_minimal_app
from src.database import db
app = create_minimal_app()
test_user = {
'username': '******',
'password': '******',
'first_name': 'Jim',
'last_name': 'Johnson'
}
with app.app_context():
db.drop_all()
db.create_all()
user = models.User(**test_user)
db.session.add(user)
db.session.commit()
def populate_mock_db(db, entities):
"""
Helper function to populate the mock DB with tracks, users, plays, and follows
Args:
db - sqlalchemy db session
entities - dict of keys tracks, users, plays of arrays of metadata
"""
with db.scoped_session() as session:
tracks = entities.get('tracks', [])
users = entities.get('users', [])
follows = entities.get('follows', [])
num_blocks = max(len(tracks), len(users), len(follows))
for i in range(num_blocks):
block = models.Block(
blockhash=hex(i),
number=i,
parenthash='0x01',
is_current=(i == 0),
)
session.add(block)
session.flush()
for i, track_meta in enumerate(tracks):
track = models.Track(
blockhash=hex(i),
blocknumber=i,
track_id=track_meta.get("track_id", i),
is_current=track_meta.get("is_current", True),
is_delete=track_meta.get("is_delete", False),
owner_id=track_meta.get("owner_id", 1),
route_id=track_meta.get("route_id", ''),
track_segments=track_meta.get("track_segments", []),
tags=track_meta.get("tags", None),
genre=track_meta.get("genre", ""),
updated_at=track_meta.get("updated_at", datetime.now()),
created_at=track_meta.get("created_at", datetime.now()),
release_date=track_meta.get("release_date", None),
is_unlisted=track_meta.get("is_unlisted", False))
session.add(track)
for i, user_meta in enumerate(users):
user = models.User(
blockhash=hex(i),
blocknumber=1,
user_id=user_meta.get('user_id', i),
is_current=True,
handle=user_meta.get('handle', i),
wallet=user_meta.get('wallet', i),
updated_at=user_meta.get("updated_at", datetime.now()),
created_at=user_meta.get("created_at", datetime.now()),
)
session.add(user)
for i, play_meta in enumerate(entities.get('plays', [])):
play = models.Play(id=play_meta.get("id", i),
play_item_id=play_meta.get("item_id"),
created_at=play_meta.get(
"created_at", datetime.now()))
session.add(play)
for i, follow_meta in enumerate(follows):
follow = models.Follow(
blockhash=hex(i),
blocknumber=follow_meta.get("blocknumber", i),
follower_user_id=follow_meta.get("follower_user_id", i + 1),
followee_user_id=follow_meta.get("followee_user_id", i),
is_current=follow_meta.get("is_current", True),
is_delete=follow_meta.get("is_delete", False),
created_at=follow_meta.get("created_at", datetime.now()))
session.add(follow)
def setUp(self):
self.user = models.User()
def create_user(db: Session, user: schemas.User):
db_user = models.User(email=user.email)
db.add(db_user)
db.commit()
db.refresh(db_user)
return db_user
def populate_mock_db(db, entities, block_offset=None):
"""
Helper function to populate the mock DB with tracks, users, plays, and follows
Args:
db - sqlalchemy db session
entities - dict of keys tracks, users, plays of arrays of metadata
"""
with db.scoped_session() as session:
# check if blocknumber already exists for longer running tests
if block_offset is None:
block_offset = get_latest_blocknumber(session)
if block_offset:
block_offset += 1
else:
block_offset = 0
tracks = entities.get("tracks", [])
playlists = entities.get("playlists", [])
users = entities.get("users", [])
follows = entities.get("follows", [])
reposts = entities.get("reposts", [])
saves = entities.get("saves", [])
track_routes = entities.get("track_routes", [])
remixes = entities.get("remixes", [])
stems = entities.get("stems", [])
challenges = entities.get("challenges", [])
user_challenges = entities.get("user_challenges", [])
plays = entities.get("plays", [])
aggregate_plays = entities.get("aggregate_plays", [])
aggregate_track = entities.get("aggregate_track", [])
aggregate_monthly_plays = entities.get("aggregate_monthly_plays", [])
aggregate_user = entities.get("aggregate_user", [])
indexing_checkpoints = entities.get("indexing_checkpoints", [])
user_listening_history = entities.get("user_listening_history", [])
hourly_play_counts = entities.get("hourly_play_counts", [])
user_bank_accounts = entities.get("user_bank_accounts", [])
associated_wallets = entities.get("associated_wallets", [])
num_blocks = max(len(tracks), len(users), len(follows), len(saves),
len(reposts))
for i in range(block_offset, block_offset + num_blocks):
max_block = (session.query(
models.Block).filter(models.Block.number == i).first())
session.query(models.Block).filter(
models.Block.is_current == True).update({"is_current": False})
if not max_block:
block = models.Block(
blockhash=hex(i),
number=i,
parenthash="0x01",
is_current=(i == block_offset + num_blocks - 1),
)
session.add(block)
session.flush()
for i, track_meta in enumerate(tracks):
track_id = track_meta.get("track_id", i)
# mark previous tracks as is_current = False
session.query(
models.Track).filter(models.Track.is_current == True).filter(
models.Track.track_id == track_id).update(
{"is_current": False})
track = models.Track(
blockhash=hex(i + block_offset),
blocknumber=i + block_offset,
txhash=track_meta.get("txhash", str(i + block_offset)),
track_id=track_id,
title=track_meta.get("title", f"track_{i}"),
is_current=track_meta.get("is_current", True),
is_delete=track_meta.get("is_delete", False),
owner_id=track_meta.get("owner_id", 1),
route_id=track_meta.get("route_id", ""),
track_segments=track_meta.get("track_segments", []),
tags=track_meta.get("tags", None),
genre=track_meta.get("genre", ""),
updated_at=track_meta.get("updated_at", datetime.now()),
created_at=track_meta.get("created_at", datetime.now()),
release_date=track_meta.get("release_date", None),
is_unlisted=track_meta.get("is_unlisted", False),
)
session.add(track)
for i, playlist_meta in enumerate(playlists):
playlist = models.Playlist(
blockhash=hex(i + block_offset),
blocknumber=i + block_offset,
txhash=playlist_meta.get("txhash", str(i + block_offset)),
playlist_id=playlist_meta.get("playlist_id", i),
is_current=playlist_meta.get("is_current", True),
is_delete=playlist_meta.get("is_delete", False),
playlist_owner_id=playlist_meta.get("playlist_owner_id", 1),
is_album=playlist_meta.get("is_album", False),
is_private=playlist_meta.get("is_private", False),
playlist_name=playlist_meta.get("playlist_name",
f"playlist_{i}"),
playlist_contents=playlist_meta.get("playlist_contents",
{"track_ids": []}),
playlist_image_multihash=playlist_meta.get(
"playlist_image_multihash", ""),
playlist_image_sizes_multihash=playlist_meta.get(
"playlist_image_sizes_multihash", ""),
description=playlist_meta.get("description",
f"description_{i}"),
upc=playlist_meta.get("upc", f"upc_{i}"),
updated_at=playlist_meta.get("updated_at", datetime.now()),
created_at=playlist_meta.get("created_at", datetime.now()),
)
session.add(playlist)
for i, user_meta in enumerate(users):
user = models.User(
blockhash=hex(i + block_offset),
blocknumber=i + block_offset,
txhash=user_meta.get("txhash", str(i + block_offset)),
user_id=user_meta.get("user_id", i),
is_current=True,
handle=user_meta.get("handle", str(i)),
handle_lc=user_meta.get("handle", str(i)).lower(),
wallet=user_meta.get("wallet", str(i)),
bio=user_meta.get("bio", str(i)),
profile_picture=user_meta.get("profile_picture"),
profile_picture_sizes=user_meta.get("profile_picture_sizes"),
cover_photo=user_meta.get("cover_photo"),
cover_photo_sizes=user_meta.get("cover_photo_sizes"),
updated_at=user_meta.get("updated_at", datetime.now()),
created_at=user_meta.get("created_at", datetime.now()),
)
user_bank = models.UserBankAccount(
signature=f"0x{i}",
ethereum_address=user_meta.get("wallet", str(i)),
bank_account=f"0x{i}",
created_at=datetime.now(),
)
session.add(user)
session.add(user_bank)
for i, follow_meta in enumerate(follows):
follow = models.Follow(
blockhash=hex(i + block_offset),
blocknumber=follow_meta.get("blocknumber", i + block_offset),
follower_user_id=follow_meta.get("follower_user_id", i + 1),
followee_user_id=follow_meta.get("followee_user_id", i),
is_current=follow_meta.get("is_current", True),
is_delete=follow_meta.get("is_delete", False),
created_at=follow_meta.get("created_at", datetime.now()),
)
session.add(follow)
for i, repost_meta in enumerate(reposts):
repost = models.Repost(
blockhash=hex(i + block_offset),
blocknumber=repost_meta.get("blocknumber", i + block_offset),
txhash=repost_meta.get("txhash", str(i + block_offset)),
user_id=repost_meta.get("user_id", i + 1),
repost_item_id=repost_meta.get("repost_item_id", i),
repost_type=repost_meta.get("repost_type", "track"),
is_current=repost_meta.get("is_current", True),
is_delete=repost_meta.get("is_delete", False),
created_at=repost_meta.get("created_at", datetime.now()),
)
session.add(repost)
for i, save_meta in enumerate(saves):
save = models.Save(
blockhash=hex(i + block_offset),
blocknumber=save_meta.get("blocknumber", i + block_offset),
txhash=save_meta.get("txhash", str(i + block_offset)),
user_id=save_meta.get("user_id", i + 1),
save_item_id=save_meta.get("save_item_id", i),
save_type=save_meta.get("save_type", "track"),
is_current=save_meta.get("is_current", True),
is_delete=save_meta.get("is_delete", False),
created_at=save_meta.get("created_at", datetime.now()),
)
session.add(save)
for i, play_meta in enumerate(plays):
play = models.Play(
id=play_meta.get("id", i + 1),
user_id=play_meta.get("user_id", i + 1),
source=play_meta.get("source", None),
play_item_id=play_meta.get("item_id", i + 1),
slot=play_meta.get("slot", i + 1),
signature=play_meta.get("signature", None),
created_at=play_meta.get("created_at", datetime.now()),
updated_at=play_meta.get("updated_at", datetime.now()),
)
session.add(play)
for i, aggregate_play_meta in enumerate(aggregate_plays):
aggregate_play = models.AggregatePlays(
play_item_id=aggregate_play_meta.get("play_item_id", i),
count=aggregate_play_meta.get("count", 0),
)
session.add(aggregate_play)
for i, aggregate_track_meta in enumerate(aggregate_track):
aggregate_track = models.AggregateTrack(
track_id=aggregate_track_meta.get("track_id", i),
repost_count=aggregate_track_meta.get("repost_count", 0),
save_count=aggregate_track_meta.get("save_count", 0),
)
session.add(aggregate_track)
for i, aggregate_monthly_play_meta in enumerate(
aggregate_monthly_plays):
aggregate_monthly_play = models.AggregateMonthlyPlays(
play_item_id=aggregate_monthly_play_meta.get(
"play_item_id", i),
timestamp=aggregate_monthly_play_meta.get("timestamp", i),
count=aggregate_monthly_play_meta.get("count", 0),
)
session.add(aggregate_monthly_play)
for i, aggregate_user_meta in enumerate(aggregate_user):
user = models.AggregateUser(
user_id=aggregate_user_meta.get("user_id", i),
track_count=aggregate_user_meta.get("track_count", 0),
playlist_count=aggregate_user_meta.get("playlist_count", 0),
album_count=aggregate_user_meta.get("album_count", 0),
follower_count=aggregate_user_meta.get("follower_count", 0),
following_count=aggregate_user_meta.get("following_count", 0),
repost_count=aggregate_user_meta.get("repost_count", 0),
track_save_count=aggregate_user_meta.get(
"track_save_count", 0),
)
session.add(user)
for i, user_listening_history_meta in enumerate(
user_listening_history):
user_listening_history = models.UserListeningHistory(
user_id=user_listening_history_meta.get("user_id", i + 1),
listening_history=user_listening_history_meta.get(
"listening_history", None),
)
session.add(user_listening_history)
for i, hourly_play_count_meta in enumerate(hourly_play_counts):
hourly_play_count = models.HourlyPlayCounts(
hourly_timestamp=hourly_play_count_meta.get(
"hourly_timestamp", datetime.now()),
play_count=hourly_play_count_meta.get("play_count", 0),
)
session.add(hourly_play_count)
if indexing_checkpoints:
session.execute("TRUNCATE TABLE indexing_checkpoints"
) # clear primary keys before adding
for i, indexing_checkpoint_meta in enumerate(indexing_checkpoints):
indexing_checkpoint = models.IndexingCheckpoints(
tablename=indexing_checkpoint_meta.get("tablename", None),
last_checkpoint=indexing_checkpoint_meta.get(
"last_checkpoint", 0),
)
session.add(indexing_checkpoint)
for i, route_meta in enumerate(track_routes):
route = models.TrackRoute(
slug=route_meta.get("slug", ""),
title_slug=route_meta.get("title_slug", ""),
blockhash=hex(i + block_offset),
blocknumber=route_meta.get("blocknumber", i + block_offset),
owner_id=route_meta.get("owner_id", i + 1),
track_id=route_meta.get("track_id", i + 1),
is_current=route_meta.get("is_current", True),
txhash=route_meta.get("txhash", str(i + 1)),
collision_id=route_meta.get("collision_id", 0),
)
session.add(route)
for i, remix_meta in enumerate(remixes):
remix = models.Remix(
parent_track_id=remix_meta.get("parent_track_id", i),
child_track_id=remix_meta.get("child_track_id", i + 1),
)
session.add(remix)
for i, stems_meta in enumerate(stems):
stem = models.Stem(
parent_track_id=stems_meta.get("parent_track_id", i),
child_track_id=stems_meta.get("child_track_id", i + 1),
)
session.add(stem)
for i, challenge_meta in enumerate(challenges):
challenge = models.Challenge(
id=challenge_meta.get("id", ""),
type=challenge_meta.get("type", ""),
amount=challenge_meta.get("amount", ""),
active=challenge_meta.get("active", True),
step_count=challenge_meta.get("step_count", None),
starting_block=challenge_meta.get("starting_block", None),
)
session.add(challenge)
for i, user_challenge_meta in enumerate(user_challenges):
user_challenge = models.UserChallenge(
challenge_id=user_challenge_meta.get("challenge_id", ""),
user_id=user_challenge_meta.get("user_id", 1),
specifier=user_challenge_meta.get("specifier", ""),
is_complete=user_challenge_meta.get("is_complete", False),
completed_blocknumber=user_challenge_meta.get(
"completed_blocknumber", 1 + block_offset),
current_step_count=user_challenge_meta.get(
"current_step_count", None),
)
session.add(user_challenge)
for i, user_bank_account in enumerate(user_bank_accounts):
bank = models.UserBankAccount(
signature=user_bank_account.get("signature", ""),
ethereum_address=user_bank_account.get("ethereum_address", ""),
bank_account=user_bank_account.get("bank_account", ""),
created_at=user_bank_account.get("created_at", datetime.now()),
)
session.add(bank)
for i, associated_wallet in enumerate(associated_wallets):
wallet = models.AssociatedWallet(
blockhash=associated_wallet.get("blockhash",
hex(i + block_offset)),
blocknumber=associated_wallet.get("blocknumber",
i + block_offset),
is_current=associated_wallet.get("is_current", True),
is_delete=associated_wallet.get("is_delete", False),
user_id=associated_wallet.get("user_id", 1),
wallet=associated_wallet.get("wallet", str(i)),
chain=associated_wallet.get("chain", WalletChain.sol),
)
session.add(wallet)
session.flush()
#!flask/bin/python
from migrate.versioning import api
from config import SQLALCHEMY_DATABASE_URI
from config import SQLALCHEMY_MIGRATE_REPO
from src import db, models
import os.path
db.create_all()
if not os.path.exists(SQLALCHEMY_MIGRATE_REPO):
api.create(SQLALCHEMY_MIGRATE_REPO, 'database repository')
api.version_control(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
else:
api.version_control(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO,
api.version(SQLALCHEMY_MIGRATE_REPO))
username = '******'
password = '******'
if models.User.query.filter_by(username=username).first() is not None:
abort(400) # existing user
user = models.User(username=username)
user.hash_password(password)
db.session.add(user)
db.session.commit()
def populate_mock_db(db, entities):
"""
Helper function to populate the mock DB with tracks, users, plays, and follows
Args:
db - sqlalchemy db session
entities - dict of keys tracks, users, plays of arrays of metadata
"""
with db.scoped_session() as session:
tracks = entities.get('tracks', [])
playlists = entities.get('playlists', [])
users = entities.get('users', [])
follows = entities.get('follows', [])
reposts = entities.get('reposts', [])
saves = entities.get('saves', [])
num_blocks = max(len(tracks), len(users), len(follows))
for i in range(num_blocks):
block = models.Block(
blockhash=hex(i),
number=i,
parenthash='0x01',
is_current=(i == 0),
)
session.add(block)
session.flush()
for i, track_meta in enumerate(tracks):
track = models.Track(
blockhash=hex(i),
blocknumber=i,
track_id=track_meta.get("track_id", i),
is_current=track_meta.get("is_current", True),
is_delete=track_meta.get("is_delete", False),
owner_id=track_meta.get("owner_id", 1),
route_id=track_meta.get("route_id", ''),
track_segments=track_meta.get("track_segments", []),
tags=track_meta.get("tags", None),
genre=track_meta.get("genre", ""),
updated_at=track_meta.get("updated_at", datetime.now()),
created_at=track_meta.get("created_at", datetime.now()),
release_date=track_meta.get("release_date", None),
is_unlisted=track_meta.get("is_unlisted", False))
session.add(track)
for i, playlist_meta in enumerate(playlists):
playlist = models.Playlist(
blockhash=hex(i),
blocknumber=i,
playlist_id=playlist_meta.get("playlist_id", i),
is_current=playlist_meta.get("is_current", True),
is_delete=playlist_meta.get("is_delete", False),
playlist_owner_id=playlist_meta.get("playlist_owner_id", 1),
is_album=playlist_meta.get("is_album", False),
is_private=playlist_meta.get("is_private", False),
playlist_name=playlist_meta.get("playlist_name",
f"playlist_{i}"),
playlist_contents=playlist_meta.get("playlist_contents",
{"track_ids": []}),
playlist_image_multihash=playlist_meta.get(
"playlist_image_multihash", ''),
playlist_image_sizes_multihash=playlist_meta.get(
"playlist_image_sizes_multihash", ''),
description=playlist_meta.get("description",
f"description_{i}"),
upc=playlist_meta.get("upc", f"upc_{i}"),
updated_at=playlist_meta.get("updated_at", datetime.now()),
created_at=playlist_meta.get("created_at", datetime.now()))
session.add(playlist)
for i, user_meta in enumerate(users):
user = models.User(
blockhash=hex(i),
blocknumber=1,
user_id=user_meta.get('user_id', i),
is_current=True,
handle=user_meta.get('handle', i),
wallet=user_meta.get('wallet', i),
updated_at=user_meta.get("updated_at", datetime.now()),
created_at=user_meta.get("created_at", datetime.now()),
)
session.add(user)
for i, play_meta in enumerate(entities.get('plays', [])):
play = models.Play(id=play_meta.get("id", i),
play_item_id=play_meta.get("item_id"),
created_at=play_meta.get(
"created_at", datetime.now()))
session.add(play)
for i, follow_meta in enumerate(follows):
follow = models.Follow(
blockhash=hex(i),
blocknumber=follow_meta.get("blocknumber", i),
follower_user_id=follow_meta.get("follower_user_id", i + 1),
followee_user_id=follow_meta.get("followee_user_id", i),
is_current=follow_meta.get("is_current", True),
is_delete=follow_meta.get("is_delete", False),
created_at=follow_meta.get("created_at", datetime.now()))
session.add(follow)
for i, repost_meta in enumerate(reposts):
repost = models.Repost(
blockhash=hex(i),
blocknumber=repost_meta.get("blocknumber", i),
user_id=repost_meta.get("user_id", i + 1),
repost_item_id=repost_meta.get("repost_item_id", i),
repost_type=repost_meta.get("repost_type", 'track'),
is_current=repost_meta.get("is_current", True),
is_delete=repost_meta.get("is_delete", False),
created_at=repost_meta.get("created_at", datetime.now()))
session.add(repost)
for i, save_meta in enumerate(saves):
save = models.Save(blockhash=hex(i),
blocknumber=save_meta.get("blocknumber", i),
user_id=save_meta.get("user_id", i + 1),
save_item_id=save_meta.get("save_item_id", i),
save_type=save_meta.get("save_type", 'track'),
is_current=save_meta.get("is_current", True),
is_delete=save_meta.get("is_delete", False),
created_at=save_meta.get(
"created_at", datetime.now()))
session.add(save)
