def create_new_account():
if request.method == 'GET':
if 'username' in session:
return render_template('create_account_logged.html')
return render_template('create_account.html')
else:
username = request.form['username']
password = request.form['password']
model.Account(username)
new_user = model.Account(username)
print(new_user)
if new_user.check_set_username():
flash('User Already Exists')
return redirect('/create_account')
if len(password) < 8:
flash('Please enter a password that is at least 8 characters')
return redirect('/create_account')
if re.search('[0-9]', password) is None:
flash('Please enter a password that has at least one digit')
return redirect('/create_account')
if re.search('[A-Z]', password) is None:
print('pass char')
flash(
'Please enter a password that with at least one capital letter'
)
return redirect('/create_account')
print('no issues')
hashed_pw = new_user.calculatehash(password)
print(hashed_pw)
new_user.pass_hash = hashed_pw
new_user.balance = 0
new_user.type = "USER"
new_user.save()
flash('User Account Successfully Created')
return redirect('/login')
def run():
while True:
selection = view.show_mainmenu() #gets input from mainmenu in view
if selection == '1':
account = model.Account() #creates object from class account
account.create_account() #calls create account function on object
elif selection == '2':
accountlogin = model.Account()
accountlogin.login_menu()
elif selection == '3':
exit(1)
def get(self):
args = dict(
client_id=FACEBOOK_APP_ID,
redirect_uri="http://www.epubhost.com/auth/facebook/callback")
args["client_secret"] = FACEBOOK_SECRET
args["code"] = self.request.get("code")
response = cgi.parse_qs(
urllib.urlopen("https://graph.facebook.com/oauth/access_token?" +
urllib.urlencode(args)).read())
access_token = response["access_token"][-1]
session = get_current_session()
me = urllib.urlopen("https://graph.facebook.com/me?access_token=" +
access_token).read()
fbData = json.loads(me)
fbUID = fbData["id"]
account = db.GqlQuery("SELECT * FROM Account WHERE facebookUID = :1",
fbUID).get()
if account is None:
account_key = session.get("account")
account = None if account_key is None else db.get(account_key)
if account is None:
account = model.Account()
account.facebookToken = access_token
account.facebookUID = fbUID
try:
account.facebookInfo = json.dumps(fbData)
account.facebookInterests = urllib.urlopen(
"https://graph.facebook.com/me/interests?access_token=" +
access_token).read()
except Exception, ex:
logging.info("Couldn't get/save FB data due to %s" % ex)
def sell_stock():
if request.method == "GET":
return render_template('authorized/sellstock.html')
elif request.method == "POST":
user = model.Account()
user.set_from_pk(session["Active User"])
ticker = model.ticker_cap(request.form["ticker"])
price = model.apiget(ticker)
if not price:
return render_template('authorized/sellstock.html',
message="Stock doesn't exist")
if not user.stock_ownership_check(ticker):
return render_template('authorized/sellstock.html',
message="Stock not owned")
volume = request.form["volume"]
try:
volume = int(volume)
if volume <= 0:
return render_template(
'authorized/sellstock.html',
message="Invalid input, must be positive integer")
except ValueError:
return render_template(
'authorized/sellstock.html',
message="Invalid input, must be positive integer")
if not model.zero_check(volume):
return render_template(
'authorized/sellstock.html',
message="Invalid input, must be positive integer")
if not user.sufficient_amount_check(ticker, volume):
return render_template('authorized/sellstock.html',
message="Insufficient amount owned")
user.sell(ticker, volume, price=price)
return redirect(url_for('trade_success'))
def add_funds():
user = model.Account()
user.set_from_pk(session["Active User"])
if request.method == "GET":
return render_template('authorized/addfunds.html')
elif request.method == "POST":
cardnumber = request.form["cardnumber"]
if not cardnumber.isdigit():
return render_template('authorized/addfunds.html',
message="Invalid credit card")
if not model.luhn_check(cardnumber):
return render_template('authorized/addfunds.html',
message="Invalid credit card")
amount = request.form["amount"]
if amount[0] == "$":
amount == amount[1:]
try:
amount = float(amount)
if amount < 0.01:
return render_template(
'authorized/addfunds.html',
message="Invalid input, must be a positive number")
except ValueError:
return render_template(
'authorized/addfunds.html',
message="Invalid input, must be a positive number")
user.increase_balance(amount)
return redirect(url_for('deposit_success'))
async def post(self):
form_data, errors, valid_data = self.validate()
# extra validation to make sure the username isn't already in use at creation time
if not errors:
# FUTURE: keep an un-lowered copy of this for potential display?
valid_data["email"] = valid_data["email"].lower()
user = model.Account.getByEmail(valid_data["email"])
if user:
errors["exists"] = True
if errors:
if "password" in form_data:
del form_data[
"password"] # never send password back for security
self.redisplay(form_data, errors)
else:
password_salt, hashed_password = model.Account.changePassword(
valid_data["password"])
del valid_data["password"]
user = model.Account(password_salt=password_salt,
hashed_password=hashed_password,
**valid_data)
user.save()
self.login(user, new=True)
def admin_account_update(account_id=0):
if account_id:
account_db = model.Account.get_by_id(account_id)
else:
account_db = model.Account()
if not account_db:
flask.abort(404)
form = AccountUpdateAdminForm(obj=account_db)
if form.validate_on_submit():
form.populate_obj(account_db)
account_db.put()
return flask.redirect(
flask.url_for('admin_account_list', order='-modified'))
return flask.render_template(
'account/admin_account_update.html',
title=account_db.username if account_id else 'New Account',
html_class='admin-account-update',
form=form,
account_db=account_db,
back_url_for='admin_account_list',
api_url=flask.url_for(
'api.admin.account',
account_key=account_db.key.urlsafe() if account_db.key else ''),
)
def create_account():
view.create_account_username()
username = input()
new_user = model.Account(username)
while new_user.check_set_username():
view.already_exists()
return login_terminal()
pass_prompt(new_user)
def testAccount(self):
act = model.Account(username="******", pass_hash="xxxx", balance=0.0)
act.save()
with model.OpenCursor() as cur:
SQL = "SELECT * FROM accounts WHERE username='******';"
cur.execute(SQL)
row = cur.fetchone()
self.assertEqual(row["balance"], 0.0, "Account.save() works")
with model.OpenCursor() as cur:
SQL = "SELECT * FROM accounts WHERE pk=1;"
cur.execute(SQL)
carter = model.Account().set_from_row(cur.fetchone())
self.assertEqual(carter.balance, 10000.0,
"Account set from database row")
carter2 = model.Account().set_from_pk(1)
self.assertEqual(carter2.username, "carter", "Account set_from_pk")
positions = carter2.getpositions()
self.assertEqual(
len(positions), 2,
"Account getpositions returns list of correct length")
self.assertEqual(
type(positions[0]), model.Position,
"Account getpositions returns list with Positions objects")
self.assertEqual(positions[0].amount, 10,
"getpositions populates Positions with data")
position = carter2.getposition("AAPL")
self.assertEqual(type(position), model.Position,
"Account getpositions returns Position object")
self.assertEqual(position.amount, 10, "Position populated with data")
noposition = carter2.getposition("F")
self.assertEqual(noposition, None,
"getposition returns None for non-position.")
trades = carter2.gettradesfor("AAPL")
self.assertEqual(len(trades), 1, "gettradesfor returns list")
self.assertEqual(type(trades[0]), model.Trade,
"gettradesfor list is Trades objects")
notrades = carter2.gettradesfor("F")
self.assertEqual(
notrades, [],
"gettradesfor returns empty list for non-traded symbol")
def see_trades():
user = model.Account()
user.set_from_pk(session["Active User"])
alltrades = user.gettrades()
trades = {}
trades["tickers"] = [i.ticker for i in alltrades]
trades["prices"] = ['${:,.2f}'.format(i.price) for i in alltrades]
trades["volumes"] = [i.volume for i in alltrades]
trades["values"] = [
'${:,.2f}'.format((i.price * i.volume)) for i in alltrades
]
trades["times"] = [
str(datetime.fromtimestamp(i.time, local_timezone))[0:-6]
for i in alltrades
]
length = range(0, len(trades["tickers"]))
if request.method == "GET":
if not alltrades:
return render_template(
'authorized/seetrades.html',
message="No trade history. Try buying some stock!")
return render_template('authorized/seetrades.html',
trades=trades,
length=length)
if request.method == "POST":
ticker = request.form["ticker"]
if not model.apiget(ticker):
return render_template('authorized/seetrades.html',
trades=trades,
length=length,
message="Stock doesn't exist")
if not user.gettradesfor(ticker):
return render_template('authorized/seetrades.html',
trades=trades,
length=length,
message="No trades exist for that stock")
alltrades = user.gettradesfor_html(ticker)
trades = {}
trades["tickers"] = [i.ticker for i in alltrades]
trades["prices"] = ['${:,.2f}'.format(i.price) for i in alltrades]
trades["volumes"] = [i.volume for i in alltrades]
trades["values"] = [
'${:,.2f}'.format((i.price * i.volume)) for i in alltrades
]
trades["times"] = [
str(datetime.fromtimestamp(i.time, local_timezone))[0:-6]
for i in alltrades
]
length = range(0, len(trades["tickers"]))
return render_template("authorized/seetrades.html",
trades=trades,
length=length)
def login():
if request.method == "GET":
return render_template('unauthorized/login.html')
elif request.method == "POST":
user = model.Account()
username = request.form["username"]
password = model.calculate_hash(request.form["password"])
if not user.set_from_credentials(username=username, password=password):
return render_template('unauthorized/login.html',
message="Incorrect username or password")
user.set_from_credentials(username=username, password=password)
session["Active User"] = user.pk
return redirect(url_for('show_dashboard'))
def start():
selection = 0
while selection != 3:
selection = v.mainmenu()
if selection == 1: # Create account
pin, first, last = v.create_account()
newaccount = m.Account()
newaccount.create_account(pin, first, last)
v.create_acc_success(newaccount.account_num)
start()
if selection == 2: #Log in
account_num, pin = v.login()
account_num = str(account_num)
account = m.Account(account_num)
account_details = account.login(account_num, pin)
if account != None:
option = 0
while option != 4:
option = v.account_options(account_details)
if option == 1: # Show Balance
v.show_balance(account.balance)
elif option == 2:# Withdraw Funds
amount = v.withdraw_funds()
if account.withdraw(amount) == False:
v.insufficient_funds
else:
v.withdraw_message(amount)
v.show_balance(account.balance)
elif option == 3:# Deposit Funds
amount = v.deposit_funds()
account.deposit(amount)
v.show_balance(account.balance)
start() # Back to create/login menu
def login():
view.login()
login_id = input().lower()
new_login = model.Account(login_id)
while not new_login.check_set_username():
view.does_not_exist()
return login_terminal()
new_login = new_login.set_from_username()
view.enter_password()
password = getpass.getpass()
while not new_login.check_password((new_login.pass_hash), password):
view.invalid_password()
view.enter_password()
password = getpass.getpass()
login_menu(new_login)
def createaccount():
if request.method == "GET":
return render_template('unauthorized/createaccount.html')
elif request.method == "POST":
user = model.Account()
username = request.form["username"]
if not user.username_exists_check(username):
return render_template('unauthorized/createaccount.html',
message="Username already exists")
password = request.form["password"]
if not model.password_check(password):
return render_template(
'unauthorized/createaccount.html',
message=
"Password must be 8 characters long and include 1 number")
password2 = request.form["password2"]
if password2 != password:
return render_template('/unauthorized/createaccount.html',
message="Passwords don't match. Try again")
user = model.Account(username=username,
pass_hash=model.calculate_hash(password))
user.save()
return render_template('unauthorized/login.html',
success_message="Account created!")
def trade_success():
user = model.Account()
user.set_from_pk(session["Active User"])
trade = user.getlasttrade()
ticker = trade.ticker
position = user.getposition(ticker=ticker)
if not position:
return render_template('authorized/tradesuccess.html',
message="Position closed out")
return render_template(
'authorized/tradesuccess.html',
ticker=ticker,
price='${:,.2f}'.format(abs(trade.price * trade.volume)),
amount=position.amount,
value='${:,.2f}'.format(trade.price * position.amount),
time=str(datetime.fromtimestamp(trade.time, local_timezone))[0:-6])
class TwitterCallback(webapp2.RequestHandler):
def get(self):
verifier = self.request.get('oauth_verifier')
auth = tweepy.OAuthHandler(model.TWITTER_CONSUMER_KEY,
model.TWITTER_CONSUMER_SECRET,
secure=True)
session = get_current_session()
request_key = session.get("rt_key_")
request_secret = session.get("rt_secret_")
if request_key is None or request_secret is None:
self.response.out.write(
'Error! Failed to retain account/handle or request key/secret.'
)
return
auth.set_request_token(request_key, request_secret)
try:
auth.get_access_token(verifier)
except tweepy.TweepError, ex:
logging.warn("Tweep Error %s" % ex)
self.response.out.write('Error! Failed to get access token.')
return
auth.set_access_token(auth.access_token.key, auth.access_token.secret)
twitter = tweepy.API(auth)
twitter_handle = twitter.auth.get_username()
account = model.Account.query(
model.Account.twitter_handle == twitter_handle).get()
if account is None:
account = model.Account()
account.twitter_handle = twitter_handle
account.status = model.STATUS_CREATED
account.twitter_key = auth.access_token.key
account.twitter_secret = auth.access_token.secret
account.last_login = model.now()
account.put()
session["account"] = account.key.urlsafe()
tempkey = ''.join(random.SystemRandom().choice(string.ascii_uppercase +
string.digits)
for _ in range(20))
memcache.set(tempkey, account.key.urlsafe(), 60)
self.redirect("http://www.MYSITE.com/me?v=%s" % tempkey)
def get(self):
session = get_current_session()
user = users.get_current_user()
if user:
account = db.GqlQuery(
"SELECT * FROM Account WHERE googleUserID = :1",
user.user_id()).get()
if account is None:
account_key = session.get("account")
account = None if account_key is None else db.get(account_key)
if account is None:
account = model.Account(googleUserID=user.user_id(),
googleEmail=user.email())
account.put()
elif account.googleUserID is None:
account.googleUserID = user.user_id()
account.put()
session["account"] = account.key()
account_key = session.get("account")
account = None if account_key is None else db.get(account_key)
if account is None:
epubs = model.ePubFile.all().filter(
"license IN", ["Public Domain", "Creative Commons"])
show = []
for epub in epubs:
if random.randint(0, 1) == 1:
show.append(epub)
if len(show) == 3:
break
for epub in epubs:
if len(show) == 3:
break
if random.randint(0, 1) == 1:
show.append(epub)
template_values = {
"epubs": show,
"current_user": get_current_session().get("account"),
"login_url": users.create_login_url("/")
}
path = os.path.join(os.path.dirname(__file__), 'html/index.html')
self.response.out.write(template.render(path, template_values))
else:
self.redirect('/list')
def setupUser(self):
self.user = users.get_current_user()
self.templateValues = {}
if self.user:
self.templateValues['signedIn'] = True
self.templateValues['loginUrl'] = users.create_logout_url('/')
self.account = model.Account.query_account_for_user(
self.user).get()
if self.account:
logging.critical('account exists for email ' +
self.account.user.email())
else:
logging.critical('account doesnt exist - creating')
self.account = model.Account(user=self.user)
self.account.put()
else:
loginURL = users.create_login_url('/account')
self.templateValues['loginUrl'] = loginURL
def view_portfolio():
user = model.Account()
user.set_from_pk(session["Active User"])
allpositions = user.getpositions_html()
positions = {}
positions["tickers"] = [i.ticker for i in allpositions]
positions["amounts"] = [i.amount for i in allpositions]
positions["values"] = [
'${:,.2f}'.format(i.amount * model.apiget(i.ticker))
for i in allpositions
]
positions["total value"] = sum([(i.amount * model.apiget(i.ticker))
for i in allpositions])
total_value = '${:,.2f}'.format(positions["total value"])
length = range(0, len(positions["tickers"]))
return render_template('authorized/viewportfolio.html',
positions=positions,
length=length,
total_value=total_value)
def setupUser(self):
# self.user = users.get_current_user()
self.user = False # setting this to false to disable the users module for now -- was causing 500 error on production
self.templateValues = {}
if self.user:
self.templateValues['signedIn'] = True
self.templateValues['loginUrl'] = users.create_logout_url('/')
self.account = model.Account.query_account_for_user(
self.user).get()
if self.account:
logging.critical('account exists for email ' +
self.account.user.email())
else:
logging.critical('account doesnt exist - creating')
self.account = model.Account(user=self.user)
self.account.put()
else:
# loginURL = users.create_login_url('/account')
self.templateValues['loginUrl'] = 'http://schealthatlas.org'
def get(self):
verifier = self.request.get('oauth_verifier')
auth = tweepy.OAuthHandler(TWITTER_CONSUMER_KEY,
TWITTER_CONSUMER_SECRET,
secure=True)
session = get_current_session()
request_key = session.get("rt_key_")
request_secret = session.get("rt_secret_")
if request_key is None or request_secret is None:
self.response.out.write(
'Error! Failed to retain account/handle or request key/secret.'
)
return
auth.set_request_token(request_key, request_secret)
try:
auth.get_access_token(verifier)
except tweepy.TweepError:
self.response.out.write('Error! Failed to get access token.')
return
auth.set_access_token(auth.access_token.key, auth.access_token.secret)
twitter = tweepy.API(auth)
twitterUsername = twitter.auth.get_username()
account = db.GqlQuery("SELECT * FROM Account WHERE twitterHandle = :1",
twitterUsername).get()
if account is None:
account_key = session.get("account")
account = None if account_key is None else db.get(account_key)
if account is None:
account = model.Account()
account.twitterHandle = twitterUsername
account.twitterKey = auth.access_token.key
account.twitterToken = auth.access_token.secret
account.put()
session["account"] = account.key()
self.redirect("/")
def show_dashboard():
user = model.Account()
user.set_from_pk(session["Active User"])
balance = '${:,.2f}'.format(user.balance)
allpositions = user.getpositions_html()
positions = {}
positions["tickers"] = [i.ticker for i in allpositions]
positions["amounts"] = [i.amount for i in allpositions]
positions["values"] = [
'${:,.2f}'.format(i.amount * model.apiget(i.ticker))
for i in allpositions
]
positions["total value"] = sum([(i.amount * model.apiget(i.ticker))
for i in allpositions])
total_value = '${:,.2f}'.format(positions["total value"])
length = range(0, len(positions["tickers"]))
return render_template('authorized/dashboard.html',
balance=balance,
length=length,
positions=positions,
total_value=total_value)
def testMakeTrades(self):
ac = model.Account().set_from_pk(2)
buyresult = ac.buy("TSLA", 5)
self.assertTrue(buyresult, "buy returns true on success")
balance = ac.balance
self.assertTrue(balance < 10000.00, "buy spends money")
fpos = ac.getposition("TSLA")
self.assertEqual(fpos.amount, 5, "buy creates position")
ftr = ac.gettradesfor("TSLA")
self.assertEqual(1, len(ftr), "buy creates trade")
self.assertEqual(5, ftr[0].volume, "buy sets trade volume")
ac.sell("TSLA", 3)
self.assertTrue(ac.balance > balance, "sell earns money")
fpos = ac.getposition("TSLA")
self.assertEqual(fpos.amount, 2, "sell reduces position")
ftr = ac.gettradesfor("TSLA")
self.assertEqual(2, len(ftr), "sell creates trade")
self.assertEqual(-3, ftr[1].volume, "sell sets negative trade volume")
model.Metier(id=1, name='Guerrier'),
model.Metier(id=2, name='Ninja'),
model.Metier(id=3, name='Voleur'),
model.Metier(id=4, name='Pretre'),
model.Metier(id=5, name='Mage'),
model.Metier(id=6, name='Paladin'),
model.Metier(id=7, name='Ranger'),
model.Metier(id=8, name='Menestrel'),
model.Metier(id=9, name='Pirate'),
model.Metier(id=10, name='Marchand'),
model.Metier(id=11, name='Ingenieur'),
model.Metier(id=12, name='Bourgeois'),
])
data = [
model.Account(id=1,
login='******',
passwd=hashlib.sha224(b'1234').hexdigest(),
email='*****@*****.**'),
model.Account(id=2,
login='******',
passwd=hashlib.sha224(b'/(&!!#').hexdigest(),
email='*****@*****.**'),
model.Carac(id=1, COU=13, INT=12, CHA=9, AD=12, FO=13),
model.Avatar(id=1,
name='le nain',
acc_id=1,
metier_id=1,
race_id=3,
carac_id=1),
model.Carac(id=2, COU=9, INT=13, CHA=11, AD=11, FO=11),
model.Avatar(id=2,
name='le ranger',
def deposit_success():
user = model.Account()
user.set_from_pk(session["Active User"])
balance = '${:,.2f}'.format(user.balance)
return render_template('authorized/depositsuccess.html', balance=balance)
def testCheckAdmin(self):
ac = model.Account().set_from_pk(2)
userType = ac.type
self.assertTrue("ADMIN" == ac.type, "user type is set to Admin")
def set_user_object(username):
user_object = model.Account(username)
user_object = user_object.set_from_username()
return user_object
