def load_user_id():
g.user_id = session.get('user_id')
if g.user_id != None:
g.user = db_session.query(User).filter_by(id=g.user_id)
g.photos = db_session.query(Photo).filter_by(user_id=g.user_id).all()
def store_smurf(self, spring_id, user_id, IP, country, cpu_id):
spring_id = self.get_kv_id('SpringID', spring_id)
user_id = self.get_kv_id('User', user_id)
country_id = self.get_kv_id('Country', country)
cpu_id = self.get_kv_id('CPU', cpu_id)
insert = False
smurf = Smurf.where(spring_id=spring_id,
user_id=user_id,
country_id=country_id,
cpu_id=cpu_id).order_by(desc(
Smurf.first_seen)).first()
if smurf:
max_first_seen = session.query(func.max(
Smurf.first_seen)).filter_by(spring_id=spring_id).scalar()
if max_first_seen == smurf.first_seen:
smurf.last_seen = datetime.utcnow()
smurf.save()
else:
insert = True
else:
insert = True
if insert:
smurf = Smurf.create(
spring_id=spring_id,
user_id=user_id,
country_id=country_id,
cpu_id=cpu_id,
first_seen=datetime.utcnow(),
last_seen=datetime.utcnow(),
)
if IP:
IPID = self.get_kv_id('IP', IP)
insert = False
smurfIP = SmurfIP.where(smurf_id=smurf.id, IPID=IPID).order_by(
desc(SmurfIP.first_seen)).first()
if smurfIP:
max_first_seen = session.query(func.max(
SmurfIP.first_seen)).filter_by(smurf_id=smurf.id).scalar()
if max_first_seen == smurfIP.first_seen:
smurfIP.last_seen = datetime.utcnow()
smurfIP.save()
else:
insert = True
else:
insert = True
if insert:
SmurfIP.create(
smurf_id=smurf.id,
IPID=IPID,
first_seen=datetime.utcnow(),
last_seen=datetime.utcnow(),
)
session.commit()
def movie(id):
if not g.user_id:
print 'no global user'
movie = db_session.query(Movie).get(id)
ratings = movie.ratings
total = []
for rating in ratings:
total.append(rating.rating)
avg_rating = float(sum(total))/len(total)
return render_template('movie.html', movie=movie,
avg=avg_rating, user_rating=None, prediction=None)
else:
movie = db_session.query(Movie).get(id)
ratings = movie.ratings
total = []
user_rating = None
for rating in ratings:
if rating.user_id == g.user_id:
user_rating = rating
total.append(rating.rating)
avg_rating = float(sum(total))/len(total)
# predict if no user rating
prediction = None
if not user_rating:
user = db_session.query(User).get(g.user_id)
prediction = user.predict_rating(movie)
print "Prediction: ", prediction
return render_template('movie.html', movie=movie,
avg=avg_rating,
user_rating=user_rating,
prediction=prediction)
def searchShape(num):
"""
根据传入的形态号，到数据库查询相关信息
:参数：
- **num(int, None)** : 形态号
:返回:
- **item(dict)** : 以字典格式返回相关信息
"""
item = {}
Query1 = session.query(Shape).filter(Shape.num == num).first()
Query2 = session.query(New).filter(New.sid == Query1.id).first()
# Query2 = session.query(New).filter(New.num == num).first()
item = {}
item["upChance"] = Query2.upChance
item["highpoint"] = Query2.highpoint
item["lowpoint"] = Query2.lowpoint
item["maxampButton"] = Query2.maxampButton
item["maxampTop"] = Query2.maxampTop
item["minampButton"] = Query2.minampButton
item["minampTop"] = Query2.minampTop
item["num"] = Query2.num
return item
def load_user_id():
g.user_id = session.get('user_id')
if g.user_id != None:
g.user = db_session.query(User).filter_by(id=g.user_id)
g.photos = db_session.query(Photo).filter_by(user_id=g.user_id).all()
def show_existing_inputs():
"""
This shows the user's current saved inputs and allows them
to either move on or edit it.
"""
if g.logged_in is True:
if g.inputs is True:
user_assets = m_session.query(model.UserBanking).filter_by(
user_id=g.user.id).first()
total_assets = user_assets.inputted_assets + \
user_assets.checking_amt + user_assets.savings_amt + \
user_assets.IRA_amt + user_assets.comp401k_amt + \
user_assets.investment_amt
risk_prof = m_session.query(model.RiskProfile).filter_by(
id=g.user.risk_profile_id).first()
return render_template(
"profile_inputs.html",
assets=utils.format_currency(total_assets),
income=utils.format_currency(g.user.income),
company_401k=g.user.company_401k,
company_match=g.user.company_match,
match_percent=utils.format_percentage(g.user.match_percent),
match_salary=utils.format_percentage(g.user.match_salary),
risk_profile=risk_prof.name)
else:
flash("Our financial data on you is incomplete. \
Please input now.")
return redirect("/input/banking")
else:
return redirect("/login")
def view_categories():
# get all categories of type "goods"
goods = db_session.query(Category).filter_by(cat_type=1).all()
#get all categories of type "services"
services = db_session.query(Category).filter_by(cat_type=2).all()
return render_template("view_categories.html",
goods=goods, services=services)
def load_rss():
# query the db: how long is it? Use this number later to empty db of old stories
exstories = db_session.query(Stories).all()
last_id = exstories[-1].id
sources = {"NPR News": 'http://www.npr.org/rss/rss.php?id=1001', "BBC": 'http://feeds.bbci.co.uk/news/rss.xml'}
for source in sources:
print source
# use feedparser to grab & parse the rss feed
parsed = feedparser.parse(sources[source])
print "parsed"
# go through each entry in the RSS feed to pull out elements for Stories
for i in range(len(parsed.entries)):
title = parsed.entries[i].title
url = parsed.entries[i].link
source = source
# pull abstract, parse out extra crap that is sometimes included
abstract = (parsed.entries[i].description.split('<'))[0]
print abstract
# connect with db
story = db_session.Stories(title=title, url=url, abstract=abstract, source=source)
print "connected with db model??"
# add story to db
db_session.add(story)
print "added story to db"
# commit
db_session.commit()
print "committed"
# delete from db old stories
for l in range(1,last_id+1):
db_session.query(Stories).filter_by(id=l).delete()
db_session.commit()
def editItem(catalog_id, item_id):
"""
Edit an item
"""
catalog = session.query(Catalog).filter_by(id=catalog_id).one_or_none()
editItem = session.query(Item).filter_by(id=item_id).one_or_none()
if catalog is None or item is None:
flash("The catalog and/or item you are looking for does not exist.")
return redirect(url_for('catalog.showAllCatalogs'))
if editItem.user_id != login_session['user_id']:
flash("You are not authorized to edit.")
return redirect(url_for('item.showAllItems', catalog_id=catalog.id))
if editItem != [] and request.method == 'POST':
editItem.name = request.form['editItemName']
editItem.description = request.form['editItemDescription']
session.add(editItem)
session.commit()
flash(editItem.name + " is edited!")
return redirect(url_for('item.showAllItems', catalog_id=catalog_id))
elif editItem != [] and request.method == 'GET':
return render_template(
'items_edit.html',
catalog=catalog,
item=editItem)
def get_trades(user):
"Retrun list of trades the user is in"
sells = session.query(Trade).filter(Trade.seller == user.id).all()
buys = session.query(Trade).filter(Trade.buyer == user.id).all()
return sells, buys
def display_episode_info(series_id, episode_id):
episode = DB.query(Episode).filter_by(id = episode_id).one()
series = DB.query(Series).filter_by(id=series_id).one()
# Determine if current_user has already written a review for the ep
review=DB.query(Review).filter_by(user_id=current_user.id, ep_id=episode_id).first()
if review == None:
review = "empty"
# Find friends' reviews
friends = current_user.friends
friend_reviews=[]
for friend in friends:
friend_review=DB.query(Review).filter_by(ep_id=episode_id, user_id=friend.id).first()
if friend_review != None:
friend_reviews.append(friend_review)
# See if current_user has watched episode. If not, will have a spoiler button in html
watched = DB.query(model.WatchedEpisode).filter_by(user_id=current_user.id, episode_id=episode_id).first()
if watched == None:
watched = False;
else:
watched = True;
return render_template("episode_page.html", episode=episode,
series=series,
review=review,
friend_reviews=friend_reviews,
watched=watched)
def update_watched_episodes():
user_id = int(request.form.get("user_id"))
episode_id = int(request.form.get("episode_id"))
status = request.form.get("status")
print "status", status
if status == "true":
watched_episode = model.WatchedEpisode(user_id=user_id, episode_id=episode_id)
DB.add(watched_episode)
else:
watched_episode = DB.query(model.WatchedEpisode).filter_by(user_id=user_id, episode_id=episode_id).one()
DB.delete(watched_episode)
DB.commit()
series = DB.query(Series).filter(Series.episodes.any(Episode.id == episode_id)).one()
eps_list = DB.query(Episode).filter_by(series_id=series.id).order_by(Episode.season_num).all()
season_dict = {}
watched_ep_ids =[]
watched_count = DB.query(model.WatchedEpisode).\
join(model.WatchedEpisode.episode).\
filter(model.Episode.series_id == series.id).\
filter(model.WatchedEpisode.user_id == user_id).count()
pct = round(100 * float(watched_count)/float(len(eps_list)), 1)
response = {
'success': True,
'completion_percentage': pct,
}
return jsonify(response)
def delete_item():
user = db_session.query(User).get(g.user_id)
item = db_session.query(Item).get(request.args.get("id"))
db_session.delete(item)
db_session.commit()
flash("item deleted", "info")
return redirect(url_for('manage_items'))
def sign_up_form():
## input new user input into database
email = request.form.get("email")
password = request.form.get("password")
username = request.form.get("username")
first_name = request.form.get("first_name")
last_name = request.form.get("last_name")
gender = int(request.form.get("gender"))
age = int(request.form.get("age"))
zipcode = request.form.get("zipcode")
hashed_password = hash_password(password, email)
# create an instance of User with email, password, username, etc. as attributes
user = User(email=email, password=hashed_password, username=username, first_name=first_name,
last_name=last_name, gender=gender, age=age, zipcode=zipcode)
# check for email in db, if not there, add it to db
if dbsession.query(User).filter_by(email = email).first():
flash("This email address is already in use. Please try again.")
return redirect("/sign_up")
else:
dbsession.add(user)
dbsession.commit()
created_user = dbsession.query(User).filter_by(email = email).first()
session["login"] = created_user.id
session["user"] = created_user
return redirect("/pick_genres")
def post_genres():
# get logged in user and user genre picks from pick_genres.html
user_obj = get_current_user()
genre_ids = [int(gi) for gi in request.form.getlist('genres')]
# modifying the collection that we're itering over is no bueno
genres_in_db = dbsession.query(Genre).all()
for g in genres_in_db:
if g in user_obj.genres:
user_obj.genres.remove(g)
try:
print "Committing..\n\n"
dbsession.commit()
except:
print "\n\n\nRolling back uh oh\n\n\n"
dbsession.rollback()
for gi in genre_ids:
genre_obj = dbsession.query(Genre).filter_by(id=gi).first()
user_obj.genres.append(genre_obj)
try:
dbsession.commit()
cache.set(session["user"].id, None, timeout=0)
except:
dbsession.rollback()
return redirect("/wall")
def add_page_pair_to_database(from_page, to_page, limit):
with db_lock:
cou = session.query(Page.id).filter(Page.url == from_page).scalar()
cou1 = session.query(Page.id).filter(Page.url == to_page).scalar()
if cou is None:
new_page_from = Page(url=from_page, text="", rank=0)
session.add(new_page_from)
session.flush()
id0 = new_page_from.id
else:
id0 = cou
if cou1 is None:
allowed = limit < 1 or limit > session.query(Page).count()
if not allowed:
return
new_page_to = Page(url=to_page, text="", rank=0)
session.add(new_page_to)
session.flush()
id1 = new_page_to.id
else:
id1 = cou1
new_relation = Relation(page_id=id0, destination_id=id1)
# print(new_relation.page_id.id)
session.add(new_relation)
session.commit()
def input_match_terms():
"""
This allows the user to enter and edit the match percent and max
salary percent match of their 401k match.
"""
if g.logged_in is True:
# If user selects that they do not have a 401k match, skip
# all 401k match-related questions.
match_401k = m_session.query(model.User).filter_by(
id=g.user.id).first().company_match
if match_401k == "Yes":
if g.inputs is True:
match_percent = m_session.query(model.User).filter_by(
id=g.user.id).first().match_percent
match_salary = m_session.query(model.User).filter_by(
id=g.user.id).first().match_salary
else:
match_percent = match_salary = 0
return render_template(
"input_match_terms.html", match_percent=match_percent,
match_salary=match_salary)
else:
match_percent = match_salary = 0
update_user = m_session.query(model.User).filter_by(
id=g.user.id).update({model.User.match_percent: match_percent,
model.User.match_salary: match_salary})
m_session.commit()
return redirect("/input/risk_tolerance")
else:
return redirect("/login")
def getRecord():
ret = {}
array = []
page_index = request.form.get('page')
page_index = int(page_index)
page_size = 10
persons = session.query(Person).slice((page_index - 1) * page_size,
page_index * page_size)
for person in persons:
info = {}
cno = person.cno
info['cno'] = cno
info['name'] = person.NAME
info['age'] = person.age
info['sex'] = person.sex
home = session.query(Home).filter(Home.cno == cno).first()
info['province'] = home.province
info['address'] = home.address
info['tele'] = home.tele
information = session.query(Information).filter(
Information.cno == cno).first()
info['pnum'] = information.pnum
info['QQ'] = information.QQ
info['wx'] = information.wx
info['email'] = information.email
school = session.query(School).filter(School.cno == cno).first()
info['sno'] = school.sno
info['major'] = school.major
info['grade'] = school.grade
info['sd'] = school.sd
array.append(info)
ret['code'] = 0
ret['data'] = array
return jsonify(ret)
def get(ctx,request:YuHeLg.Request):
post_id = request.vars.id
try:
post = session.query(Post).filter(Post.id==post_id).one()
post.hits +=1
session.add(post)
try:
session.commit()
except:
session.rollback()
#处理tags
pts = session.query(Post_tag).filter(Post_tag.post_id == post_id).limit(10).all()
tags = " ".join([pt.tag.tag for pt in pts])
buryinfo, diginfo = get_digs_or_burys(post_id)
return jsonify(post={
'post_id':post.id,
'title':post.title,
'author':post.author.name,
'postdate':post.postdate.timestamp(),
'content':post.content.content,
'hits':post.hits
},diginfo=diginfo,buryinfo=buryinfo,tags=tags)
except Exception as e:
print(e)
raise exc.HTTPNotFound()
def one_party():
parties = session.query(Party).limit(5).all()
guests = session.query(Guest).limit(5).all()
q = {'parties': [party.as_dict() for party in parties]}, \
{'guests': [guest.as_dict() for guest in guests]}
# print "------------------------\n", q, "\n------------------------"
return q
def view_movie(id):
#id = movie.id
user_id = g.user_id
if g.user_id:
movie = Movie.search_movie(id)
ratings = Rating.search_rating(movie.id, user_id.id)
beratement = None
if ratings == None:
ratings = movie.ratings
rating_nums = []
user_rating =None
for r in ratings:
rating_nums.append(r.rating)
avg_rating = float(sum(rating_nums))/len(rating_nums)
prediction = User.predict_rating(movie.id, user_id.id)
the_eye = db_session.query(User).filter_by(email="*****@*****.**").one()
eye_rating = db_session.query(Rating).filter_by(user_id = the_eye.id, movie_id = id).first()
if not eye_rating:
eye_rating = User.predict_rating(movie.id, the_eye.id)
print eye_rating
else:
eye_rating = eye_rating.rating
if prediction:
difference = abs(eye_rating - prediction)
messages = [ "I suppose you don't have such bad taste after all.",
"I regret every decision that I've ever made that has brought me to listen to your opinion.",
"Words fail me, as your taste in movies has clearly failed you.",
"That movie is great. For a clown to watch. Idiot.",]
beratement = messages[int(difference)]
return render_template("view_movie.html", movie=movie, average=avg_rating, user_rating=user_rating, prediction=prediction, ratings = ratings, beratement=beratement)
else:
return render_template("view_movie.html", movie = movie, ratings=ratings)
return render_template("")
def process_maintain_basic_data(item):
oil_usage = item.get('oil_usage', 0)
brake_oil_usage = item.get('brake_oil_usage', 0)
steering_oil_usage = item.get('steering_oil_usage', 0)
transmission_oil_usage = item.get('transmission_oil_usage', 0)
spark_plug_num = item.get('spark_plug_num', 0)
if oil_usage != 0 or brake_oil_usage != 0 or steering_oil_usage != 0 or transmission_oil_usage != 0 or spark_plug_num != 0:
sohu_type = session.query(SohuType).filter_by(
id=item.get('sohu_vehicle_type_id')).first()
maintain_basic_data = session.query(MaintainBasicData).filter_by(
sohu_vehicle_type_id=item.get('sohu_vehicle_type_id')).first()
if maintain_basic_data is None:
maintain_basic_data = MaintainBasicData()
maintain_basic_data.created_at = datetime.now()
maintain_basic_data.updated_at = datetime.now()
maintain_basic_data.oil_usage = oil_usage
maintain_basic_data.brake_oil_usage = brake_oil_usage
maintain_basic_data.steering_oil_usage = steering_oil_usage
maintain_basic_data.transmission_oil_usage = transmission_oil_usage
maintain_basic_data.spark_plug_num = spark_plug_num
sohu_type.basic_data.append(maintain_basic_data)
session.merge(sohu_type)
def join_carpool(trip, user):
# Creates new TripPassenger object; returns appropriate message.
carpool = db_session.query(model.Trip).filter_by(id=trip).first()
driver = get_user_by_id(carpool.trip_driver)
if user.id == carpool.trip_driver:
return "You cannot join a carpool where you are the driver."
if carpool.seats_available > 0:
carpool_contact = driver.first_name + ", email: " + driver.email
new_passenger = model.TripPassenger(trip_id=trip, passenger_id=user.id)
seats_available = carpool.seats_available - 1
db_session.query(model.Trip).filter_by(id=carpool.id).update({"seats_available": seats_available})
db_session.add(new_passenger)
db_session.commit()
# Sends email to driver, confirming new passenger.
message = (
user.first_name
+ " "
+ user.last_name
+ " (email: "
+ user.email
+ ") has joined your carpool to "
+ carpool.event_name
+ " on "
+ carpool.departure_date
+ "."
)
send_email("inStep carpool addition", driver.email, "*****@*****.**", message)
response = "You have been added to the carpool. The driver is " + carpool_contact
return response
else:
return "That carpool is full."
def load_globalcounts(list_of_wordcounts):
"""
Adds wordcounts for all unique words. There should only be one row per unique word.
"""
# i = 0
for localcount_dict in list_of_wordcounts:
# if i < 5:
for word, count in localcount_dict.iteritems():
item = session.query(GlobalCount).filter(GlobalCount.term == word).first()
if item:
print "%r is already in globalcounts. Updating count..." % word
# update the global count for this word, because we have added new songs with more occurrences of this word
q = session.query(LocalCount.term, func.sum(LocalCount.count))
q = q.group_by(LocalCount.term)
q = q.filter(LocalCount.term == word)
results = q.all()
# print "Current count for %r is %d" % (item.term, item.count)
item.count = results[0][1]
print "Updating %r's count to %d" % (item.term, item.count)
session.commit()
else:
print "%r not in globalcounts table, creating new row" % word
qq = session.query(LocalCount.term, func.sum(LocalCount.count))
qq = qq.group_by(LocalCount.term)
qq = qq.filter(LocalCount.term == word)
resultsresults = qq.all()
countcount = resultsresults[0][1]
new_row = GlobalCount(term = word, count = countcount)
session.add(new_row)
# you must commit before you query the same word/item again!
session.commit()
def calc_percent_change_all(ticker_list, session):
"""
This function calculates the percent change since 4/10/2007 for all
loaded tickers and saves that value to the new_change column in the
database.
All values are being benchmarked against 4/10/2007, which is the latest
inception date for all of the funds for apples-to-apples since-inception
comparison.
"""
ticker_id = 0
for ticker_data in range(len(ticker_list)):
ticker_id = ticker_id + 1
ticker = m_session.query(
model.Price).filter_by(ticker_id=ticker_id).all()
old_close_price = float(
m_session.query(model.Price).filter_by(
date="2007-04-10", ticker_id=ticker_id).first().close_price)
new_index = 0
for daily_ticker_price in ticker:
new_close_price = float(ticker[new_index].close_price)
difference = round(
(new_close_price - old_close_price) / old_close_price, 4)
ticker[new_index].percent_change = difference
new_index = new_index + 1
session.commit()
def add_page_pair_to_database(from_page, to_page, limit):
with db_lock:
cou = session.query(Page.id).filter(Page.url == from_page).scalar()
cou1 = session.query(Page.id).filter(Page.url == to_page).scalar()
if cou is None:
new_page_from = Page(url=from_page, text="", rank=0)
session.add(new_page_from)
session.flush()
id0 = new_page_from.id
else:
id0 = cou
if cou1 is None:
allowed = limit < 1 or limit > session.query(Page).count()
if not allowed:
return
new_page_to = Page(url=to_page, text="", rank=0)
session.add(new_page_to)
session.flush()
id1 = new_page_to.id
else:
id1 = cou1
new_relation = Relation(page_id = id0, destination_id = id1)
# print(new_relation.page_id.id)
session.add(new_relation)
session.commit()
def ranking(search):
try:
stores = session.query(Store).filter(Store.name.like('%' + search + '%')
).order_by(Store.average_score.desc()).all()
for index, store in enumerate(stores):
store_info = session.query(Store).filter(Store.id == store.id).first()
store_info.ranking = index + 1
session.commit()
if stores:
response = [{
"id": store.id,
"ranking": store.ranking,
"name": store.name,
"description": store.description,
"average_score": store.average_score,
"average_price": store.average_price,
"picture": os.getenv('BASE_URL') + store.picture
}for index, store in enumerate(stores)]
return response
else:
abort(400, "none data")
except SQLAlchemyError:
session.rollback()
abort(500, "database error")
def save_assets():
"""
Pulls assets from user input (as a post request), save to
database, and routes to next question (/results will perform
the calculations).
"""
form = AssetsForm(request.form)
if form.validate_on_submit():
assets = float(request.form["assets"])
# Checks that user's assets are getting updated each time they change
# their input, and not getting added to the database.
user_assets = m_session.query(model.UserBanking).filter_by(
user_id=g.user.id).first()
if user_assets is not None:
update_assets = m_session.query(model.UserBanking).filter_by(
user_id=g.user.id).update(
{model.UserBanking.inputted_assets: assets})
else:
new_account = model.UserBanking(
user_id=g.user.id, inputted_assets=assets, checking_amt=0,
savings_amt=0, IRA_amt=0, comp401k_amt=0, investment_amt=0)
m_session.add(new_account)
m_session.commit()
return redirect("/input/income")
else:
flash("Please enter an integer. No commas or symbols.")
return redirect("/input/assets")
def addlocation():
if request.method == 'POST':
#.get using the key photo_id to get the value which is the photo_id
photo_id = session.get('photo_id')
city = request.form['city']
goo = geocoders.GoogleV3()
geocodes = goo.geocode(city, exactly_one=False)
l2 = str(geocodes)
latitude = lat2(l2)
longitude = lon2(l2)
# query by photo_id and update latlng
db_session.query(Photo).filter_by(id=photo_id).update({
"latitude":
latitude,
"longitude":
longitude
})
db_session.commit()
db_session.flush()
del session['photo_id']
return redirect(url_for('userpage'))
return render_template("upload2.html")
def calc_percent_change_all(ticker_list, session):
"""
This function calculates the percent change since 4/10/2007 for all
loaded tickers and saves that value to the new_change column in the
database.
All values are being benchmarked against 4/10/2007, which is the latest
inception date for all of the funds for apples-to-apples since-inception
comparison.
"""
ticker_id = 0
for ticker_data in range(len(ticker_list)):
ticker_id = ticker_id + 1
ticker = m_session.query(model.Price).filter_by(
ticker_id=ticker_id).all()
old_close_price = float(m_session.query(model.Price).filter_by(
date="2007-04-10",
ticker_id=ticker_id).first().close_price)
new_index = 0
for daily_ticker_price in ticker:
new_close_price = float(ticker[new_index].close_price)
difference = round((new_close_price - old_close_price) /
old_close_price, 4)
ticker[new_index].percent_change = difference
new_index = new_index + 1
session.commit()
def del_client():
log.info('Controle del_clients starts')
if request.method == 'POST':
# si la méthode du formaulaire est post on interroge la table Client avec comme contrainte le prénom et le nom de l'utilisateur
client_account = db.query(Client).filter_by(
firstname=request.form['firstname']).filter_by(
lastname=request.form['lastname']
) #.filter_by(email=request.form['email'])
#ensuite on récupère sous forme tuples la ligne du client
client = db.execute(client_account).fetchone()
#si le client n'existe pas on redirige l'utilisateur sur un page d'erreur
if client is None:
return render_template('redirectory_delete_client.html')
else:
#si il existe on récupère on id en interrogeant la table Client on récupère son id à l'indcice 0
client_id = db.query(Client).get(client[0])
#ensuite on interroge la table Bankaccount possédant tous les ocmptes bancaires du client à l'aide de l'id du client,
# ensuite on supprime le client de la table Bankaccount
db.query(BankAccount).filter_by(
client_id=client_id.client_id).delete()
# enusite on supprime l'id du client existant dans la table Client, il n'y a plus de trace de lui
db.delete(client_id)
db.commit()
return redirect(url_for('home_admin'))
else:
return render_template('delete_client.html')
def movie_profile():
user = get_current_user()
id = request.args.get("id")
if not id:
return redirect("/wall")
movie_info = dbsession.query(Media).options(joinedload('genres')).get(id)
if not movie_info:
# movie wasn't found
flash("This movie does not exist. Please try again.")
return redirect("/wall")
# FIXME: fix this workaround for utf-8 decoding weirdness in flask/jinja
if movie_info.director:
movie_info.director = movie_info.director.decode('utf-8', 'ignore')
if movie_info.actors:
movie_info.actors = movie_info.actors.decode('utf-8', 'ignore')
if movie_info.plot:
movie_info.plot = movie_info.plot.decode('utf-8', 'ignore')
ratings = dbsession.query(Rating).filter(Rating.rating !=0).options(joinedload('user')).filter_by(movie_id = id).all()
avg_rating = average_rating(ratings)
# get rating of currently logged in user
current_user_rating = None
for rating in ratings:
if rating.user == user:
current_user_rating = rating
break
return render_template("movie_prof.html", movie=movie_info, ratings=ratings, avg_rating = avg_rating, user=user, current_user_rating = current_user_rating)
def show_random_user_ratings():
"""return a list of movies and ratings given by this user"""
our_range = dbsesh.query(model.User.id).all()
# print our_range
clean_list =[]
for i in range(len(our_range)):
clean_list.append(our_range[i][0])
# print clean_list
users_to_show = []
for i in range(10):
random_user = random.choice(clean_list)
users_to_show.append(random_user)
user_objects = []
for uid in users_to_show:
user_object = dbsesh.query(model.User).get(uid)
user_objects.append(user_object)
print len(user_objects)
return (user_objects)
def del_account_client(token):
log.info('Controle del_account_client starts')
client_id = get_client_using_Token(token)
if request.method == 'POST':
enter_number = request.form['number']
req = db.query(BankAccount).filter_by(number=enter_number)
account = db.execute(req).fetchone()
print("this account client", account)
if account is None:
return render_template('redirectory_to_delete_account_client.html',
number=enter_number)
if client_id != account[2] or account is None:
return render_template('redirectory_to_delete_account_client.html',
number=enter_number)
if client_id == account[2]:
db.query(SavingAccount).filter_by(
number=request.form['number']).delete()
#print(req)
db.commit()
return redirect(
url_for('client_file', token=token)
) # dans le url_for (qui est une fonction) le 'client file' ici est un end point d'une url définiit dans le main et qui va appeler le reste de l'url au moment de l'éxécution de la fonction, et qui va injecter la donneé contenu de "client_id" à l'emplcement correspondant dans l'url du main
else:
return render_template('delete_account_client.html', token=token)
def input_match_401k():
"""
This allows the user to enter and edit if their company has a 401k
match.
"""
if g.logged_in is True:
# If user selects that they do not have a company 401k, skip
# all 401k-related questions.
comp_401k = m_session.query(model.User).filter_by(
id=g.user.id).first().company_401k
if comp_401k == "Yes":
if g.inputs is True:
match_401k = m_session.query(model.User).filter_by(
id=g.user.id).first().company_match
else:
match_401k = 0
return render_template(
"input_match_401k.html", match_401k=match_401k)
else:
match_401k = "No"
match_percent = match_salary = 0
update_user = m_session.query(model.User).filter_by(
id=g.user.id).update({model.User.company_match: match_401k,
model.User.match_percent: match_percent,
model.User.match_salary: match_salary})
m_session.commit()
return redirect("/input/risk_tolerance")
else:
return redirect("/login")
def process_maintenance_information(item):
sohu_type = session.query(SohuType).filter_by(
id=item.get('sohu_vehicle_type_id')).first()
maintenance_information = session.query(
SohuMaintenanceInformation).filter_by(
sohu_vehicle_type_id=item.get('sohu_vehicle_type_id')).filter_by(
mileage=item.get('mileage')).first()
if maintenance_information is None:
maintenance_information = SohuMaintenanceInformation()
maintenance_information.created_at = datetime.now()
maintenance_information.updated_at = datetime.now()
maintenance_information.mileage = item.get('mileage', '')
maintenance_information.oil = item.get('oil', 0)
maintenance_information.oil_filter = item.get('oil_filter', 0)
maintenance_information.air_filter = item.get('air_filter', 0)
maintenance_information.cabin_filter = item.get('cabin_filter', 0)
maintenance_information.fuel_filter = item.get('fuel_filter', 0)
maintenance_information.brake_oil = item.get('brake_oil', 0)
maintenance_information.transmission_oil = item.get(
'transmission_oil', 0)
maintenance_information.steering_oil = item.get('steering_oil', 0)
maintenance_information.spark_plug = item.get('spark_plug', 0)
maintenance_information.timing_belt = item.get('timing_belt', 0)
maintenance_information.reference_price = item.get(
'reference_price', '')
maintenance_information.mounth = item.get('mounth', '')
sohu_type.sohu_maintenance_informations.append(maintenance_information)
session.merge(sohu_type)
def view_movie(id):
#get is a function for a Query object
movie = db_session.query(Movie).get(id)
rating_objs = movie.ratings
rating_values = []
user_rating = None #user_rating will become user_rating object
for r in rating_objs:
if r.user_id == g.user_id:
user_rating = r
# getting the whole rating object for the user's rating (will find out why later)
rating_values.append(r.rating)
# you want to make as few calls to the database as possible
average_rating = float(sum(rating_values)/len(rating_values))
# Prediction code: only predict if the user hasn't rated it.
user = db_session.query(User).get(g.user_id)
prediction = None
if not user_rating:
prediction = user.predict_rating(movie)
# End prediction
return render_template("movie.html", movie=movie,
average=average_rating, user_rating=user_rating,
prediction=prediction)
return render_template("movie.html", movie=movie, average=average_rating, user_rating=user_rating, prediction=prediction)
def access_bank():
"""
Allows login to banking institutions using Intuit API and
Python library aggcat. Calls functions in accounts.py.
Assumes that all account assets will be checking accounts.
"""
form = BankLoginForm(request.form)
if form.validate_on_submit():
institution = str(request.form["institution"])
username = request.form["user_name"]
password = request.form["user_password"]
user_fields = accounts.get_credential_fields(
accounts.create_client(), institution)
credentials = {}
credentials[user_fields["username"]] = username
credentials[user_fields["password"]] = password
try:
account = accounts.discover_add_account(
accounts.create_client(), institution, credentials)
account_data = account.content
# Checks the HTTP error code if account needs further
# authentication
if account.status_code in [200, 201]:
checking_balance = account_data.balance_amount
# Checks that user's assets are getting updated each time
# they change their input, and not getting added to the
# database.
user_assets = m_session.query(model.UserBanking).filter_by(
user_id=g.user.id).first()
if user_assets is not None:
update_assets = m_session.query(
model.UserBanking).filter_by(user_id=g.user.id).update(
{model.UserBanking.checking_amt: checking_balance})
else:
new_account = model.UserBanking(
user_id=g.user.id, inputted_assets=0,
checking_amt=checking_balance, savings_amt=0,
IRA_amt=0, comp401k_amt=0, investment_amt=0)
m_session.add(new_account)
m_session.commit()
flash("%s account XXXX%s with $%s has been added to your \
assets." % (account_data.account_nickname,
account_data.account_number[-4:],
account_data.balance_amount))
return redirect("/input/assets")
else:
return redirect("/banklogin/challenge")
except:
flash("There was an error accessing your account. Please try \
again.")
return redirect("/banklogin")
else:
flash("Please enter a valid email and password.")
return redirect("/banklogin")
def update_event(event_info):
# Given info to update, updates Event record.
parameters = process_parameters(event_info)
for key, value in parameters.iteritems():
db_session.query(model.Event).filter_by(name=event_info["name"]).update({key: value})
db_session.commit()
return "Event updated."
def save_location(data):
"""Receives a data object with location_id and latlong properties,
and updates the latlong value in the db for that location id."""
location_id = data['id']
latitude = data['latitude']
longitude = data['longitude']
db_session.query(Location).filter_by(id=location_id).update({"latitude": latitude, "longitude": longitude})
db_session.commit()
def update_account(update_info, user_id):
# Given info to update, updates User record.
parameters = process_parameters(update_info)
for key, value in parameters.iteritems():
db_session.query(model.User).filter_by(id=user_id).update({key: value})
db_session.commit()
return "Your account has been updated."
def display_rating_form(movie_id):
user_id = session['id']
user_object = model_session.query(model.User).filter_by(user_id=user_id).first()
movie_object = model_session.query(model.Movie).filter_by(movie_id=movie_id).first()
prediction = user_object.predict_rating(movie_object)
existing_rating_object = model_session.query(model.Rating).filter_by(user_id=user_id, movie_id=movie_object.movie_id).first()
return render_template("rate_movie.html", movie_object=movie_object, prediction=prediction, user_object=user_object, existing_rating_object=existing_rating_object)
def my_profile():
# fetch user_id from the session dictionary of logged-in user
user_id = session["login"]
# query Rating object filtering on user_id column and user_id stored in the "login" session
ratings = dbsession.query(Rating).filter_by(user_id = user_id).all()
# query User object, joining in follows association table
user = dbsession.query(User).options(joinedload('follows')).filter_by(id=user_id).first()
return render_template("my_profile.html", user=user, ratings=ratings)
def updateRecord():
name = request.form.get('name')
age = int(request.form.get('age'))
old_cno = int(request.form.get('old_cno'))
new_cno = int(request.form.get('new_cno'))
sex = request.form.get('sex')
sno = request.form.get('sno')
major = request.form.get('major')
grade = request.form.get('grade')
sd = request.form.get('sd')
province = request.form.get('province')
address = request.form.get('address')
tele = request.form.get('tele')
pnum = request.form.get('pnum')
QQ = request.form.get('QQ')
wx = request.form.get('wx')
email = request.form.get('email')
home = session.query(Home).filter(Home.cno == old_cno).first()
home.province = province
home.address = address
home.tele = tele
session.commit()
information = session.query(Information).filter(
Information.cno == old_cno).first()
information.pnum = pnum
information.QQ = QQ
information.wx = wx
information.email = email
session.commit()
school = session.query(School).filter(School.cno == old_cno).first()
school.sno = sno
school.major = major
school.grade = grade
school.sd = sd
session.commit()
person = session.query(Person).filter(Person.cno == old_cno).first()
person.cno = new_cno
person.NAME = name
person.age = age
person.sex = sex
code = 0
msg = ''
try:
session.commit()
except:
code = 100
msg = '修改失败'
session.rollback()
else:
code = 0
msg = '修改成功'
ret = {'code': code, 'msg': msg}
return jsonify(ret)
def user_movies(user_id):
user_object = model_session.query(model.User).filter_by(user_id=user_id).first()
all_movies = model_session.query(model.Movie).all()
rated_movies = {}
for rating_object in user_object.ratings:
rated_movies[rating_object.movie_id] = rating_object.rating
return render_template("movie_library.html", rated_movies=rated_movies, all_movies=all_movies, user_object=user_object)
def calc_percent_change_compare(compare_ticker, session):
"""
This function calculates the percent change since inception for only
the comparison ticker and saves that value to the new_change column
in the database.
All values are being benchmarked against 4/10/2007, which is the latest
inception date for all of the funds for apples-to-apples since-inception
comparison. EXCEPTION: if the comparison ticker has an inception date
after 4/10/2007, I am using the inception date. Comparison validity
is no longer applicable, but it at least allows the user to see the data.
"""
beginning = time.time()
compare_ticker = model.session.query(
model.Ticker).filter_by(symbol=compare_ticker).first()
ticker = compare_ticker.price
# This methodology needs improvement- some stocks have an inception
# date after 4/10/2007, so I created blank lines of data to be
# added to the database for the difference in days between 4/10/2007
# and the stock's inception date. I could not increment through dates,
# because the API data does not include weekends. Therefore, I am
# modelling the dates after ticker_id 1.
standard_date = datetime.strptime("2007-04-10", "%Y-%m-%d").date()
old_date = ticker[-1].date
find_old_date_id = m_session.query(model.Price).filter_by(
date=old_date, ticker_id=1).first().id
find_standard_date_id = m_session.query(model.Price).filter_by(
date=standard_date, ticker_id=1).first().id
number_of_blanks = find_standard_date_id - find_old_date_id
incrementing_date = 0
while incrementing_date < number_of_blanks:
incrementing_date = incrementing_date + 1
dummy_id = find_old_date_id + incrementing_date
find_dummy_date = m_session.query(
model.Price).filter_by(id=dummy_id).first().date
add_dummy_price = model.Price(ticker_id=compare_ticker.id,
date=find_dummy_date,
close_price=0)
session.add(add_dummy_price)
session.commit()
new_index = 0
old_close_price = float(
m_session.query(model.Price).filter_by(
date=ticker[-1].date,
ticker_id=compare_ticker.id).first().close_price)
old_date = ticker[-1].date
while ticker[new_index].date > old_date:
new_close_price = float(ticker[new_index].close_price)
difference = round(
(new_close_price - old_close_price) / old_close_price, 4)
ticker[new_index].percent_change = difference
new_index = new_index + 1
session.commit()
def perform(user_id):
# frab range of current queue ids for user
exist_q = db_session.query(Queue).filter_by(user_id=user_id).all()
exist = []
for s in exist_q:
exist.append(s.id)
print exist
stories = db_session.query(Stories).all()
queued = []
for item in stories:
# determine probability that the user will like this item
try:
doc = Classifier.gettext(item.url) # strong of article words
cl = FisherClassifier(Classifier.getwords, user_id) # returns instance
cl.setdb('news.db')
# classification = 'yes'
probability = cl.fisherprob(doc, 'yes')
if probability > 0:
# add item's probability to the queue dictionary
tup = (item.id, probability)
queued.append(tup)
except Exception:
pass
#sort queue by probability, lowest-->highest
queue = sorted(queued, key=lambda x:x[1])
print queue
# grab top and low rated stories, add to Queue
if len(queue)>=10:
for i in queue[-8:]:
story_id = i[0]
score = i[1]
# add story, user, and probability to db for pulling articles
story = Queue(story_id=story_id, score=score, user_id=user_id)
db_session.add(story)
for i in queue[:2]:
story_id = i[0]
score = i[1]
# add story, user, and probability to db for pulling articles
story = Queue(story_id=story_id, score=score, user_id=user_id)
db_session.add(story)
db_session.commit()
else:
for i in queue:
story_id = i[0]
score = i[1]
# add story, user, and probability to db for pulling articles
story = Queue(story_id=story_id, score=score, user_id=user_id)
db_session.add(story)
db_session.commit()
# clear old stories out of Queue now that new ones are in there
for i in exist:
d = db_session.query(Queue).filter_by(id=i).first()
db_session.delete(d)
db_session.commit()
def pages_(num = 1):
form = CrawlerFormProcessor(request.forms.decode())
global pages_limit
pages_to_display = pages_limit
current_page = int(num)
pages = session.query(Page).order_by(Page.rank.desc(), Page.url).offset(pages_to_display*(current_page-1)).limit(pages_to_display).all()
total_pages = session.query(Page).count()
return locals()
def vote():
allphotos = db_session.query(Photo).all()
sql = """select distinct v.photo_id
from votes v where v.give_vote_user_id = %s and v.value > 0;""" % (
g.user_id)
upvotes = [vote[0] for vote in db_session.execute(sql)]
print upvotes
sql = """select distinct v.photo_id
from votes v where v.give_vote_user_id = %s and v.value < 0;""" % (
g.user_id)
downvotes = [vote[0] for vote in db_session.execute(sql)]
if request.form:
vote = request.form['vote']
photoid = request.form['photoid']
photoowner = request.form['photoowner']
v = db_session.query(Vote).filter_by(give_vote_user_id=g.user_id,
photo_id=photoid).first()
if not v:
v = Vote(give_vote_user_id=g.user_id,
photo_id=photoid,
receive_vote_user_id=photoowner)
db_session.add(v)
p = db_session.query(Photo).filter_by(id=photoid).one()
if vote == "upvote":
v.value = 1
p.up_vote = Photo.up_vote + 1
elif vote == "downvote":
v.value = -1
p.down_vote = Photo.down_vote + 1
db_session.commit()
sql = """select distinct v.photo_id
from votes v where v.give_vote_user_id = %s and v.value > 0;""" % (
g.user_id)
upvotes = [vote[0] for vote in db_session.execute(sql)]
sql = """select distinct v.photo_id
from votes v where v.give_vote_user_id = %s and v.value < 0;""" % (
g.user_id)
downvotes = [vote[0] for vote in db_session.execute(sql)]
return render_template("_vote.html",
u=g.user,
photos=allphotos,
upvotes=upvotes,
downvotes=downvotes)
return render_template("vote.html",
u=g.user,
photos=allphotos,
upvotes=upvotes,
downvotes=downvotes)
def display_user(username):
username = session.get('username')
if username != None:
try:
user_id = model_session.query(model.User).filter_by(username=username).first().id
clouds = model_session.query(model.User).filter_by(id=user_id).first().clouds
return render_template('display_user.html', username=username, user_id=user_id, clouds=clouds)
except:
return redirect(url_for('login'))
return redirect(url_for('index'))
def pages_(num=1):
form = CrawlerFormProcessor(request.forms.decode())
global pages_limit
pages_to_display = pages_limit
current_page = int(num)
pages = session.query(Page).order_by(Page.rank.desc(), Page.url).offset(
pages_to_display * (current_page - 1)).limit(pages_to_display).all()
total_pages = session.query(Page).count()
return locals()
def wrapper(catalog_id, item_id):
catalog = session.query(
exists().where(Catalog.id == catalog_id)).scalar()
item = session.query(exists().where(Item.id == item_id)).scalar()
if catalog is False or item is False:
flash(
"The catalog and/or item you are looking for does not exist!")
return redirect(url_for('catalog.showAllCatalogs'))
else:
return func(catalog_id, item_id)
def display_items(cat_id):
#get all items for a category by cat_id
items = db_session.query(Item).filter_by(cat_id=cat_id).filter(Item.user_id != g.user.id).all()
cat = db_session.query(Category).filter_by(id=cat_id).one()
# get category to display its name
if not items:
flash("Sorry, no items are available to trade in that category", "error")
return redirect(url_for("view_categories"))
return render_template(
"display_items.html", items=items, search_term=cat.name, title="All Items in ")
