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