def import_users():
global users
(row_success, row_error) = (0, 0)
ses = db_session()
users = read_users(full_user_csv)
users = users[:-10] # drop last 10 rows
for user in users.values:
try:
record = User(
**{
# "id": user[0], # - nie wstawiam id, bo popsuje auto increment
"full_name": user[1],
"email": user[2],
"hashed_password": user[3],
"is_active": user[4],
})
ses.add(record)
ses.commit()
row_success += 1
except:
ses.rollback()
ses = db_session()
row_error += 1
ses.close()
print(f"User table results: success: {row_success}, failed: {row_error}")
def import_movies():
global movies
(row_success, row_error) = (0, 0)
ses = db_session()
movies = read_clear_movies(reduced_movie_csv)
for movie in movies.values:
try:
record = Movie(
**{
"id": movie[0],
"imdb_id": movie[1],
"title": movie[2],
"genres": movie[3],
"release_date": movie[4],
"overview": movie[5],
"vote_average": movie[6],
"vote_count": movie[7],
"popularity": movie[8],
"budget": movie[9],
"release_year": movie[10]
})
ses.add(record)
ses.commit()
row_success += 1
except:
ses.rollback()
ses = db_session()
row_error += 1
ses.close()
print(f"Movie table results: success: {row_success}, failed: {row_error}")
def crumb(crumb_dict):
crumb_instance = Crumb(**crumb_dict)
with db_session() as session:
session.add(crumb_instance)
session.commit()
yield crumb_instance
session.delete(crumb_instance)
def user(user_dict):
user_instance = User(**user_dict)
with db_session() as session:
session.add(user_instance)
session.commit()
yield user_instance
session.delete(user_instance)
def register():
post_data = request.get_json()
first_name = post_data.get('first_name')
last_name = post_data.get('last_name')
phone_number = post_data.get('phone_number')
normalized_phone = normalize_phone_number(phone_number)
with db_session() as session:
existing = session.query(User).filter_by(
phone_number=normalized_phone).first()
if existing:
return make_response(jsonify({
'message': 'already-exists',
})), 202
else:
user = User(first_name=first_name,
last_name=last_name,
phone_number=phone_number)
session.add(user)
session.commit()
user.send_confirmation_code()
return make_response(
jsonify({
'first_name': user.first_name,
'last_name': user.last_name,
'user_id': str(user.id),
})), 200
def resolve_crumb_images(self, args, context, info):
with db_session() as session:
res = session.query(CrumbImageModel).filter_by(
crumb_id=args['crumb_id'])
return [
CrumbImage(id=crumb_image.id,
upload_status=crumb_image.upload_status,
s3_url=crumb_image.s3_url) for crumb_image in res
]
def test_create_crumb(crumb_dict):
""" successfully creates a crumb record
"""
crumb = Crumb(**crumb_dict)
with db_session() as session:
session.add(crumb)
session.commit()
persisted_crumb = session.query(Crumb).first()
assert isinstance(persisted_crumb.id, int) is True
session.delete(persisted_crumb)
def confirmed_user(user_dict):
user_instance = User(**user_dict)
with db_session() as session:
session.add(user_instance)
code = user_instance.confirmation_code
user_instance.confirm_phone_number_with_code(code)
session.add(user_instance)
session.commit()
yield user_instance
session.delete(user_instance)
def test_create_user(user_dict):
""" successfully creates a user record
"""
user = User(**user_dict)
with db_session() as session:
session.add(user)
session.commit()
persisted_user = session.query(User).filter_by(
phone_number=user_dict['phone_number']).one()
assert isinstance(persisted_user.id, int) is True
session.delete(persisted_user)
def test_login_with_valid_credentials(test_client, user_dict):
user = User(**user_dict)
with db_session() as session:
session.add(user)
res = test_client.post('/auth/login',
data=json.dumps(user_dict),
content_type='application/json')
data = json.loads(res.data.decode())
assert res.status_code == 200
assert data.get('auth_token') is None
assert data['user_id'] is not None
def mutate(root, args, context, info):
with db_session() as session:
crumb_image_instance = CrumbImageModel(
user_id=g.current_user['id'],
s3_url=args['s3_url'],
crumb_id=args['crumb_id'])
session.add(crumb_image_instance)
session.commit()
crumb_image = CrumbImage(s3_url=crumb_image_instance.s3_url,
id=crumb_image_instance.id)
return CreateCrumbImage(crumb_image=crumb_image)
def test_create_duplicate_user(user_dict):
""" the database should not let us insert duplicate phone numbers
"""
user1 = User(**user_dict)
user2 = User(**user_dict)
with pytest.raises(sa.exc.IntegrityError):
with db_session() as session:
session.add(user1)
session.commit()
session.add(user2)
session.commit()
session.delete(user1)
session.delete(user2)
def test_create_crumb_image(crumb_image_dict):
""" successfully creates a crumb image record
"""
crumb_image = CrumbImage(**crumb_image_dict)
with db_session() as session:
session.add(crumb_image)
session.commit()
persisted_crumb_image = session.query(CrumbImage).first()
assert isinstance(persisted_crumb_image.id, int) is True
assert persisted_crumb_image.user.id == crumb_image_dict['user_id']
assert persisted_crumb_image.crumb.id == crumb_image_dict['crumb_id']
crumb = session.query(Crumb).get(crumb_image_dict['crumb_id'])
assert len(crumb.crumb_images) == 1
session.delete(persisted_crumb_image)
def test_register_with_new_user(user_dict):
""" register a user that doesn't already exist
"""
res = register_user(user_dict)
# lets go ahead and delete this user now that we have the response info
# we need so we don't muck up the test database
with db_session() as session:
session.query(User).filter_by(
phone_number=user_dict['phone_number']).delete()
data = json.loads(res.data.decode())
assert res.status_code == 200
assert data.get('auth_token') is None
assert data.get('user_id') is not None
assert data.get('first_name') == user_dict['first_name']
assert data.get('last_name') == user_dict['last_name']
def import_ratings():
(row_success, row_error) = (0, 0)
ses = db_session()
ratings = read_rating(reduced_rating_csv)
ratings = ratings[ratings["movieId"].isin(movies['id'])]
ratings = ratings[ratings["userId"].isin(users['id'])]
for rating in ratings.values:
try:
record = Rating(
**{
"user_id": rating[0],
"movie_id": rating[1],
"rating": rating[2],
"time_stamp": rating[3]
})
ses.add(record)
ses.commit()
row_success += 1
except:
row_error += 1
ses.rollback()
ses = db_session()
ses.close()
print(f"Rating table results: success: {row_success}, failed: {row_error}")
def create_savvy_request():
post_data = request.get_json()
email_address = post_data.get('email_address')
subject = post_data.get('subject')
with db_session() as session:
user = session.query(User).filter_by(
email_address=email_address).first()
if not user:
user = User(email_address=email_address)
session.add(user)
session.commit()
savvy_request = SavvyRequest(user_id=user.id, subject=subject)
session.add(savvy_request)
session.commit()
return make_response(jsonify({
'message': 'success',
})), 200
def confirm():
post_data = request.get_json()
user_id = post_data.get('user_id')
confirmation_code = post_data.get('confirmation_code')
with db_session() as session:
user = session.query(User).filter_by(id=user_id).one()
user.confirm_phone_number_with_code(confirmation_code)
session.add(user)
session.commit()
if user.phone_number_confirmed:
return make_response(
jsonify({
'auth_token': user.generate_auth_token(),
})), 200
else:
return make_response(jsonify({
'message': 'invalid-code',
})), 401
def create_savvy_submission():
post_data = request.get_json()
email_address = post_data.get('email_address')
title = post_data.get('title')
body = post_data.get('body')
with db_session() as session:
user = session.query(User).filter_by(
email_address=email_address).first()
if not user:
user = User(email_address=email_address)
session.add(user)
session.commit()
savvy_submission = SavvySubmission(user_id=user.id,
title=title,
body=body)
session.add(savvy_submission)
session.commit()
return make_response(jsonify({
'message': 'success',
})), 200
def login():
post_data = request.get_json()
phone_number = post_data.get('phone_number')
normalized_phone = normalize_phone_number(phone_number)
with db_session() as session:
user = session.query(User).filter_by(
phone_number=normalized_phone).first()
if user:
user.send_confirmation_code()
return make_response(
jsonify({
'first_name': user.first_name,
'last_name': user.last_name,
'user_id': str(user.id),
})), 200
else:
return make_response(jsonify({
'message': 'no-user-for-phone',
})), 401
def add(x):
session = db_session()
session.add(x)
session.commit()
def resolve_all_crumbs(self, args, context, info):
with db_session() as session:
res = session.query(CrumbModel)
return [Crumb(id=crumb.id, status=crumb.status) for crumb in res]
import asyncio
import pandas as pd
from src.crud import crud_movie
from src.services.omdb import load_data_from_omdb
from src.database import db_base, db_engine, db_session
from src.utilities import query_util
ses = db_session()
async def update_posters_url(movies_count: int):
db_movies = crud_movie.get_movies_without_posters(db=ses, count=movies_count)
if db_movies:
df = pd.DataFrame(query_util.query_to_dict(db_movies))
# data from omdb
results = await load_data_from_omdb(df['imdb_id'])
# transpose array
url_list = {}
for i in results:
if i['Response'] == 'True':
url_list[i['imdbID']] = i['Poster']
# update each movies
(row_success, row_error) = (0, 0)
for movie in db_movies:
poster_url = url_list[movie.imdb_id]
if crud_movie.update_movie_poster_url(db=ses, movie_obj=movie, poster_url=poster_url):
from src.database import get_db, db_session
from src.models import Movie, User, Rating
from data_loader.import_to_db import import_all
db = db_session()
try:
print("Database migration check: ", end='')
if \
db.query(Movie).count() == 0 or \
db.query(User).count() == 0 or \
db.query(Rating).count() == 0:
raise Exception('db is empty')
print("data already populated.")
except:
print("import is required!")
import_all()