from flask import Flask, render_template, request, redirect, flash, session
from mysqlconnection import MySQLConnector
app = Flask(__name__)
mysql = MySQLConnector(app, 'emails')
import re
import md5
EMAIL_REGEX = re.compile(r'^[a-zA-Z0-9.+_-]+@[a-zA-Z0-9._-]+\.[a-zA-Z]+$')
app.secret_key = 'ThisIsSecret'
@app.route('/')
def index():
return render_template('index.html')
@app.route('/users/new')
def new():
return render_template('new.html')
@app.route('/users/<userid>')
def view(userid):
query = mysql.query_db("SELECT * FROM emails WHERE id = :sid")
data = {'sid': userid}
emails = mysql.query_db(query, data)
return render_template('display.html')
@app.route('/post', methods=['POST'])
def post():
from flask import Flask, redirect, request, session, render_template, flash
from flask_bcrypt import Bcrypt
from mysqlconnection import MySQLConnector
import re
email_regex = re.compile(r"(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$)")
app = Flask(__name__)
app.secret_key = 'Secret'
bcrypt = Bcrypt(app)
mysql = MySQLConnector(app, 'registration')
@app.route('/')
def index():
return render_template('index.html')
@app.route('/register', methods=['POST'])
def register():
errors = []
if len(request.form['first_name']) < 2:
errors.append('First name must be at least 2 characters long.')
if len(request.form['last_name']) < 2:
errors.append('Last name must be at least 2 characters long.')
if not len(request.form['email']) < 2:
errors.append('Email required.')
from flask import Flask, request, redirect, render_template, session, flash
import re
import datetime
from mysqlconnection import MySQLConnector
app = Flask(__name__)
app.secret_key = "ThisIsSecret!"
bcrypt = Bcrypt(app)
mysql = MySQLConnector(app,'loginsdb')
def isValidEmail(email):
if len(email) > 7:
if re.match('^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*(\.[a-z]{2,4})$', email) != None:
return True
return False
@app.route('/')
def index():
return "hit index route"
@app.route('/registration', methods=["POST"])
def registration:
return "hit registration route"
@app.route('/login', methods=["POST"])
return "hight login route"
@app.route('/success')
return "hit success route"
app.run(debug=True)
from flask import Flask, request, render_template, redirect
from mysqlconnection import MySQLConnector
app = Flask(__name__)
mysql = MySQLConnector(app, 'emails')
print mysql.query_db("SELECT * FROM users")
@app.route('/')
def index():
return render_template('index.html')
@app.route('/sucess', methods=['POST'])
def create():
return render_template('sucess.html')
app.run(debug=True)
"""
Pajama Programmer
Coding Dojo - July 5 Online Flex
02-September-2015
Python > Flask & MySQL > Assignment: Login and Registration
"""
from flask import Flask, render_template, request, redirect, flash, session
from mysqlconnection import MySQLConnector
from flask.ext.bcrypt import Bcrypt
import re
app = Flask(__name__)
bcrypt = Bcrypt(app)
app.secret_key = "TheAnswerToLifeTheUniverseAndEverything=42"
db = MySQLConnector(app,'login_db')
EMAIL_REGEX = re.compile(r'^[\w\.+_-]+@[\w\._-]+\.[\w]*$')
queries = {
'create' : "INSERT INTO users (first_name, last_name, email, password, created_at, updated_at) VALUES (:first_name, :last_name, :email, :password, NOW(), NOW())",
'index' : "SELECT * FROM users",
'delete' : "DELETE FROM users WHERE id=:id",
'select_id' : "SELECT * FROM users WHERE id=:id",
'update' : "UPDATE users SET first_name = :first_name, last_name=:last_name, email=:email, updated_at=NOW() WHERE id=:id",
'select_email' : "SELECT id, password FROM users WHERE email=:email"
}
print db.query_db("SELECT * FROM users")
# ROUTING
from flask import Flask, request, redirect, render_template, session, flash
from flask_bcrypt import Bcrypt
from mysqlconnection import MySQLConnector
import re
EMAIL_REGEX = re.compile(r'^[a-zA-Z0-9\.\+_-]+@[a-zA-Z0-9\._-]+\.[a-zA-Z]+$')
USER_REGEX = re.compile(r'^[a-zA-Z]{1}[a-zA-z\._-]{3,20}$')
NAME_REGEX = re.compile(r'^[a-zA-Z]{2}[a-zA-z ]*$')
PASS_REGEX = re.compile(r'^[a-zA-Z@#$%_-]{8,21}$')
app = Flask(__name__)
bcrypt = Bcrypt(app)
app.secret_key = 'nobodyknows'
mysql = MySQLConnector(app, 'walldb')
@app.route('/') # Route shows a login form (div) if no #session else user info
# check session. (if session exists retrieve self's info)
def index():
print("re routed to main", session.get('validated'))
if 'validated' in session:
return render_template('wall.html')
else:
return render_template('login.html')
@app.route('/allusers', methods=['GET'])
# retrieve user names
def allusers():
if 'validated' in session:
msgs = mysql.query_db(
"SELECT * from messages ORDER BY created_at DESC")
comments = mysql.query_db("SELECT * from comments")
from flask import Flask
# import the Connector function
from mysqlconnection import MySQLConnector
app = Flask(__name__)
# connect and store the connection in "mysql"; note that you pass the database name to the function
mysql = MySQLConnector(app, 'twitter')
# an example of running a query
print mysql.query_db("SELECT * FROM users")
app.run(debug=True)
from flask import Flask, render_template, request, redirect, session, flash
import md5
import os, binascii
import re
from mysqlconnection import MySQLConnector
app = Flask(__name__)
mysql = MySQLConnector(app, 'login_reg')
app.secret_key = "ThisIsSecret"
EMAIL_REGEX = re.compile(r'^[a-zA-Z0-9.+_-]+@[a-zA-Z0-9._-]+\.[a-zA-Z]+$')
@app.route('/')
def index():
return render_template("index.html")
@app.route('/register', methods=["POST"])
def register():
is_valid = True
#email validation
if len(request.form["email"]) < 1:
flash("Email is required")
is_valid = False
elif not EMAIL_REGEX.match(request.form["email"]):
flash("This is not a valid email format")
is_valid = False
else:
email_exists = "SELECT * FROM users where email = :email"
data = {"email": request.form["email"]}
"""
Pajama Programmer
Coding Dojo - July 5 Online Flex
30-August-2015
Python > Flask & MySQL > Assignment: Full Friends
"""
from flask import Flask, render_template, request, redirect, flash
from mysqlconnection import MySQLConnector
import re
app = Flask(__name__)
app.secret_key = "somesecret"
db = MySQLConnector(app,'friends_db')
EMAIL_REGEX = re.compile(r'^[\w\.+_-]+@[\w\._-]+\.[\w]*$')
queries = {
'create' : "INSERT INTO friends (first_name, last_name, email, created_at) VALUES (:first_name, :last_name, :email, NOW())",
'index' : "SELECT * FROM friends",
'delete' : "DELETE FROM friends WHERE id=:id",
'select' : "SELECT * FROM friends WHERE id=:id",
'update' : "UPDATE friends SET first_name = :first_name, last_name=:last_name, email=:email WHERE id=:id"
}
print db.query_db("SELECT * FROM friends")
# ROUTING
@app.route('/') #Show All Friends
def index():
query = queries['index']
data = {}
from flask import Flask, render_template, request, redirect, jsonify # jsonify lets us send JSON back!
# Import MySQLConnector class from mysqlconnection.py
from mysqlconnection import MySQLConnector
app = Flask(__name__)
'''
Set variable 'mysql' to be an instance of the MySQLConnector class,
taking our entire application as the first argument and the database
name as the second argument.
'''
mysql = MySQLConnector(app, 'myownapi')
@app.route('/quotes')
def index():
query = "SELECT * FROM quotes"
quotes = mysql.query_db(query)
return render_template('index.html', quotes=quotes)
@app.route('/quotes/index_json')
def index_json():
query = "SELECT * FROM quotes"
quotes = mysql.query_db(query)
return jsonify(quotes=quotes)
@app.route('/quotes/index_html')
def index_partial():
query = "SELECT * FROM quotes"
quotes = mysql.query_db(query)
return render_template('partials/quotes.html', quotes=quotes)
@app.route('/quotes/create', methods=['POST'])
def create():
from flask import Flask, request, redirect, render_template, session, flash
from mysqlconnection import MySQLConnector
app = Flask(__name__)
app.secret_key = 'Secret'
mysql = MySQLConnector('full_friendsdb')
friends = mysql.fetch("SELECT * FROM friends")
def find_friend(id):
for friend in friends:
if friend['id'] == int(id):
return friend
return False
@app.route('/', methods=['GET'])
def index():
friends = mysql.fetch("SELECT * FROM friends")
return render_template('index.html', friends=friends)
@app.route('/friends', methods=['POST'])
def create():
query = "INSERT INTO friends (first_name, last_name, occupation, created_at, updated_at) VALUES ('{}', '{}', '{}', NOW(), NOW())".format(request.form['first_name'], request.form['last_name'], request.form['occupation'])
print query
mysql.run_mysql_query(query)
return redirect('/')
@app.route('/friends/<id>/edit', methods=['GET'])
def edit(id):
print id
friend = find_friend(id)
if friend:
from flask import Flask, request, redirect, render_template, session, flash
from mysqlconnection import MySQLConnector
app = Flask(__name__)
mysql = MySQLConnector(app,'friendsdb')
@app.route('/')
def index():
query = "SELECT * FROM friends" # define your query
friends = mysql.query_db(query) # run query with query_db()
return render_template('index.html', all_friends=friends) # pass data to our template
@app.route('/friends', methods=['POST'])
def create():
# Write query as a string. Notice how we have multiple values
# we want to insert into our query.
query = "INSERT INTO friends (first_name, last_name, occupation, created_at, updated_at)
VALUES (:first_name, :last_name, :occupation, NOW(), NOW())"
# We'll then create a dictionary of data from the POST data received.
data = {
'first_name': request.form['first_name'],
'last_name': request.form['last_name'],
'occupation': request.form['occupation']
}
# Run query, with dictionary values injected into the query.
mysql.query_db(query, data)
return redirect('/')
@app.route('/friends/<friend_id>')
def show(friend_id):
# Write query to select specific user by id. At every point where
# we want to insert data, we write ":" and variable name.
query = "SELECT * FROM friends WHERE id = :specific_id"
# Then define a dictionary with key that matches :variable_name in query.
data = {'specific_id': friend_id}
from flask import Flask
# import the Connector function
from mysqlconnection import MySQLConnector
app = Flask(__name__)
# connect and store the connection in "mysql" note that you pass the database name to the function
mysql = MySQLConnector('mydb1')
# an example of running a query
print mysql.fetch("Select * From users")
app.run(debug=True)
from flask import Flask, render_template, redirect, request, flash, get_flashed_messages, url_for, session
from mysqlconnection import MySQLConnector
from flask_bcrypt import Bcrypt
app = Flask(__name__)
bcrypt = Bcrypt(app)
app.secret_key = "lol"
mysql = MySQLConnector(app, "mydb")
def get_user_from_id(id):
query = "SELECT * FROM friends WHERE id = :id"
return mysql.query_db(query, {"id": id})[0]
@app.route('/')
def index():
flash_messages = get_flashed_messages(with_categories=True)
staticfile = url_for('static', filename="style.css")
return render_template("index.html",
messages=flash_messages,
styles=staticfile)
@app.route('/register', methods=['POST'])
def register():
errors = []
# min length on username
if len(request.form['username']) < 5:
# -*- python -*-
from flask import Flask, render_template, redirect, request, session, flash
from mysqlconnection import MySQLConnector
import os, binascii, md5
import re
import datetime
app = Flask(__name__)
app.secret_key = "TheWallSecretKey"
mysql = MySQLConnector(app, '7_Wall')
email_regex = re.compile(r'^[a-zA-Z0-9.+_-]+@[a-zA-Z0-9._-]+\.[a-zA-Z]+$')
def get_passwd_salt():
return (binascii.b2a_hex(os.urandom(15)))
def get_passwd_hash(passwd, salt):
return (md5.new(passwd + salt).hexdigest())
@app.route('/')
def index():
if 'login_id' in session:
return (redirect('/wall'))
else:
return (render_template('index.html'))
# jsonify lets us send JSON back!
from flask import Flask, render_template, request, redirect, jsonify
# Import MySQLConnector class from mysqlconnection.py
from mysqlconnection import MySQLConnector
app = Flask(__name__)
mysql = MySQLConnector(app, 'notes')
@app.route('/', methods=['GET'])
def index():
query = "SELECT * FROM notes"
notes = mysql.query_db("SELECT * FROM notes")
return render_template('index.html', notes = notes)
@app.route('/notes/html', methods=['GET'])
def html_notes():
query = "SELECT * FROM notes"
notes = mysql.query_db("SELECT * FROM notes")
return render_template('notes.html', notes = notes)
@app.route('/notes/create', methods=['POST'])
def create():
query = "INSERT INTO notes (title, created_at, updated_at) VALUES (:title, NOW(), NOW())"
data = {
'title': request.form['title']
}
mysql.query_db(query, data)
return redirect('/')
@app.route('/notes/<id>/delete')
def delete(id):
from flask import Flask, request, redirect, render_template, session, flash
from mysqlconnection import MySQLConnector
app = Flask(__name__)
mysql = MySQLConnector(app, 'full_friends')
@app.route('/')
def index():
return redirect('/users')
@app.route('/users')
def users():
query = 'select * from friend'
friend = mysql.query_db(query)
return render_template('index.html', all_friends=friend)
@app.route('/users/new')
def new():
return render_template('new.html')
@app.route('/friends', methods=['POST'])
def create():
query = "INSERT INTO friend (first_name, last_name, age, created_at, updated_at) VALUES (:first_name, :last_name, :age, NOW(), NOW())"
data = {
'first_name': request.form['first_name'],
'last_name': request.form['last_name'],
'age': request.form['age']
}
from flask import Flask
from mysqlconnection import MySQLConnector
app = Flask(__name__)
mysql = MySQLConnector('mydb')
print mysql.fetch('SELECT * FROM users')
app.run(debug=True)
from flask import *
from mysqlconnection import MySQLConnector
from flask_bcrypt import Bcrypt
app = Flask(__name__)
mysql = MySQLConnector(app, 'login_registration')
bcrypt = Bcrypt(app)
app.secret_key = "ThisIsSecret!"
@app.route('/')
def index():
return render_template("index.html")
@app.route('/users', methods=['post'])
def create_user():
if request.form['password'] != request.form['password_confirmation']:
flash('Your password does not match.')
return redirect('/')
query = 'INSERT INTO users (email, password, updated_at, created_at) VALUES (:email, :password, NOW(), NOW());'
values = {
'email': request.form['email'],
'password': bcrypt.generate_password_hash(request.form['password']),
}
user_id = mysql.query_db(query, values)
session['user_id'] = user_id
return redirect('/success')
from flask import Flask, render_template, request, redirect, flash, session
from mysqlconnection import MySQLConnector # import the Connector function
from flask.ext.bcrypt import Bcrypt # import Bcrypt to hash password
import re
EMAIL_REGEX = re.compile(r'^[a-zA-Z0-9\.\+_-]+@[a-zA-Z0-9\._-]+\.[a-zA-Z]*$')
NAME_REGEX = re.compile(r'^[a-zA-Z ]+$') # Case insensitive "a" to "z" and "space" allowed
PASSWORD_REGEX = re.compile(r'^([^0-9]*|[^A-Z]*)$') # number and upper case letter allowed
app = Flask(__name__)
bcrypt = Bcrypt(app)
app.secret_key = 'KeepItSecretKeepItSafe'
mysql = MySQLConnector(app, 'login') # connect and store the connection in "mysql" note that you pass the database name to the function
print mysql.query_db("SELECT * FROM users") # an example of running a query
# this will load a page that has 2 forms one for registration and login
@app.route('/', methods=['GET'])
def index():
error=1 # assume there could be register error by default
return render_template('index.html', error=error)
@app.route('/register', methods=['POST'])
def register():
print "Got Post Info"
error = 1 # assume there could be register error by default
if len(request.form['first_name']) < 2 or not NAME_REGEX.match(request.form['first_name']):
flash("Invalid First Name. (Letters only, at least 2 characters.)")
elif len(request.form['last_name']) < 2 or not NAME_REGEX.match(request.form['last_name']):
flash("Invalid Last Name. (Letters only, at least 2 characters.)")
elif len(request.form['email']) < 1 or not EMAIL_REGEX.match(request.form['email']):
flash("Invalid Email Address.")
# check if email already exists which is required as unique value for users to log in
elif mysql.query_db("SELECT * FROM users WHERE email = '"+request.form['email']+"'") != [] :
flash("Account already exists with this email. Please choose different email to register.")
from flask import Flask, request, redirect, render_template, session, flash
from mysqlconnection import MySQLConnector
app = Flask(__name__)
mysql = MySQLConnector(app, 'friends_againdb')
@app.route('/')
def index():
friends = mysql.query_db('SELECT * FROM friends')
print friends
return render_template('index.html', friend_list=friends)
@app.route('/addfriends', methods=['POST'])
def new_friend():
data = {}
name = request.form['name']
age = request.form['age']
data['name'] = name
data['age'] = age
print data
query = 'INSERT INTO friends(name, age, friends_since) VALUES (:name, :age, NOW())'
mysql.query_db(query, data)
return redirect('/')
app.run(debug=True)
from flask import Flask, render_template, redirect, request, session, flash
import re
from mysqlconnection import MySQLConnector
EMAIL_REGEX = re.compile(r'^[a-zA-Z0-9\.\+_-]+@[a-zA-Z0-9\._-]+\.[a-zA-Z]*$')
app = Flask(__name__)
app.secret_key = 'mykey'
mysql = MySQLConnector(app, 'books')
@app.route('/')
def index():
return render_template('index.html')
@app.route("/emailvalidation", methods=['POST', 'GET'])
def emailValidation():
if not EMAIL_REGEX.match(request.form['email']):
flash(u'Invalid email address', 'error')
return redirect('/')
else:
flash('The email address you entered (' + request.form['email'] +
') is a Valid email address! Thank you!')
dbqueryString = 'INSERT into emails(EmailAddress, create_dt, update_dt)values(\'' + request.form[
'email'] + '\',now(),now())'
print dbqueryString
res = mysql.query_db(dbqueryString)
return redirect('/success')
from flask import Flask, request, redirect, render_template, session, flash
import re
from mysqlconnection import MySQLConnector
app = Flask(__name__)
mysql = MySQLConnector(app, 'valid_emails')
app.secret_key = 'qijeqoihqwohrqu9rhq9rh39r8q'
EMAIL_REGEX = re.compile(r'^[a-zA-Z0-9.+_-]+@[a-zA-Z0-9._-]+\.[a-zA-Z]+$')
@app.route('/')
def home():
return render_template('index.html')
@app.route('/verify', methods=['POST'])
def verify():
if not EMAIL_REGEX.match(request.form['email']):
flash('Enter a valid email')
return redirect('/')
query_email = "SELECT * FROM emails WHERE email = :email"
data = {'email': request.form['email']}
mails = mysql.query_db(query_email, data)
if mails:
flash('Email Already Exists!')
return redirect('/')
else:
query_add = 'INSERT INTO emails (email, created_at) VALUES (:email, now())'
data = {'email': request.form['email']}
mysql.query_db(query_add, data)
return redirect('/success')
import time
import datetime
import md5
import os, binascii
from flask import Flask, render_template, request, redirect, session, flash
from mysqlconnection import MySQLConnector
EMAIL_REGEX = re.compile(r'^[a-zA-Z0-9.+_-]+@[a-zA-Z0-9._-]+\.[a-zA-Z]+$')
NAME_REGEX = re.compile(r'^[a-zA-Z-]{2,20}$')
PASSWORD_REGEX = re.compile(
r'^(?=.*[0-9])(?=.*[A-Z])([a-zA-Z0-9!@#$%^&*()]{8,16})$')
app = Flask(__name__)
app.secret_key = 'SecretKey'
mysql = MySQLConnector(app, 'RESTlite_Users_db')
@app.route('/')
def index():
# Authenticate user session
if session.get('user_id') == None:
session['permission_level'] = permissions(None)
return render_template('index.html')
else:
return render_template('user.html', user=showUser(session['user_id']))
@app.route('/register', methods=['POST'])
def register():
from flask import Flask, request, redirect, render_template, flash, session
import re
from mysqlconnection import MySQLConnector
from flask_bcrypt import Bcrypt
EMAIL_REGEX = re.compile(r'^[a-zA-Z0-9\.\+_-]+@[a-zA-Z0-9\._-]+\.[a-zA-Z]*$')
app = Flask(__name__)
bcrypt = Bcrypt(app)
mysql = MySQLConnector(app, 'Login_and_Registration_db')
app.secret_key = 'secret_key'
@app.route('/')
def index():
return render_template('index.html')
@app.route('/register', methods=['POST'])
def register():
first_name = request.form['first_name']
last_name = request.form['last_name']
email = request.form['email']
password = request.form['pwd']
confirm_password = request.form['pwd_confirm']
errors = False
query = 'SELECT * FROM users WHERE email = :email'
data = {'email': email}
results = mysql.query_db(query, data)
if len(results) > 0:
flash('email already in use')
return redirect('/')
from flask import Flask, request, redirect, render_template, session, flash
import re
from mysqlconnection import MySQLConnector
import md5
import os, binascii
app = Flask(__name__)
mysql = MySQLConnector(app, 'the_wall')
app.secret_key = 'qwertyuiop123456789'
@app.route('/')
def index():
if 'id' in session and 'user' in session:
return render_template('index.html')
else:
session['id'] = ''
session['user'] = ''
return render_template('index.html')
#####################################################
@app.route('/registration', methods=['POST'])
def user_register():
first_name = request.form['first_name']
last_name = request.form['last_name']
email = request.form['email']
password = request.form['password']
confir_pw = request.form['confir_pw']
name_regex = re.compile(r'^[A-Z][a-z]+$')
from flask import Flask, render_template, session, request, redirect, flash
from mysqlconnection import MySQLConnector
from flask.ext.bcrypt import Bcrypt
app = Flask(__name__)
app.secret_key = "e94f849828dfc7122c30106a8b42fb4c3"
mysql = MySQLConnector(app, 'userdb')
bcrypt = Bcrypt(app)
import re
EMAIL_REGEX = re.compile(r'^[a-zA-Z0-9.+_-]+@[a-zA-Z0-9._-]+\.[a-zA-Z]+$')
@app.route('/')
def index():
if 'is_valid' in session:
session.clear()
return render_template('index.html')
@app.route('/register', methods=['POST'])
def register():
is_valid = True
session['first_name'] = request.form['first_name']
session['last_name'] = request.form['last_name']
session['email'] = request.form['email']
password = request.form['password']
password_confirm = request.form['password_confirm']
if len(session['first_name']) < 2:
is_valid = False
from flask import Flask, request, redirect, render_template, session, flash
from mysqlconnection import MySQLConnector
import re
import datetime
import md5
EMAIL_REGEX = re.compile(r'^[a-zA-Z0-9.+_-]+@[a-zA-Z0-9._-]+\.[a-zA-Z]+$')
app = Flask(__name__)
app.secret_key = 'ThisIsSecret'
mysql = MySQLConnector(app, 'mydb')
@app.route('/')
def index():
if (session.get('success') == None):
session['success'] = ""
if (session.get('first_name') == None):
session['first_name'] = ""
if (session.get('last_name') == None):
session['last_name'] = ""
if (session.get('email') == None):
session['email'] = ""
if (session.get('user_id') == None):
session['user_id'] = ""
if (session.get('login') == None):
session['login'] = ""
return render_template('index.html', success=session['success'], first_name=session['first_name'], last_name=session['last_name'] , email=session['email'], login=session['login'], user_id=session['user_id'])
@app.route('/result')
def result():
return render_template('result.html', first_name=session.get('first_name'), last_name=session.get('last_name'), success=session.get('success'), user_id=session['user_id'])
@app.route('/login')
import re
import bcrypt
from flask import Flask, render_template, request, redirect, session, flash
from mysqlconnection import MySQLConnector
EMAIL_REGEX = re.compile(r'^[a-za-z0-9\.\+_-]+@[a-za-z0-9\._-]+\.[a-za-z]*$')
app = Flask(__name__)
app.secret_key = 'wow, such secret, much awesome'
mysql = MySQLConnector('thewalldb')
@app.route('/')
def index():
return render_template('index.html')
@app.route('/register', methods=['POST'])
def register():
if len(request.form['first_name']) < 2 or (
not request.form['first_name'].isalpha()):
flash(
'First Name must have at least 2 characters and cannot contain any numbers.'
)
return redirect('/')
elif len(request.form['last_name']) < 2 or (
not request.form['last_name'].isalpha()):
flash(
'Last Name must have at least 2 characters and cannot contain any numbers.'
)
from flask import Flask, request, redirect, render_template, session, flash
from mysqlconnection import MySQLConnector
import re
EMAIL_REGEX = re.compile(r'^[a-zA-Z0-9.+_-]+@[a-zA-Z0-9._-]+\.[a-zA-Z]+$')
app = Flask(__name__)
app.secret_key = "ThisIsSecretadfasdfasdf!"
mysql = MySQLConnector(app, 'email-validation')
@app.route('/')
def index():
query = "SELECT email, DATE_FORMAT(created_at,'%M %d %Y') FROM emails" # define your query, make sure you use the DATE_FORMAT stuff in your key
emails = mysql.query_db(query) # run query with query_db()
return render_template('index.html', email_list=emails)
@app.route('/email_validate', methods=['POST'])
def validate():
input_email = request.form['email']
email_query = "SELECT * FROM emails WHERE email = :email_id"
query_data = {'email_id': input_email}
stored_email = mysql.query_db(email_query, query_data)
# print stored_email[0]['email']
if not EMAIL_REGEX.match(input_email):
flash("Email must be a valid email")
elif stored_email:
flash("Email already exists!")
from flask import Flask, request, redirect, render_template, flash, session
from mysqlconnection import MySQLConnector
app = Flask(__name__)
app.secret_key = "SecretKey!"
mysql = MySQLConnector(app, 'sakila')
@app.route('/')
def index():
return render_template('index.html')
def email_addition():
query = "INSERT INTO same_emails (email, created_at) VALUES (:email, NOW())"
data = {'email': request.form['email']}
mysql.query_db(query, data)
@app.route('/email_processing', methods=['POST'])
def email_processing():
email = mysql.query_db('SELECT LCASE(email) FROM customer')
print email
if {'LCASE(email)': request.form['email']} in email:
flash('Email is valid!')
email_addition()
import re
from flask import Flask
from flask import flash
from flask import redirect
from flask import render_template
from flask import request
from flask import session
from mysqlconnection import MySQLConnector
app = Flask(__name__)
mysql = MySQLConnector(app, 'friends_db')
app.secret_key = "secretsauce81"
EMAILREG = re.compile(r'^[a-zA-Z0-9.+-_]+@[a-zA-Z0-9._-]+\.[a-zA-Z]*$')
@app.route('/')
def index():
query = "SELECT * FROM friends"
all_friends = mysql.query_db(query)
return render_template('index.html', all_friends=all_friends)
@app.route('/friends', methods=['POST'])
def created():
friend_data = {
'first_name': request.form['fname'],
'last_name': request.form['lname'],
'email': request.form['email']
}
if len(friend_data['first_name']) < 2:
from flask import Flask, render_template, redirect, request, session, flash
from mysqlconnection import MySQLConnector
from flask_bcrypt import Bcrypt
app = Flask(__name__)
app.secret_key='mykey'
bcrypt = Bcrypt(app)
mysql = MySQLConnector(app, 'TheWall')
@app.route('/', methods=['GET'])
def index():
if len(session.keys()) > 2:
return redirect('/messageboard')
else:
return render_template('index.html')
@app.route('/create_user', methods=['POST'])
def create_user():
first_name = request.form['first_name']
last_name = request.form['last_name']
email = request.form['email']
password = request.form['password']
pw_hash = bcrypt.generate_password_hash(password)
insert_query = "INSERT INTO users(first_name, last_name, email, password, created_at) VALUES (:first_name, :last_name, :email, :pw_hash, NOW())"
query_data = { 'first_name': first_name, 'last_name': last_name, 'email': email, 'pw_hash': pw_hash}
mysql.query_db(insert_query, query_data)
return redirect('/')
from flask import Flask, request, redirect, render_template, session, flash
app = Flask(__name__)
app.secret_key = 'ThisIsSecret'
import re
EMAIL_REGEX = re.compile(r'^[a-zA-Z0-9\.\+_-]+@[a-zA-Z0-9\._-]+\.[a-zA-Z]*$')
from mysqlconnection import MySQLConnector
mysql = MySQLConnector(app, 'rest')
from flask_bcrypt import Bcrypt
bcrypt = Bcrypt(app)
import datetime
import time
now = time.time()
st = datetime.datetime.fromtimestamp(now).strftime('%Y-%m-%d %H:%M:%S')
@app.route('/users')
def index():
#Displays all users
users = mysql.query_db("SELECT * FROM users")
return render_template('users.html', users=users)
@app.route('/add_user', methods=['POST'])
def add_user():
#Form submission that adds new user
new_user_query = "INSERT INTO `rest`.`users` (`first_name`, `last_name`, `email`, `created_at`, `updated_at`) VALUES ('{}', '{}', '{}', NOW(), NOW() );".format(
request.form['first_name'], request.form['last_name'],
from flask import Flask, render_template, request, redirect, session, flash, url_for
import re
from flask_bcrypt import Bcrypt
from mysqlconnection import MySQLConnector
app = Flask(__name__)
app.secret_key = 'aksdf'
mysql = MySQLConnector(app,'loginandregister')
bcrypt = Bcrypt(app)
emailRegex = re.compile(r'^[a-zA-Z0-9\.\+_-]+@[a-zA-Z0-9\._-]+\.[a-zA-Z]*$')
passwordRegex = re.compile(r'^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).+$')
def validate():
validate = True
#Check first name
if len(request.form['first_name']) < 1:
flash('First name must be at least 2 characters!','firstNameError')
validate = False
elif any(char.isdigit() for char in request.form['first_name']) == True:
flash('First name cannot have numbers','firstNameError')
validate = False
else:
session['first_name'] = request.form['first_name']
#Check last name
if len(request.form['last_name']) < 1:
flash('Last name must be at least 2 charactoers!','lastNameError')
validate = False
elif any(char.isdigit() for char in request.form['last_name']) == True:
flash('Last name cannot have numbers','lastNameError')
from flask import Flask
# import the Connector function
from mysqlconnection import MySQLConnector
app = Flask(__name__)
# connect and store the connection in "mysql" note that you pass the database name to the function
mysql = MySQLConnector('mydb')
# an example of running a query
print mysql.fetch("SELECT * FROM users")
app.run(debug=True)
from flask import Flask, request, render_template, redirect, session
from mysqlconnection import MySQLConnector
app = Flask(__name__)
mysql = MySQLConnector(app, '')
@app.route('/')
def index():
print "Inside the index method."
return render_template('index.html')
app.run(debug=True)
from flask import Flask, render_template, flash, request, redirect
from mysqlconnection import MySQLConnector
import re
app = Flask(__name__)
app.secret_key = "secret"
mysql = MySQLConnector(app, 'email')
EMAIL_REGEX = re.compile(r'^[a-zA-Z0-9\.\+_-]+@[a-zA-Z0-9\._-]+\.[a-zA-Z]*$')
queries = {
'create' : 'INSERT INTO emails (email, created_at) VALUES (:email, NOW());',
'index' : "SELECT * FROM emails",
'delete' : "DELETE FROM emails WHERE id = :id"
}
print mysql.query_db("SELECT email FROM emails")
@app.route('/', methods = ["GET", "POST"])
def index():
if request.method == "POST":
if(validateEmail(request.form['email'])):
query = queries['create']
data = { 'email' : request.form['email']}
mysql.query_db(query, data)
flash("Successfully created email record!")
return redirect('/success')
else:
flash("Email is not valid!")
return render_template('index.html')
@app.route('/success', methods = ['GET'])
from flask import Flask, render_template, redirect, request, flash, session
from flask_bcrypt import Bcrypt
from mysqlconnection import MySQLConnector
import os, random, re
app = Flask(__name__)
app.secret_key = os.urandom(24)
bcrypt = Bcrypt(app)
mysql=MySQLConnector(app, 'ajax_notes_db')
@app.route('/')
def index():
return redirect('/notes')
@app.route('/notes')
def notes():
print"into notes"
query = "SELECT * FROM notes "
notes = mysql.query_db(query)
return render_template("notes.html", notes=notes)
@app.route('/notes/new', methods=['POST'])
def new_note():
print "new note received:", request.form['new_note']
data={
'title': request.form['note_title'],
from flask import Flask
# import the Connector function
from mysqlconnection import MySQLConnector
app = Flask(__name__)
# connect and store the connection in "mysql" note that you pass the database name to the function
mysql = MySQLConnector(app, 'mydb')
# an example of running a query
print mysql.query_db("SELECT * FROM users")
app.run(debug=True)
from flask import Flask, request, redirect, render_template, session, flash
from mysqlconnection import MySQLConnector
app = Flask(__name__)
mysql = MySQLConnector(app,'friendsdb')
print mysql.query_db("SELECT * FROM friends")
@app.route('/')
def index():
query = "SELECT * FROM friends" # define your query
friends = mysql.query_db(query) # run query with query_db()
return render_template('index.html', all_friends=friends) # pass data to our template
@app.route('/friends', methods=['POST'])
def create():
# add a friend to the database!
return redirect('/')
app.run(debug=True)
