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)