# os.system('createdb synaesthetic')
model.connect_to_db(server.app)
# model.db.create_all()
# get user's top 50 artists and store as Artist objects
#this will change to be the API response instead of file
with open('top_artists.json') as f:
data = json.load(f)
#will change to get_user_info() from API response
user_id = "test2"
display_name = "test2"
image_url = "test"
db_user = crud.create_user(user_id, display_name, image_url)
#parse artists in response
for artist in data['items']:
artist_id = artist['id']
artist_name = artist['name']
popularity = artist['popularity']
#check if artist is in artists table
if crud.get_artist_by_id(artist_id) == None:
db_artist = crud.create_artist(artist_id, artist_name, popularity)
#add each artist to user_artists table
db_user_artist = crud.create_user_artist(user_id, artist_id)
#parse genres from list for each artist
def create_user(user_in: UserIn):
user = crud.create_user(user_in)
return user
with open('data/parkinfo.json') as f:
park_data = json.loads(f.read())
#Create Users
all_users = []
for user in range(50):
extension = ['@gmail.com', '@yahoo.com', '@hotmail.com']
first = fake.first_name()
last = fake.last_name()
email = f'{first}.{last}{choice(extension)}'
email = email.lower()
password = fake.word()
user = crud.create_user(first, last, email, password)
all_users.append(user)
#Create States
states = [
"AK", "AL", "AR", "AS", "AZ", "CA", "CO", "CT", "DC", "DE", "FL", "GA",
"GU", "HI", "IA", "ID", "IL", "IN", "KS", "KY", "LA", "MA", "MD", "ME",
"MI", "MN", "MO", "MS", "MT", "NC", "ND", "NE", "NH", "NJ", "NM", "NV",
"NY", "OH", "OK", "OR", "PA", "PR", "RI", "SC", "SD", "TN", "TX", "UT",
"VA", "VI", "VT", "WA", "WI", "WV", "WY"
]
for state in states:
crud.create_state(state)
#Create Parks
model.Price.query.delete()
model.Toy_Feature.query.delete()
model.Toy.query.delete()
model.User.query.delete()
model.Category.query.delete()
model.Feature.query.delete()
model.Store.query.delete()
model.Address.query.delete()
A = crud.create_category("Outdoor game", "kids toy")
B = crud.create_category("indoor toy", "kids toy")
C = crud.create_category("soft toy", "everyone loves it")
d = crud.create_category("All other", "everyone's favorite")
e = crud.create_category("board Game", "All age group")
u = crud.create_user("deena", "bhatt", "*****@*****.**", "test")
I = crud.create_user("Jiya", "Dave", "*****@*****.**", "test")
L = crud.create_user("Aanya", "Pandya", "*****@*****.**", "test")
N = crud.create_user("Miraya", "Pandya", "*****@*****.**", "test")
O = crud.create_user("Angiras", "Pandya", "*****@*****.**", "test")
V = crud.create_user("Rohan", "Bhatt", "*****@*****.**", "test")
x = crud.create_toy(C, I, "rainbowbear", "kids toy", "build a bear", 5,
"rainbowbear.jpg")
y = crud.create_toy(C, u, "Gient bears", "kids toy", "build a bear", 5,
"Gient_bears.jpg")
AA = crud.create_toy(C, L, "rainbowbear", "kids toy", "build a bear", 3,
"rainbowbear.jpg")
aa = crud.create_toy(C, N, "Gient bears", "kids toy", "build a bear", 3,
"Gient_bears.jpg")
bb = crud.create_toy(A, V, "water table outdoor", "kids toy", "fisher price",
def create_user(user: schemas.UserCreate, db: Session = Depends(get_db)):
db_user = crud.get_user_by_email(db, email=user.email)
if db_user:
raise HTTPException(status_code=400, detail="Email already registered")
return crud.create_user(db=db, user=user)
with open('data/entry.json') as d:
entry_data = json.loads(d.read())
with open('data/note.json') as d:
note_data = json.loads(d.read())
with open('data/listname.json') as d:
list_data = json.loads(d.read())
with open('data/account.json') as d:
account_data = json.loads(d.read())
users_in_db = []
for user in user_data:
username, password, first_name, last_name = (user['username'],
user['password'],
user['first_name'],
user['last_name'])
user_db = crud.create_user(username, password)
users_in_db.append(user_db)
login_in_db = []
for login in user_data:
user_id = choice(users_in_db).id
login_db = crud.create_login(user_id)
login_in_db.append(login_db)
account_in_db = []
for account in account_data:
email, password = (account['email'], account['password'])
login_id = choice(login_in_db).id
account_db = crud.create_account(email, password, login_id)
import os
import server
import model
import crud
import json
os.system('dropdb photos')
os.system('createdb photos')
model.connect_to_db(server.app)
model.db.create_all()
#creation of users
crud.create_user("John", "Doe", "*****@*****.**", "johnDoe")
crud.create_user("Jane", "Derick", "*****@*****.**", "janeDoe")
crud.create_user("Kamala", "Harris", "*****@*****.**", "kamalaHarris")
crud.create_user("Sourav", "Patel", "*****@*****.**", "souravPatel")
crud.create_user("Arnab", "Dey", "*****@*****.**", "arnabDey")
crud.create_user("Sivarman", "Rajaganpathy", "*****@*****.**",
"SivarmanRajaganpathy")
crud.create_user("Rachit", "Shrivastava", "*****@*****.**",
"RachitShrivastava")
crud.create_user("Edlund", "Connor", "*****@*****.**", "edlundConnor")
crud.create_user("Harish", "Doddi", "*****@*****.**", "harishDoddi")
crud.create_user("Mishfad", "Veedu", "*****@*****.**", "mishfadVeedu")
crud.create_user("Vivek", "Khatana", "*****@*****.**", "vivekKhatana")
#creation of photo records using json upload
with open('./images.json') as f:
def create_user(user: schemas.User, db: Session = Depends(get_db)):
is_user = crud.check_user(user.email, db)
if is_user:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST,
detail="Email already registered")
return crud.create_user(db=db, user=user)
midwives_in_db = []
for midwife in midwife_data:
name, creds, email, password, phone, address, website, bio, counties, location, services, img, lat, lng = (
midwife['name'], midwife['creds'], midwife['email'],
midwife['password'], midwife['phone'], midwife['address'],
midwife['website'], midwife['bio'], midwife['counties'],
midwife['location'], midwife['services'], midwife['img'],
midwife['lat'], midwife['lng'])
db_midwife = crud.create_midwife(name, creds, email, password, phone,
address, website, bio, counties, location,
services, img, lat, lng)
midwives_in_db.append(db_midwife)
with open('data/users.json') as f:
user_data = json.loads(f.read())
users_in_db = []
for user in user_data:
first_name, last_name, email, password, address, bio, img, lat, lng = (
user['first_name'], user['last_name'], user['email'], user['password'],
user['address'], user['bio'], user['img'], user['lat'], user['lng'])
db_user = crud.create_user(first_name, last_name, email, password, address,
bio, img, lat, lng)
users_in_db.append(db_user)
def test_create_user(self):
"""Test create_user function by checking if instance returned is User."""
user = crud.create_user(email='*****@*****.**', password='******')
self.assertIsInstance(user, User)
def test_create_inventory(self):
"""Test create_inventory function by checking if instance returned is Inventory."""
user = crud.create_user(email='*****@*****.**', password='******')
inventory = crud.create_inventory(user_id=user.user_id, title='test inventory')
self.assertIsInstance(inventory, Inventory)
# Create movies, store them in list so we can use them to create (fake) ratings later
movies_in_db = []
for movie in movie_data:
# TODO: get the title, overview, and poster_path from the movie dictionary.
# Then, get the release_date and convert it to a datetime object with datetime.strptime
format = '%Y-%m-%d'
release_date = datetime.strptime(movie['release_date'], format)
genre = None
db_movie = crud.create_movie(movie['title'], movie['overview'],
release_date, movie['poster_path'], genre)
# TODO: create a movie and append it to movies_in_db
movies_in_db.append(db_movie)
list_of_all_ratings_created = []
for n in range(10):
email = f'user{n}@test.com' # Yay! A unique fake email.
password = f'Pass{n}{n}word' # Yay! A unique fake password.
name = 'Test User'
user = crud.create_user(email=email, password=password, name=name)
for i in range(10):
score = randint(1, 5)
rand_movie = choice(movies_in_db)
crud.create_rating(score, rand_movie, user)
#**** ------------------------------- ****#
with open('data/users.json') as u:
users_data = json.loads(u.read())
for user in users_data:
fname = user['fname']
lname = user['lname']
email = user['email']
password = user['password']
phone = user['phone']
image = user['image']
crud.create_user(fname, lname, email, password, phone, image)
#**** --------- Events Data --------- ****#
#**** ------------------------------- ****#
with open('data/events.json') as e:
events_data = json.loads(e.read())
for event in events_data:
event_type = event['event_type']
event_name = event['event_name']
event_start_date = datetime.strptime(event['event_start_date'],'%Y-%m-%d %H:%M')
def register_user():
"""Add a new user.
Check if caregiver info already exists
else create both objects """
error = None
# If caregiver not logged in / brand new,
# get info, create new caregiver, and log them in:
if not current_user.is_authenticated:
# Get Caregiver info from form:
cg_name = request.form.get('caregiver-name')
cg_email = request.form.get('caregiver-email')
cg_pass = request.form.get('caregiver-password')
cg_phone = request.form.get('caregiver-phone')
password = generate_password_hash(cg_pass, method='sha256')
dupe_cg = model.Caregiver.check_if_registered(cg_email)
if dupe_cg:
login_user(dupe_cg)
else:
# Instantiate a Caregiver object
caregiver = crud.create_caregiver(cg_name, cg_email, cg_phone,
password)
login_user(caregiver)
if current_user.is_authenticated:
caregiver = current_user
# Create a user profile:
name = request.form.get('user-name')
user_name = name.capitalize()
user_body = request.form.get('body')
flow = request.form.get('flow-name')
if flow == "":
flow = 'daily'
flow_title = flow.lower()
dupe = crud.prevent_duplicates(caregiver, user_name, user_body, flow_title)
if not dupe:
new_user = crud.create_user(user_name, user_body, caregiver)
# Create a flow:
activities = request.form.getlist('activity')
duration = int(request.form.get('duration'))
new_flow = crud.create_flow(activities=activities,
duration=duration,
user=new_user,
title=flow_title)
# Get the list of associated users for display on the dashboard:
users = caregiver.users
# Success alert to caregiver:
alert = crud.send_creation_alert(API_SID, AUTH, DEMO_PHONE)
return redirect(url_for('caregiver_control_panel'))
else:
error = 'Duplicate user'
flash(
'Oops! Looks like you already have a flow for this person. If you\'re trying to create additional routines, give it a new name.'
)
return render_template('dashboard.html', users=users)
os.system("dropdb photos")
os.system("createdb photos")
model.connect_to_db(server.app)
model.db.drop_all()
model.db.create_all()
## create 5 new users
for num in range(1, 5):
fname = f"user{num}"
lname = f"user{num}"
email = f"user{num}@test.com" # Voila! A unique email!
password = "******"
user = crud.create_user(fname, lname, email, password)
## create 2 albums
album1 = crud.create_album(name='Colorado', date_created=datetime.now(), user_id=1)
album2 = crud.create_album(name='Utah', date_created=datetime.now(), user_id=1)
## load json data file
with open("data/fake_photos.json") as f:
photo_data = json.loads(f.read())
## iterate through json data and add each photo as a new photo
for photo in photo_data:
user_id = photo["user_id"]
date_uploaded = datetime.now()
date_taken = datetime.strptime(photo["date_taken"], "%Y-%m-%d %H:%M")
with open('data/offices.json') as f:
office_data = json.loads(f.read())
# pprint(office_data)
office_in_db = []
for office in office_data:
#unpack each office in office data from json file
print(office)
company_name, office_location, office_latitude, office_longitude = (
office['company_name'], office['office_location'],
office['office_latitude'], office['office_longitude'])
# create a office and append it to office_in_db
db_office = crud.create_office(company_name, office_location,
office_latitude, office_longitude)
# Create a rating for each office
office_code = crud.get_office_code(company_name, office_location)
for n in range(2):
user = f'user{n+1}@{company_name}.com'
password = '******'
user = crud.create_user(user, password)
score = randrange(0, 100, 20)
crud.create_rating(score, office_code, user.user_id)
office_in_db.append(db_office)
model.db.session.add(db_office)
model.db.session.commit()
from random import choice, randint
from datetime import datetime, date
from model import *
from crud import create_user
import server
os.system('dropdb testdb')
os.system('createdb testdb')
connect_to_db(server.app)
db.create_all()
mickey_mouse = create_user(username='******',
email='*****@*****.**',
password='******',
fname='Mickey',
lname='Mouse')
minnie_mouse = create_user(username='******',
email='*****@*****.**',
password='******',
fname='Minnie',
lname='Mouse')
donald_duck = create_user(username='******',
email='*****@*****.**',
password='******',
fname='Donald',
lname='Duck')
users_list = []
with open('data/users.json') as f:
user_data = json.loads(f.read())
for user in user_data:
username = user["username"]
fname = user["fname"]
lname = user["lname"]
email = user["email"]
password = user["password"]
birthdate_str = user["birthdate"]
birthdate_format = "%b %d, %Y"
birthdate = datetime.strptime(birthdate_str, birthdate_format)
new_user = crud.create_user(username, fname, lname, email, password,
birthdate)
users_list.append(new_user)
with open('data/mechanics.json') as f:
mechanic_data = json.loads(f.read())
for mechanic in mechanic_data:
name = mechanic["name"]
atlas_id = mechanic["id"]
crud.create_mechanic(name, atlas_id)
with open('data/categories.json') as f:
category_data = json.loads(f.read())
for category in category_data:
# crud.create_location_full(real_location=real_location,
# movie_scene=movie_scene,
# imgURL = imgURL,
# movie = movie,
# lat = lat,
# lng = lng
# )
#end of the code
crud.create_location(real_location=real_location,
movie_scene=movie_scene,
imgURL=imgURL,
description=description,
movie=movie,
movie_real_life_scene_img=movie_real_life_scene_img,
movie_scene_img=movie_scene_img)
# # params = {"address":"Dogo Onsen","key":"AIzaSyB-33vlR6YV43rPhaQIU-vZAW0LZcS2qpc"}
# # res = requests.get('https://maps.googleapis.com/maps/api/geocode/json',params = params)
# # print(res.json())
# # pprint(res.json())
# # pprint(res.json()['results'][0]['geometry']['location']['lat'])
for i in range(5):
crud.create_user(f"email_{i}@user.com", f'user-{i}')
def post_registration(user: schemas.UserCreate, db: Session = Depends(get_db)):
#db_user = crud.get_user_by_email(db, email=user.email)
#if db_user:
# raise HTTPException(status_code=400, detail="Email already registered")
crud.create_user(user, db)
return {"message": "user created"}
model.connect_to_db(server.app)
model.db.create_all()
with open('data/fakeUsers.json') as f:
user_data = json.loads(f.read())
users_in_db = []
for user in user_data:
fname = user['firstname']
lname = user['lastname']
email = user['email']
password = user['password']
phone_number = user['phone']
db_user = crud.create_user(fname, lname, email, password, phone_number)
users_in_db.append(db_user)
habits_in_db = []
habit_names_list = [
"eat 3 healthy meals a day", "read 30 minutes a day",
"meditate 15 minutes", "work out for 30 minutes",
"draw for 15 minutes a day"
]
habit_difficulties = ["Easy", "Medium", "Hard"]
habit_types = [
"Work", "Exercise", "Health & Wellness", "School", "Chores", "Creativity",
"General Self Improvement"
]
for user in users_in_db:
if "-resetdb" in sys.argv:
os.system('dropdb pb')
os.system('createdb pb')
connect_to_db(server.app, local=local)
db.create_all()
### Seeding User ###
for n in range(1, 11):
"""Seeding users table."""
first_name = f'Bob{n}'
last_name = f'Bobby{n}'
email = f'test{n}@test.com' # A unique email!
password = f'test{n}'
crud.create_user(first_name, last_name, email, password)
#* Miss Piggy *#
crud.create_user("Miss", "Piggy", "*****@*****.**", "kermit")
### Seeding Account ###
for n in range(1, 5):
"""Seeding accounts table for user_id 1."""
user_id = 1
account_type = "Checking"
account_nickname = f"Nickname{n}"
crud.create_account(user_id, account_type, account_nickname)
for n in range(5, 9):
"""Seeding accounts table for user_id 2."""
import os
import server
import model
import crud
import json
os.system('dropdb hellosisters')
os.system('createdb hellosisters')
model.connect_to_db(server.app)
model.db.create_all()
#creating users
crud.create_user("test", "*****@*****.**", "test1")
crud.create_user("jane", "*****@*****.**", "test")
#create blogs
crud.create_blog("The world is yours", "Finishing school and graduating")
crud.create_blog("Go and get it!", "After graduation set yourself free")
list_of_users = []
# Create 10 users;
for n in range(10):
email = f'user{n}@test.com'
password = '******'
first_name = choice([
'Jane', 'John', 'Zella', 'Jordan', 'Nick', 'Rachel', 'Thomas', 'Trish',
'Micah', 'Jack'
])
last_name = choice([
'Wolter', 'Adair', 'Morgan', 'Lewis', 'Hepper', 'Marin', 'Knutsen',
'Wagner', 'Torke'
])
user = crud.create_user(first_name, last_name, email, password)
list_of_users.append(user)
'''Create "favorite" and "roasters" lists for each user'''
for user in list_of_users:
db_list1 = crud.create_list(list_name='My Favorites', user=user)
db_list2 = crud.create_list(list_name='My Roasters', user=user)
rated_roasters = []
'''Create 4 entries for roasters list and 1 entry for favorites list, for each user'''
# Create 4 entries for 'My Roasters' list
for n in range(6):
# For each entry, make random choice from roasters list, remove that choice from the list but add to separate list (so can add
# those roasters back to master list later), generate score and make random choice for note, instantiate entry and loop through
new_book = crud.create_book(title, author, publisher, published_date, isbn,
description, cover_img_source)
print(f"added new book to database : {new_book}")
book_data_seeding.append(new_book)
# ADD TEST USERS TO DATABASE
user_data_seeding = []
with open('data/seeding_jsons/test_user_info.json') as f:
user_data = json.loads(f.read())
zipcode = [
"94115", "94941", "94607", "94501", "94577", "94010", "94608", "94115"
]
for user in user_data:
new_user = crud.create_user(user['email'], user['password'],
user['user_name'], choice(zipcode))
print(f"added new book to database : {new_user}")
user_data_seeding.append(new_user)
# ADD READING STATUS TO DATABASE
reading_data_seeding = []
with open('data/seeding_jsons/reading_status.json') as f:
reading_data = json.loads(f.read())
for status in reading_data:
new_status = crud.create_reading_status(status['reading_status'])
print(f"added new reading_status to database : {new_status}")
reading_data_seeding.append(new_status)
model.connect_to_db(server.app)
model.db.create_all()
# users_in_db = []
# for n in range(10):
# fname = str(n)
# lname = str(n)
# email = f'user{n}@test.com'
# pw = 'test'
# img = ''
# user = crud.create_user(fname, lname, email, pw, img)
# users_in_db.append(user)
trie = server.email_trie
user_1 = crud.create_user('Pam', 'Deezly', 'work-pam@__mifflin.com', 'test',
'', trie)
user_2 = crud.create_user('Jim', 'Halfort', 'work-jim@__mifflin.com', 'test',
'', trie)
user_3 = crud.create_user('Dwight', 'Root', 'work-dwight@__mifflin.com',
'test', '', trie)
user_4 = crud.create_user('Michael', 'Scatt', 'work-michael@__mifflin.com',
'test', '', trie)
user_5 = crud.create_user('Jan', 'Havingson', 'work-jan@__mifflin.com', 'test',
'', trie)
user_6 = crud.create_user('Ryan', 'Hovard', 'work-ryan@__mifflin.com', 'test',
'', trie)
user_7 = crud.create_user('Andy', 'Nard', 'work-andy@__mifflin.com', 'test',
'', trie)
user_8 = crud.create_user('Erin', 'Cannon', 'work-erin@__mifflin.com', 'test',
'', trie)
user_9 = crud.create_user('Stanley', 'Hutson', 'work-stanley@__mifflin.com',
with open('data/movies.json') as f:
movie_data = json.loads(f.read())
# Create movies, store them in list so we can use them
# to create fake ratings later
movies_in_db = []
for movie in movie_data:
title, overview, poster_path = (movie['title'],
movie['overview'],
movie['poster_path'])
release_date = datetime.strptime(movie['release_date'], '%Y-%m-%d')
db_movie = crud.create_movie(title,
overview,
release_date,
poster_path)
movies_in_db.append(db_movie)
for n in range(10):
email = f'user{n}@test.com' # Voila! A unique email!
password = '******'
user = crud.create_user(email, password)
for _ in range(10):
random_movie = choice(movies_in_db)
score = randint(1, 5)
crud.create_rating(user, random_movie, score)
import os
from random import choice, randint
from datetime import datetime
import crud
import model
import server
os.system('dropdb travel')
os.system('createdb travel')
model.connect_to_db(server.app)
model.db.create_all()
# Create users
crud.create_user('*****@*****.**', 'test', 'Alex', 'Arbour')
crud.create_user('*****@*****.**', 'test', 'Bobby', 'Bobbington')
crud.create_user('*****@*****.**', 'test', 'Claire', 'Carson')
crud.create_user('*****@*****.**', 'test', 'Dawna', 'Darcy')
crud.create_user('*****@*****.**', 'test', 'Eunice', 'Ellis')
crud.create_user('*****@*****.**', 'test', 'Flo', 'Florence')
crud.create_user('*****@*****.**', 'test', 'Grace', 'Graceful')
crud.create_user('*****@*****.**', 'test', 'Hildy', 'Hinter')
crud.create_user('*****@*****.**', 'test', 'Jamie', 'Jameson')
crud.create_user('*****@*****.**', 'test', 'Kat', 'King')
#create itineraries
crud.create_itinerary('London, UK', '2021-01-01', '2021-01-08', 15, 51.4141076, -1.4000882)
crud.create_itinerary('Bali, Indonesia', '2021-05-05', '2021-05-15', 11, -8.4556973, 114.510954)
crud.create_itinerary('San Francisco, CA', '2020-12-01', '2020-12-05', 5, 37.7576793, -122.5076413)
clog_timestamp = SEED[i]['cleanse_log']['timestamp']
comment = SEED[i]['cleanse_log']['comment']
private = SEED[i]['cleanse_log']['private']
r_name = SEED[i]['recipe']['name']
timestamp = SEED[i]['recipe']['timestamp']
i_name = SEED[i]['ingredients'][1]['name']
calories = SEED[i]['ingredients'][1]['calories']
i_name_2 = SEED[i]['ingredients'][2]['name']
calories_2 = SEED[i]['ingredients'][2]['calories']
i_name_3 = SEED[i]['ingredients'][3]['name']
calories_3 = SEED[i]['ingredients'][3]['calories']
db_user = crud.create_user(username, email, password)
db_ingredient = crud.create_ingredient(i_name, calories)
db_ingredient_2 = crud.create_ingredient(i_name_2, calories_2)
db_ingredient_3 = crud.create_ingredient(i_name_3, calories_3)
db_recipe = crud.create_recipe(r_name, db_user)
db_cleanse = crud.create_cleanse(start_date, end_date, public, description,
db_user)
crud.create_recipe_ingredient(db_recipe, db_ingredient)
crud.create_recipe_ingredient(db_recipe, db_ingredient_2)
crud.create_recipe_ingredient(db_recipe, db_ingredient_3)
db_user_cleanse = crud.create_user_cleanse(active, completed, db_cleanse,
db_user)
crud.create_user_cleanse_recipe(timestamp, start_date, db_user_cleanse,
db_recipe)
async def create_user(user: schemas.User, db: Session = Depends(get_db)):
return crud.create_user(db=db, user=user)
