def create_account() -> User:
# Prompt user for username
username = input("Choose your username: "******"\nHmm, that username is already taken. Let's try something different!"
)
username = input("Choose your username: "******"Great, choose your password now: ")
salt = os.urandom(32) # A new salt for this user
key = hashlib.pbkdf2_hmac('sha256', password.encode('utf-8'), salt, 100000)
user = User(name=username, salt=salt, key=key)
session.add(user)
session.commit()
user_instance = session.query(User).filter_by(name=username).first()
print("\nYou've successfully created the account!")
return user_instance
def on_post(self, req, resp, *args, **kwargs):
cid = req.context['doc']['Car']
cars = session.query(Car).filter(Car.id == int(cid)).one()
uid_list = req.context['doc']['User']
for uid in uid_list:
car = session.query(User).filter(User.id == int(uid)).one()
cars.users.remove(car)
session.commit()
def on_post(self, req, resp, *args, **kwargs):
uid = req.context['doc']['User']
users = session.query(User).filter(User.id == int(uid)).one()
cid_list = req.context['doc']['Car']
for cid in cid_list:
user = session.query(Car).filter(Car.id == int(cid)).one()
users.cars.append(user)
session.commit()
def get(self, keg_id):
if keg_id is None:
result = []
for instance in session.query(Keg).order_by(Keg.id):
result.append(instance.to_json())
return jsonify(result)
else:
keg = session.query(Keg).filter(Keg.id == keg_id).first()
return jsonify(keg.to_json())
def find_or_create_subsite(self, subreddit_name):
reddit = session.query(Site).filter_by(name="Reddit").first()
subsite = session.query(Subsite).filter_by(
site_id=reddit.id, name=subreddit_name).first()
if not subsite:
url = self.BASE_URL + "/r/" + subreddit_name
subsite = Subsite(name=subreddit_name, site_id=reddit.id, url=url)
session.add(subsite)
session.commit()
return subsite
def get(self, user: int, password: int):
result = {}
busquedas = session.query(BusquedaSegundaMano).all()
for busqueda in busquedas:
anuncios = session.query(Anuncio).filter(
Anuncio.busqueda_id == busqueda.id).all()
for anuncio in anuncios:
imagenes = session.query(Imagen).filter(
Imagen.anuncio_id == anuncio.id).all()
return {'nada': 'nada'}
def q_where_exists():
from sqlalchemy.sql import exists
stmt = exists().where(Image.owner_id == User.id)
for (name,) in session.query(User.name).filter(stmt):
print name
stmt = exists().where(User.name == "not exists")
for (name,) in session.query(User.name).filter(stmt):
print name
else:
print "not exists"
def get(self, beer_id):
if beer_id is None:
result = []
for instance in session.query(Beer).order_by(Beer.id):
result.append(instance.to_json())
return jsonify(result)
else:
beer = session.query(Beer).filter(Beer.id == beer_id).first()
if beer:
return jsonify(beer.to_json())
else:
return ('Beer Not Found', 404)
def on_post(self, req, resp, *args, **kwargs):
uid = req.context['doc']['User']
user = session.query(User).filter(User.id == int(uid)).one()
cid_list = req.context['doc']['Car']
for cid in cid_list:
try:
with session.begin_nested():
car = session.query(Car).filter(Car.id == int(cid)).one()
user.cars.append(car)
except Exception as e:
raise falcon.HTTPBadRequest("User:%s" % uid,
"is linking with Car: %s" % cid)
session.commit()
def on_post(self, req, resp, *args, **kwargs):
cid = req.context['doc']['Car']
car = session.query(Car).filter(Car.id == int(cid)).one()
uid_list = req.context['doc']['User']
for uid in uid_list:
try:
with session.begin_nested():
user = session.query(User).filter(
User.id == int(uid)).one()
car.users.remove(user)
except Exception as e:
raise falcon.HTTPBadRequest(
"Car:%s" % cid, "is not linking with User: %s" % uid)
session.commit()
def showDashboard():
"""Gathers the users categories and tasks, and renders the dashboard page.
Returns:
The dashboard page state
"""
if 'username' not in user_session:
return redirect('/login')
categories = session.query(Category).filter_by(
user_id=user_session['user_id']).all()
tasks = session.query(Task).filter_by(
user_id=user_session['user_id']).all()
flash("Welcome, " + user_session['username'] + ", to Worksack!")
return render_template('dashboard.html', categories=categories,
tasks=tasks)
def getUserID(email):
try:
user = session.query(User).filter_by(
email=user_session['email']).one()
return user.id
except:
return None
def home():
hour_ago = datetime.now() - timedelta(hours=1)
day_ago = datetime.now() - timedelta(hours=24)
week_ago = datetime.now() - timedelta(days=7)
logs = session.query(ScrapeLog).order_by("id desc").limit(500)
hour_mention_count = session.query(Mention).filter(
Mention.created_at > hour_ago).count()
day_mention_count = session.query(Mention).filter(
Mention.created_at > day_ago).count()
week_mention_count = session.query(Mention).filter(
Mention.created_at > week_ago).count()
return render_template('home.html',
logs=logs,
hour_mention_count=hour_mention_count,
day_mention_count=day_mention_count,
week_mention_count=week_mention_count)
def budget_category(budget: Budget, month, year) -> Category:
all_categories = get_budget_categories(budget)
choice = input("Pick category's ID which you want to budget for this month: ")
selected_category = next((category for category in all_categories if category.id == int(choice)), None)
if selected_category:
new_budget_amount = input("What amount do you wish to budget for this category: ")
category_budget = session.query(CategoryBudget) \
.filter(
CategoryBudget.category_id == selected_category.id,
CategoryBudget.datetime >= datetime(year, month, 1),
CategoryBudget.datetime <= datetime(year, month, monthrange(year, month)[1])
).first()
if category_budget:
category_budget.budgeted_amount = new_budget_amount
session.add(category_budget)
session.commit()
else:
category_budget = CategoryBudget(budgeted_amount=new_budget_amount, category_id=selected_category.id,
datetime=datetime(year, month, 1))
session.add(category_budget)
session.commit()
else:
print("Incorrect category!")
def dispatch_request(self, keg_id):
keg = session.query(Keg).filter(Keg.id == keg_id).first()
if keg:
return jsonify(keg.beer.to_json())
else:
return ('Keg Not Found', 404)
def add_budget(user: User) -> Budget:
budget_name = input("Name of the new budget: ")
budget = Budget(name=budget_name, user_id=user.id)
session.add(budget)
session.commit()
new_budget = session.query(Budget).order_by(Budget.id.desc()).first()
return new_budget
def check_auth(email, password):
account = session.query(Account).filter(Account.email == email).first()
if account and account.verify_password(password):
g.account = account
return True
else:
return False
def edit_item(category_name, item_name):
data = request.get_json()
item = session.query(Item).filter_by(name=item_name).one()
user_jwt = request.headers.get('Authorization')
# If user is not logged in or user is not in db return error response
if user_jwt == u"null" or not verify_jwt(user_jwt):
return create_message_response('Unauthorized access', 400)
else:
user_info = jwt.decode(user_jwt, SECRET, algorithms=['HS256'])
# Check if request has required content
if 'name' not in data or 'description' not in data:
return create_message_response('Invalid input', 400)
# Logged in user must match item creator to edit item
if user_info['username'] == item.creator:
# Use Marshmallow to create item object
input_dict = {
'name': data['name'],
'description': data['description'],
'category_name': item.category_name,
'creator': item.creator,
}
item_mm = verify_item(input_dict)
# If errors exist on object, one of the input fields is empty
if item_mm.errors:
return create_message_response('Input cannot be empty', 400)
# Edit item information and commit changes
else:
item.name = item_mm.data.name
item.description = item_mm.data.description
session.add(item)
session.commit()
return create_message_response('Item successfully edited', 200)
# If user is not logged in user is not item creator
else:
return create_message_response('Unauthorized access', 400)
def editCategory(category_id):
"""Given a category id, display a form for editing the data
describing that category, and handle the submission of that form.
Args:
category_id: The id of the category to be edited.
Returns:
Redirect to main dashboard on successful form submission, which will show
the edited category changes. Otherwise, returns rendered edit
category template.
"""
if 'username' not in user_session:
return redirect('/login')
category = session.query(Category).filter_by(id=category_id).one()
if category.user_id != user_session['user_id']:
return "<script>function showAuthAlert() {alert('You are not " \
+ "authorized to edit this category.');}" \
+ "</script><body onload='showAuthAlert()'>"
original_name = category.name
if request.method == 'POST':
if request.form['name']:
category.name = request.form['name']
if request.form['description']:
category.description = request.form['description']
session.add(category)
try:
session.commit()
except:
session.rollback()
flash("Category: " + original_name + " was successfully edited!")
return redirect(url_for('showDashboard'))
else:
return render_template('edit_category.html', category=category)
def put(self, account_id):
account_json = request.get_json()
account = session.query(Account).filter(
Account.id == account_id).first()
if account:
account.updated_at = datetime.datetime.utcnow()
if 'email' in account_json:
account.email = account_json['email']
if 'first_name' in account_json:
account.first_name = account_json['first_name']
if 'last_name' in account_json:
account.last_name = account_json['last_name']
session.commit()
if 'email_token' in account_json:
if not self.link_card(account, account_json['email_token']):
return ('Invalid Email Token', 400)
return jsonify(account.to_json())
else:
return ('Account Not Found', 404)
def deleteCategory(category_id):
"""Given a category id, display a button for deleting that category,
and handle the clicking of that button.
Args:
category_id: The id of the category to be deleted
Returns:
Redirect to main dashboard on successful form submission, which will show
the remaining categories. Otherwise, returns rendered delete
category template.
"""
if 'username' not in user_session:
return redirect('/login')
category = session.query(Category).filter_by(id=category_id).one()
if category.user_id != user_session['user_id']:
return "<script>function showAuthAlert() {alert('You are not " \
+ "authorized to delete this category.');}" \
+ "</script><body onload='showAuthAlert()'>"
if request.method == 'POST':
session.delete(category)
try:
session.commit()
except:
session.rollback()
flash("Category: " + category.name + " was successfully deleted!")
return redirect(url_for('showDashboard'))
else:
return render_template('delete_category.html', category=category)
def deleteTask(category_id, task_id):
"""Given a category id and task id, render a button that will allow the
given task to be deleted, and process the clicking of that button.
Args:
category_id: The id of the category to be displayed after task deletion.
task_id: The id of the task to be deleted
Returns:
Redirect for category that contained the deleted task on form submission,
otherwise renders the task deletion template for display.
"""
if 'username' not in user_session:
return redirect('/login')
task = session.query(Task).filter_by(id=task_id).one()
if task.user_id != user_session['user_id']:
return "<script>function showAuthAlert() {alert('You are not " \
+ "authorized to delete this task.');}" \
+ "</script><body onload='showAuthAlert()'>"
if request.method == 'POST':
session.delete(task)
try:
session.commit()
except:
session.rollback()
flash("Task: " + task.name + " was successfully deleted!")
return redirect(url_for('showCategory', category_id=category_id))
else:
return render_template('delete_task.html', task=task)
def last_successful_request(self):
return session.query(TechnicalRequest) \
.filter_by(tradable_id=self.tradable_id) \
.filter_by(technical_indicator_id=self.technical_indicator_id) \
.filter_by(sent=True) \
.filter_by(successful=True) \
.order_by(TechnicalRequest.time_sent.desc()) \
.first()
def get_today():
today = session.query(WorkDay).filter(WorkDay.day==datetime.date.today())
try:
return today.one()
except NoResultFound:
commit(WorkDay(day=datetime.date.today()))
return get_today()
def show(self, account_id):
account = session.query(Account).filter(
Account.id == account_id).first()
if account:
return jsonify(account.to_json())
else:
return ('Account Not Found', 404)
def show_dashboard():
"""Gathers the users categories and tasks, and renders the dashboard page.
Returns:
The dashboard page state
"""
input_sets = session.query(InputSet).all()
return render_template('dashboard.html', input_sets=input_sets)
def check_keg(token, secret):
kegerator = session.query(Kegerator).filter(
Kegerator.token == token).first()
if kegerator and kegerator.verify_secret(secret):
g.kegerator = kegerator
return True
else:
return False
def createUser(user_session):
newUser = User(name=user_session['username'],
email=user_session['email'],
image=user_session['picture'])
session.add(newUser)
session.commit()
user = session.query(User).filter_by(email=user_session['email']).one()
return user.id
def get_user():
users = session.query(User).all()
print users
for user in users:
print user["first_name"]
return "Getting users"
def verify_jwt(user_jwt):
user_info = jwt.decode(user_jwt, SECRET, algorithms=['HS256'])
username = user_info['username']
user = session.query(User).filter_by(email=username)
if not user:
return False
else:
return True
def dispatch_request(self, beer_id):
beer = session.query(Beer).filter(Beer.id == beer_id).first()
if beer:
result = []
for instance in beer.kegs:
result.append(instance.to_json())
return jsonify(result)
else:
return ('Beer Not Found', 404)
def find_or_create_product_group(self, amazon_name):
product_group = session.query(ProductGroup).filter_by(
amazon_name=amazon_name).first()
if not product_group:
product_group = ProductGroup(amazon_name=amazon_name,
name=amazon_name)
session.add(product_group)
session.commit()
return product_group
def add_parent_category(budget: Budget) -> ParentCategory:
parent_category_name = input("The name of the new parent category: ")
parent_category = ParentCategory(name=parent_category_name,
budget_id=budget.id)
session.add(parent_category)
session.commit()
new_parent_category = session.query(Budget).order_by(
Budget.id.desc()).first()
return new_parent_category
def find_or_create_comment(self, attrs):
comment = session.query(Comment).filter_by(
site_comment_ident=attrs['site_comment_ident']).first()
if not comment:
comment = Comment()
for key in attrs:
setattr(comment, key, attrs[key])
session.add(comment)
return comment
def _load_movies_with_ratings(self):
return session.query(
models.Movie, models.MovieInfoIDX.info
).join(
models.MovieInfoIDX
).filter(
models.MovieInfoIDX.info_type_id==RATING_ID,
models.Movie.id.in_(self.movie_ids)
)
def link_card(self, account, email_token):
card = session.query(Card).filter(
Card.email_token == email_token).first()
if card and account.email == card.email:
card.account = account
session.commit()
return True
else:
return False
def update():
users = session.query(User).all()
users.reverse()
for user in users:
if user.qq == "7420838":
break
user.send = False
session.commit()
def add():
df = pd.read_csv('qq.csv')
for qq in df['qq']:
newqq = str(qq)
users = session.query(User).filter(User.qq == newqq).all()
if len(users) == 0:
user = User(name="", qq=newqq, send=False)
session.add(user)
session.commit()
def get(self):
users = session.query(User).all()
res = {
'user_list': [i.all() for i in users]
}
return jsonify(res)
def dispatch_request(self, account_id):
result = []
account = session.query(Account).filter(
Account.id == account_id).first()
if account:
for instance in account.cards:
result.append(instance.to_json())
return jsonify(result)
else:
return ('Account Not Found', 404)
def categoryTasksJSON(category_id):
"""Given a category id, serializes the category information, as
well as information of all tasks under the category into JSON data.
Args:
category_id: The id of the category from which to retrieve
the information
Returns:
Valid JSON containing all DB information for the requested category,
and tasks under that category.
"""
category = session.query(Category).filter_by(id=category_id).one()
if category.user_id != user_session['user_id']:
return "<script>function showAuthAlert() {alert('You are not " \
+ "authorized to view this category JSON.');}" \
+ "</script><body onload='showAuthAlert()'>"
items = session.query(Task).filter_by(category_id=category_id).all()
return jsonify(Category=[category.serialize], Tasks=[i.serialize
for i in items])
def showCategory(category_id):
"""Given a category id, retrieve the data for the category and all
tasks under that category. Then, render the category template with
that data.
Args:
category_id: The id of the category to be displayed.
Returns:
Rendered category read template for display
"""
if 'username' not in user_session:
return redirect('/login')
category = session.query(Category).filter_by(id=category_id).one()
if category.user_id != user_session['user_id']:
return "<script>function showAuthAlert() {alert('You are not " \
+ "authorized to view this category.');}" \
+ "</script><body onload='showAuthAlert()'>"
tasks = session.query(Task).filter_by(category_id=category_id).all()
return render_template('category.html', category=category, tasks=tasks)
def get(self, **kwargs):
user_id = kwargs['user_id']
user = session.query(User).get(user_id)
if not user:
res = {'err_msg': 'user not exists'}
else:
res = user.all()
return jsonify(res)
def taskJSON(category_id, task_id):
"""Given a task id, serializes the task information into JSON data.
Args:
category_id: Required by routing methodology. Not actually used.
task_id: The id of the category from which to retrieve the information
Returns:
Valid JSON containing all DB information for the requested task.
"""
task = session.query(Task).filter_by(id=task_id).one()
if task.user_id != user_session['user_id']:
return "<script>function showAuthAlert() {alert('You are not " \
+ "authorized to view this task JSON.');}" \
+ "</script><body onload='showAuthAlert()'>"
return jsonify(Task=task.serialize)
def render_calendar():
"""Gets all events attached to the selected input set, and then renders the
event calendar utilizing the selected data. The frontend logic for the
calendar is contained in templates/static.html
Returns:
The rendered calendar template if POST, otherwise returns to the dashboard.
"""
if request.method == 'POST':
input_set_id = request.form["inputSet"]
if (input_set_id is None):
flash("Please upload and select a valid input set.")
return redirect(url_for('show_dashboard'))
events = session.query(Event).filter_by(input_set_id=input_set_id).all()
return render_template('calendar.html', events=events)
return redirect(url_for('show_dashboard'))
def upload_events():
"""Attempts to parse and store a JSON file sent in the request.
Every file uploaded is considered as an input set, which is a set of data
that provides a complete test case for the app's main functionality.
Returns:
The dashboard page state with message flashes on error.
"""
if request.method == 'POST':
file = request.files['file']
if file and valid_file(file.filename):
try:
events = json.load(file)
except:
flash("An error occurred while parsing the provided JSON. Please check the validity of the data.")
return redirect(url_for('show_dashboard'))
try:
input_set = InputSet(name=request.form["name"])
session.add(input_set)
for event in events:
event_type = session.query(EventType).filter_by(name=event["type"]).one()
# Ensure that start and endtimes are stored as timestamps
# with no corresponding date.
start_time = datetime.strptime(event["startTime"], "%H:%M:%S").time()
end_time = datetime.strptime(event["endTime"], "%H:%M:%S").time()
db_event = Event(title=event["title"], description=event["description"],
start_time=start_time, end_time=end_time, address=event["address"],
type_id=event_type.id, input_set_id=input_set.id)
session.add(db_event)
session.commit()
except:
session.rollback()
flash("An error occurred while saving the provided JSON. Please check the validity of the data.")
return redirect(url_for('show_dashboard'))
return redirect(url_for('show_dashboard'))
else:
flash("A JSON file was not provided. Nothing to see here...")
return redirect(url_for('show_dashboard'))
def showTask(category_id, task_id):
"""Given a category id and task id, display information set by the user
that is attached to this task. This will be more heavily extended in
future releases, to allow multimedia definitions of what a task entails.
Args:
category_id: Required by routing methodology. Not actually used.
task_id: The id of the task to be displayed
Returns:
Rendered task read template.
"""
if 'username' not in user_session:
return redirect('/login')
task = session.query(Task).filter_by(id=task_id).one()
if task.user_id != user_session['user_id']:
return "<script>function showAuthAlert() {alert('You are not " \
+ "authorized to view this task.');}" \
+ "</script><body onload='showAuthAlert()'>"
return render_template('task.html', task=task)
def fetch_distinct_ids(self):
query = session.query(distinct(models.Movie.id))
query = self._add_conditions(query)
return query.all()
def event_JSON(event_id):
event = session.query(Event).filter_by(id=event_id).one()
return jsonify(event.serialize)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from session import session
import models
# Userを追加
session.add_all([models.User('name' + str(i), 'fullname', 'password') for i in range(100)])
session.commit()
# 最初のUserにImageを追加
users = session.query(models.User).all()
user = users[0]
session.add_all([models.Image('image' + str(i), user) for i in range(10)])
for user in users[1:5]:
session.add_all([models.Image('image' + str(i), user) for i in range(5)])
session.commit()
from session import session
from database_model import Restaurant, Base, MenuItem, User
# Delete all existing
session.query(Restaurant).delete()
session.query(MenuItem).delete()
session.query(User).delete()
session.commit()
# ############ Create new ones ############
# Create dummy user
User1 = User(name="Diner Jack", email="*****@*****.**",
picture='http://localhost:5000/static/diner-owner.jpg')
session.add(User1)
session.commit()
# Restaurant UrbanBurger
restaurant1 = Restaurant(user_id=1, name="Urban Burger")
session.add(restaurant1)
session.commit()
menuItem1 = MenuItem(
user_id=1,
name="French Fries",
description="with garlic and parmesan",
price="$2.99",
course="Appetizers",
restaurant=restaurant1)
def getUserInfo(user_id):
try :
user = session.query(User).filter_by(id=user_id).one()
return user
except Exception:
return None
def getUserId(email):
try:
user = session.query(User).filter_by(email=email).one()
return user.id
except:
return None
def q_select_users_relation():
user = session.query(User).first()
print user.name
for image in user.images:
print image.filename,
print ""
from session import session
from database_model import Restaurant, Base, MenuItem, User
print '********* Users ***********'
users = session.query(User).all()
for user in users:
print 'id:{} name:{}, picture:{}'.format(user.id, user.name, user.picture)
print '********* Restaurants ***********'
restaurants = session.query(Restaurant).all()
for restaurant in restaurants:
print 'id:{} name:{}'.format(restaurant.id, restaurant.name)
print '********* Menu Items ***********'
items = session.query(MenuItem).all()
for item in items:
print 'id:{} name:{} restaurant:{}'.format(item.id, item.name, item.restaurant_id)
# -*- coding: utf-8 -*-
from models import User, Image
from session import session
# UserとImageを追加する。
testuser = User('test_cascade', '', '')
testimage = Image('image name', testuser)
session.add(testuser)
session.add(testimage)
session.commit()
# 追加されているか確認
user = session.query(User).filter(User.name=='test_cascade').first()
image = session.query(Image).filter(Image.filename=='image name').first()
print user.name
print image.filename
# Userを削除する。Imageは直接削除しない。
session.delete(user)
session.commit()
# UserもImageも削除されていることを確認
user = session.query(User).filter(User.name=='test_cascade').first()
image = session.query(Image).filter(Image.filename=='image name').first()
print user
print image
from models import User
from session import session
print len(session.query(User).all())
session.add(User('hoge','hoge','hoge'))
print len(session.query(User).all())
session.rollback()
print len(session.query(User).all())
def q_subquery():
stmt = session.query(User).filter(User.name == "name1").subquery()
for user in session.query(stmt).all():
print user.name
def q_select_images_relation():
for row in session.query(Image).all()[0:1]:
print row.filename, "'s owner is", row.owner.name
