def create_connection(): mysql = MySQL() app = Flask(__name__) app.config['MYSQL_DATABASE_USER'] = '******' app.config['MYSQL_DATABASE_PASSWORD'] = '' app.config['MYSQL_DATABASE_DB'] = 'virball' app.config['MYSQL_DATABASE_HOST'] = 'localhost' mysql.init_app(app) con = mysql.connect() return con
def setupDb(): mysql = MySQL() # MySQL configurations app.config['MYSQL_DATABASE_USER'] = '******' app.config['MYSQL_DATABASE_PASSWORD'] = '******' app.config['MYSQL_DATABASE_DB'] = 'devathon' app.config['MYSQL_DATABASE_HOST'] = 'localhost' mysql.init_app(app) return mysql
class App:
def __init__(self):
self.app = Flask(__name__)
self.mysql = MySQL()
# mysql config
self.app.config['MYSQL_DATABASE_USER'] = "******"
self.app.config['MYSQL_DATABASE_PASSWORD'] = ""
self.app.config['MYSQL_DATABASE_DB'] = "mastertestv2"
self.app.config['MYSQL_DATABASE_HOST'] = "localhost"
self.mysql.init_app(self.app)
class BD():
def __init__(self):
self.__mysql = MySQL()
WBSV_AYD1.app.config['MYSQL_DATABASE_USER'] = '******'
WBSV_AYD1.app.config['MYSQL_DATABASE_PASSWORD'] = '******'
WBSV_AYD1.app.config['MYSQL_DATABASE_DB'] = 'proyectoClase'
WBSV_AYD1.app.config['MYSQL_DATABASE_HOST'] = 'localhost'
self.__mysql.init_app(WBSV_AYD1.app)
def get_mysql(self):
return self.__mysql
def set_connection(app):
mysql = MySQL()
# MySQL configurations
with open("project/credentials.txt", "r") as credentials_file:
credentials = credentials_file.read().splitlines()
app.config['MYSQL_DATABASE_USER'] = credentials[0]
app.config['MYSQL_DATABASE_PASSWORD'] = credentials[1]
app.config['MYSQL_DATABASE_DB'] = credentials[2]
app.config['MYSQL_DATABASE_HOST'] = credentials[3]
mysql.init_app(app)
global conn
conn = mysql.connect()
def test_search(self):
_startdate = '2017-03-23'
_starttime = '01:00 PM'
_type = 'G'
mysql = MySQL()
# MySQL configurations
app.config['MYSQL_DATABASE_USER'] = '******'
app.config['MYSQL_DATABASE_PASSWORD'] = '******'
app.config['MYSQL_DATABASE_DB'] = 'lrrs'
app.config['MYSQL_DATABASE_HOST'] = 'localhost'
mysql.init_app(app)
conn = mysql.connect()
cursor = conn.cursor()
cursor.callproc('sp_searchrooms', args=(_type, _starttime, _startdate))
assert cursor.rowcount == 1
def connect():
"""connect user to DataBase on host"""
host = "psotty.mysql.pythonanywhere-services.com"
user = "******"
pswd = ""
database = "psotty$fitness"
mysql = MySQL()
# MySQL configurations
app.config['MYSQL_DATABASE_USER'] = user
app.config['MYSQL_DATABASE_PASSWORD'] = pswd
app.config['MYSQL_DATABASE_DB'] = database
app.config['MYSQL_DATABASE_HOST'] = host
mysql.init_app(app)
db = mysql.connect()
return db
def setConfig(cls, app):
mysql = MySQL()
app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 0
app.config['MYSQL_DATABASE_USER'] = AccountBookRepository.getInstance(
).db_user
app.config[
'MYSQL_DATABASE_PASSWORD'] = AccountBookRepository.getInstance(
).db_password
app.config['MYSQL_DATABASE_DB'] = AccountBookRepository.getInstance(
).db_database
mysql.init_app(app)
AccountBookRepository.getInstance().db_source = mysql
#custom rule
app.custom_id_min_length = 6
app.custom_password_min_length = 6
return app
__author__ = 'Robley < *****@*****.** >'
eureka = Flask(__name__)
eureka.secret_key = 'secret'
mysql = MySQL()
# Database configuration
eureka.config['MYSQL_DATABASE_USER'] = '******'
eureka.config['MYSQL_DATABASE_PASSWORD'] = '******'
eureka.config['MYSQL_DATABASE_DB'] = 'eureka'
eureka.config['MYSQL_DATABASE_HOST'] = 'localhost'
eureka.config['UPLOADED_PHOTOS_DEST'] = '../static/uplds'
mysql.init_app(eureka)
# Home page
@eureka.route('/')
def home_page():
return render_template('index.html')
# Login / Register Page
@eureka.route('/logreg')
def logreg():
return render_template('logreg.html')
# Register
api = Flask(__name__)
@api.after_request
def apply_all_origin_headers(response):
response.headers['Access-Control-Allow-Origin'] = '*'
return response
# Setup mysql cursor, get cursor and connection every single time
mysql = MySQL()
api.config['MYSQL_DATABASE_USER'] = '******'
api.config['MYSQL_DATABASE_DB'] = 'eecs373'
api.config['MYSQL_DATABASE_PASSWORD'] = '******'
api.config['MYSQL_DATABASE_HOST'] = 'localhost'
mysql.init_app(api)
def execute_query(sql, needs_commit=False):
"""Use this function to get a connection object and then get a cursor and
then run a query and then return the values"""
db_connection = mysql.connect()
db_cursor = db_connection.cursor()
db_cursor.execute(sql)
# commit and return if the needs_commit flag is set
if needs_commit:
db_connection.commit()
return
# else return the results
import time
import datetime
import math
import os
import requests
application = Flask(__name__)
CORS(application)
mysql = MySQL()
application.config['MYSQL_DATABASE_USER'] = os.environ.get('RDS_USERNAME')
application.config['MYSQL_DATABASE_PASSWORD'] = os.environ.get('RDS_PASSWORD')
application.config['MYSQL_DATABASE_DB'] = 'parking'
application.config['MYSQL_DATABASE_HOST'] = 'parking.c9q5edmigsud.us-west-2.rds.amazonaws.com'
application.config['MYSQL_DATABASE_PORT'] = 3306
mysql.init_app(application)
@application.route('/')
def index():
return render_template('index.html')
@application.route('/paystations', methods=['GET', 'POST'])
def get_paystations():
element_keys = request.args.get('element_keys', None)
cur = mysql.connect().cursor()
query = "SELECT * FROM blockfaces"
if element_keys:
query += " WHERE element_key IN ({0})"
cur.execute(query.format(', '.join(element_keys.split())))
else:
cur.execute(query)
class Database():
def __init__(self, app):
self.mysql = MySQL()
self.mysql.init_app(app)
def get_all_users(self):
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
query = """SELECT username, email, password FROM Users WHERE is_active = True"""
cursor.execute(query)
rows = cursor.fetchall()
cursor.close()
users = []
for row in rows:
users.append(User(row[0], row[1], row[2]))
#self.mysql.get_db().close()
return users
def get_user(self, username=None, email=None, password=None):
if email is None and username is None:
return None
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
first = True
query = """SELECT username, email, password, is_active FROM Users WHERE """
if username:
query += """username = '******'""" % (username)
first = False
if email:
if not first:
query += """ AND """
query += """email = '%s'""" % (email)
first = False
if password:
if not first:
query += """ AND """
query += """password = '******'""" % (password)
cursor.execute(query)
u = cursor.fetchone()
cursor.close()
#self.mysql.get_db().close()
if not u:
return None
return User(u[0], u[1], u[2], u[3])
def insert_user(self, username, email, password):
if (not (username and email and password)):
return None
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
statement = """INSERT INTO Users (username, email, password) VALUES ('%s', '%s', '%s')""" % (
username, email, password)
cursor.execute(statement)
self.mysql.get_db().commit()
cursor.close()
#self.mysql.get_db().close()
return User(username, email, password)
def update_user(self, username, email=None, password=None, is_active=True):
if (not (username) or not (email or password)):
return None
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
statement = """UPDATE Users SET is_active = %s""" % (str(is_active))
if email:
statement += """, email = '%s'""" % email
if password:
statement += """, password = '******'""" % password
statement += """ WHERE username = '******'""" % username
cursor.execute(statement)
self.mysql.get_db().commit()
cursor.close()
#self.mysql.get_db().close()
return User(username, email, password)
def get_all_players(self):
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
query = """SELECT player_id, first_name, last_name, nfl_team FROM Players"""
cursor.execute(query)
rows = cursor.fetchall()
cursor.close()
players = []
for row in rows:
players.append(Player(row[0], row[1], row[2], row[3]))
#self.mysql.get_db().close()
return players
def get_player(self,
player_id=None,
first_name=None,
last_name=None,
nfl_team=None):
if player_id is None and first_name is None and last_name is None and nfl_team is None:
return None
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
first = True
query = """SELECT player_id, first_name, last_name, nfl_team FROM Players WHERE """
if player_id:
query += """player_id = '%s'""" % (player_id)
first = False
if first_name:
if not first:
query += """ AND """
query += """first_name = '%s'""" % (first_name)
first = False
if last_name:
if not first:
query += """ AND """
query += """last_name = '%s'""" % (last_name)
first = False
if nfl_team:
if not first:
query += """ AND """
query += """nfl_team = '%s'""" % (nfl_team)
first = False
cursor.execute(query)
p = cursor.fetchone()
cursor.close()
#self.mysql.get_db().close()
if not p:
return None
return Player(p[0], p[1], p[2], p[3])
def insert_player(self, player_id, first_name, last_name, nfl_team):
if (not (player_id and first_name and nfl_team)):
return None
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
statement = """INSERT INTO Players (player_id, first_name, last_name, nfl_team) VALUES ('%s', '%s', '%s', '%s')""" % \
(player_id, first_name, last_name, nfl_team)
try:
cursor.execute(statement)
self.mysql.get_db().commit()
cursor.close()
self.mysql.get_db().close()
except Exception, e:
print e
return Player(player_id, first_name, last_name, nfl_team)
from flask.ext.mysql import MySQL
from import_config import load_config
import json
import types
config = load_config()
mysql = MySQL()
basic_api = Flask(__name__)
basic_api.config['MYSQL_DATABASE_USER'] = config["database"]["user_name"]
basic_api.config['MYSQL_DATABASE_PASSWORD'] = config["database"]["password"]
basic_api.config['MYSQL_DATABASE_DB'] = config["database"]["db_instance"]
basic_api.config['MYSQL_DATABASE_HOST'] = config["database"]["connection_url"]
mysql.init_app(basic_api)
url_root = '/todo/api/v3.0/'
def format_json(element):
new_task = {}
new_task["id"] = element[0]
new_task["title"] = element[1]
new_task["description"] = element[2]
new_task["done"] = element[3]
return new_task
@basic_api.before_request
def db_connect():
g.db_conn = mysql.connect()
class Database():
def __init__(self, app):
self.mysql = MySQL()
self.mysql.init_app(app)
def get_all_users(self):
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
query = """SELECT username, email, password FROM Users WHERE is_active = True"""
cursor.execute(query)
rows = cursor.fetchall()
cursor.close()
users = []
for row in rows:
users.append(User(row[0], row[1], row[2]))
#self.mysql.get_db().close()
return users
def get_user(self, username=None, email=None, password=None):
if email is None and username is None:
return None
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
first = True
query = """SELECT username, email, password, is_active FROM Users WHERE """
if username:
query += """username = '******'""" % (username)
first = False
if email:
if not first:
query += """ AND """
query += """email = '%s'""" % (email)
first = False
if password:
if not first:
query += """ AND """
query += """password = '******'""" % (password)
cursor.execute(query)
u = cursor.fetchone()
cursor.close()
#self.mysql.get_db().close()
if not u:
return None
return User(u[0], u[1], u[2], u[3])
def insert_user(self, username, email, password):
if (not (username and email and password)):
return None
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
statement = """INSERT INTO Users (username, email, password) VALUES ('%s', '%s', '%s')""" % (username, email, password)
cursor.execute(statement)
self.mysql.get_db().commit()
cursor.close()
#self.mysql.get_db().close()
return User(username, email, password)
def update_user(self, username, email=None, password=None, is_active=True):
if (not (username) or not (email or password)):
return None
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
statement = """UPDATE Users SET is_active = %s""" % (str(is_active))
if email:
statement += """, email = '%s'""" % email
if password:
statement += """, password = '******'""" % password
statement += """ WHERE username = '******'""" % username
cursor.execute(statement)
self.mysql.get_db().commit()
cursor.close()
#self.mysql.get_db().close()
return User(username, email, password)
def get_all_players(self):
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
query = """SELECT player_id, first_name, last_name, nfl_team FROM Players"""
cursor.execute(query)
rows = cursor.fetchall()
cursor.close()
players = []
for row in rows:
players.append(Player(row[0], row[1], row[2], row[3]))
#self.mysql.get_db().close()
return players
def get_player(self, player_id=None, first_name=None, last_name=None, nfl_team=None):
if player_id is None and first_name is None and last_name is None and nfl_team is None:
return None
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
first = True
query = """SELECT player_id, first_name, last_name, nfl_team FROM Players WHERE """
if player_id:
query += """player_id = '%s'""" % (player_id)
first = False
if first_name:
if not first:
query += """ AND """
query += """first_name = '%s'""" % (first_name)
first = False
if last_name:
if not first:
query += """ AND """
query += """last_name = '%s'""" % (last_name)
first = False
if nfl_team:
if not first:
query += """ AND """
query += """nfl_team = '%s'""" % (nfl_team)
first = False
cursor.execute(query)
p = cursor.fetchone()
cursor.close()
#self.mysql.get_db().close()
if not p:
return None
return Player(p[0], p[1], p[2], p[3])
def insert_player(self, player_id, first_name, last_name, nfl_team):
if (not (player_id and first_name and nfl_team)):
return None
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
statement = """INSERT INTO Players (player_id, first_name, last_name, nfl_team) VALUES ('%s', '%s', '%s', '%s')""" % \
(player_id, first_name, last_name, nfl_team)
try:
cursor.execute(statement)
self.mysql.get_db().commit()
cursor.close()
self.mysql.get_db().close()
except Exception, e:
print e
return Player(player_id, first_name, last_name, nfl_team)
class Database(object):
"""Handles communication with the mysql database"""
def __init__(self, app):
self.mysql = MySQL()
self.mysql.init_app(app)
self.con = self.mysql.connect()
self.cur = self.con.cursor()
def GetCredit(self):
"""Get the total credits added
Returns:
Total credits added, in seconds
"""
self.cur.execute('select sum(seconds) from credit;')
rv = self.cur.fetchall()[0][0]
return rv and int(rv) or 0
def GetUsage(self):
"""Get the total internet usage according to the database
Returns:
Total usage in seconds
"""
self.cur.execute('select sum(duration) from record;')
rv = self.cur.fetchall()[0][0]
return rv and int(rv) or 0
def GetState(self):
"""Get the current internet state, and when that state was set
A state change is written to the 'state' table when the Internet is
enabled. It is removed when the Internet is disabled. So if there is
a state record, we know that the Internet was enabled at some point.
Returns:
tuple:
State (DISABLED or ENABLED)
Time of last state change (0 if disabled)
"""
self.cur.execute('select * from state;')
rv = self.cur.fetchall()
if not rv:
return DISABLED, 0
state, dt = rv[0]
return state, dt
def GetUsed(self):
"""Return the duration of internet that is used but not recorded yet
Returns:
Duration in seconds since the Internet was started
"""
state, dt = self.GetState()
if not state:
return 0, 0
return 1, math.floor((datetime.now() - dt).total_seconds())
def RecordEnableTime(self):
"""Record that we have started a new internet session"""
self.cur.execute('delete from state;')
self.cur.execute(
'insert into state (enabled, start) values (true, now());')
self.con.commit()
def RecordSession(self):
"""Record that the internet session has ended"""
state, start = self.GetState()
if state == DISABLED:
# We did not write a record at the start of the session, so don't
# know when it began
print 'Missing record in "state" table'
return
cmd = (
"insert into record (start, end, duration) values ('%s', now(), %d);"
% (start.strftime('%Y-%m-%d %H:%M:%S'),
(datetime.now() - start).total_seconds()))
self.cur.execute(cmd)
self.cur.execute('delete from state;')
self.con.commit()
def GetRemaining(self):
"""Get the remaining internet time in seconds
This totals all credits, subtracts all usage and also subtracts any
pending usage (the time since the Internet was started).
Returns:
Remaining time in seconds
"""
credit = self.GetCredit()
debit = self.GetUsage()
db_state, used = self.GetUsed()
return credit - debit - used
from flask import Flask
from flask_restful import Resource, Api, reqparse
from flask.ext.mysql import MySQL
mySql = MySQL()
app = Flask(__name__)
app.config['MYSQL_DATABASE_USER'] = '******'
app.config['MYSQL_DATABASE_PASSWORD'] = '******'
app.config['MYSQL_DATABASE_DB'] = 'Your_Database_Name'
app.config['MYSQL_DATABASE_HOST'] = 'localhost'
mySql.init_app(app)
api = Api(app)
class CreateUser(Resource):
#@app.route('/CreateUser', methods=['POST'])
def post(self):
try:
parser = reqparse.RequestParser()
parser.add_argument('FIRST_NAME',
type=str,
help='Enter First Name')
parser.add_argument('MIDDLE_NAME',
type=str,
help='Enter Middle Name')
parser.add_argument('LAST_NAME', type=str, help='Enter Last Name')
parser.add_argument('USERNAME', type=str, help='Enter Username')
args = parser.parse_args()
# if __name__ == '__main__':
# app.run()
from flask import Flask, render_template, json, request
from flask.ext.mysql import MySQL
from werkzeug import generate_password_hash, check_password_hash
mysql = MySQL()
app = Flask(__name__)
# MySQL configurations
app.config['MYSQL_DATABASE_USER'] = '******'
app.config['MYSQL_DATABASE_PASSWORD'] = '******'
app.config['MYSQL_DATABASE_DB'] = 'Bucketlist'
app.config['MYSQL_DATABASE_HOST'] = 'localhost'
mysql.init_app(app)
# the toolbar is only enabled in debug mode:
app.debug = True
# set a 'SECRET_KEY' to enable the Flask session cookies
app.config['SECRET_KEY'] = '<replace with a secret key>'
toolbar = DebugToolbarExtension(app)
@app.route('/')
def main():
return render_template('index.html')
@app.route('/showSignUp')
def showSignUp():
from flask import Flask, render_template, json, request
from flask.ext.mysql import MySQL
app = Flask(__name__)
mysql = MySQL()
app.config['MYSQL_DATABASE_USER'] = '******'
app.config['MYSQL_DATABASE_PASSWORD'] = '******'
app.config['MYSQL_DATABASE_DB'] = 'diradinsk'
app.config[
'MYSQL_DATABASE_HOST'] = 'mysql://*****:*****@ada.sterncs.net:3306'
"""
app.config['MYSQL_DATABASE_USER'] = '******'
app.config['MYSQL_DATABASE_PASSWORD'] = '******'
app.config['MYSQL_DATABASE_DB'] = 'lifehacks'
app.config['MYSQL_DATABASE_HOST'] = 'localhost'
mysql.init_app(app)"""
conn = mysql.connect()
cursor = conn.cursor()
@app.route("/")
def main():
return render_template('home.html')
@app.route('/post.html')
def showSignUp():
return render_template('post.html')
from flask import Flask, request, Response, jsonify;
from flask_restful import Resource, Api, reqparse;
from flask.ext.mysql import MySQL;
import json;
app = Flask(__name__);
#MySQL configurations
app.config['MYSQL_DATABASE_USER'] ='******';
app.config['MYSQL_DATABASE_PASSWORD'] ='******';
app.config['MYSQL_DATABASE_DB'] ='analysis_app_db';
app.config['MYSQL_DATABASE_HOST'] ='localhost';
mysql=MySQL();
mysql.init_app(app);
class Tag(Resource):
def get(self):
try:
query_result = execute_query("SELECT * FROM tb_tag");
data = json.dumps(query_result);
resp = Response(data, status=200, mimetype='application/json');
return resp;
except Exception as e:
return {'error':str(e)};
class Test(Resource):
def get(self):
import tweepy, requests, json
from facepy import GraphAPI
application = Flask(__name__)
application.secret_key = 'alldefdigital'
application.wsgi_app = ProxyFix(application.wsgi_app)
api = Api(application)
mysql = MySQL()
application.config['MYSQL_DATABASE_USER'] = '******'
application.config['MYSQL_DATABASE_PASSWORD'] = '******'
application.config['MYSQL_DATABASE_DB'] = 'DB1'
application.config[
'MYSQL_DATABASE_HOST'] = 'creatorsapplicants-08282016.cuhrgyuzad7j.us-west-2.rds.amazonaws.com'
mysql.init_app(application)
consumer_key = 'aYJWS2nOeqMavQAPabi3ULWtz'
consumer_secret = 'YxM7MhfBV45G105gj7v7W9oqMlzHldHAqwzz6oq5Oqp1n6Sj5q'
access_token = '2174711515-GiTm6zgUp7YjNWAEGbN1B60j6ymDgaebC5eaOHk'
access_token_secret = '1DWFca5iU1l0ig3LOk9x3U2cJ3dMOdFIaNRUmx1o166UF'
def login_required(f):
@wraps(f)
def wrap(*args, **kwargs):
if 'logged_in' in session:
return f(*args, **kwargs)
else:
flash('You need to login first')
return redirect(url_for('login'))
class Database(object):
def __init__(self, app):
self.mysql = MySQL()
self.mysql.init_app(app)
####### USERS #######
def get_all_users(self):
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
query = """SELECT uid, uname, email, pass FROM Users WHERE is_active = True"""
cursor.execute(query)
rows = cursor.fetchall()
cursor.close()
users = []
for row in rows:
users.append(User(row[0], row[1], row[2], row[3]))
return users
def get_user(self, username=None, email=None, password=None, dob=None):
if email is None and username is None:
return None
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
first = True
query = """SELECT uid, uname, email, pass, udob FROM Users WHERE """
if username:
query += """uname = '%s'""" % (username)
first = False
if email:
if not first:
query += """ AND """
query += """email = '%s'""" % (email)
first = False
if password:
if not first:
query += """ AND """
query += """pass = '******'""" % (password)
if dob:
if not first:
query += """ AND """
query += """udob = '%s'""" % (dob)
cursor.execute(query)
u = cursor.fetchone()
cursor.close()
if not u:
return None
return User(u[1], u[2], u[3], u[4], u[0])
def insert_user(self, username, email, password, dob):
if (not (username and email and password)):
return None
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
statement = """INSERT INTO Users (uname, email, pass, udob) VALUES ('%s', '%s', '%s', '%s')""" % (username, email, password, dob)
cursor.execute(statement)
self.mysql.get_db().commit()
cursor.close()
return User(username, email, password, dob)
def update_user(self, username, email=None, password=None, is_active=True):
if (not (username) or not (email or password)):
return None
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
statement = """UPDATE Users SET is_active = %s""" % (str(is_active))
if email:
statement += """, email = '%s'""" % email
if password:
statement += """, pass = '******'""" % password
statement += """WHERE uname = '%s'""" % unsername
cursor.execute(statement)
self.mysql.get_db().commit()
cursor.close()
return User(username, email, password)
####### MOVIES #######
def get_people_like(self, pname, limit=10):
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
query = """SELECT pid, pname FROM People WHERE pname LIKE '%s%%' OR pname LIKE '%%%s' OR pname LIKE '%%%s%%' LIMIT %s;""" % (pname, pname, pname, limit)
cursor.execute(query)
results = cursor.fetchall()
cursor.close()
r = []
for result in results:
r.append(dict(id=result[0],name=result[1]))
return json.dumps(r)
def get_movies_like(self, title, limit=5):
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
query = """SELECT mid, title FROM Movies WHERE title LIKE '%s%%' OR title LIKE '%%%s' OR title LIKE '%%%s%%' LIMIT %s;""" % (title, title, title, limit)
cursor.execute(query)
results = cursor.fetchall()
cursor.close()
r = []
for result in results:
r.append(dict(id=result[0],name=result[1]))
return json.dumps(r)
def get_genres_like(self, gname, limit=5):
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
query = """SELECT gid, gname FROM Genres WHERE gname LIKE '%s%%' OR gname LIKE '%%%s' OR gname LIKE '%%%s%%' LIMIT %s;""" % (gname, gname, gname, limit)
cursor.execute(query)
results = cursor.fetchall()
cursor.close()
r = []
for result in results:
r.append(dict(id=result[0],name=result[1]))
return json.dumps(r)
def get_movie_by_id(self, mid):
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
cols = "mid,title,mdate,runtime,languages,description,budget,box_office,country"
query = """SELECT %s FROM Movies WHERE mid='%s';""" % (cols, mid)
cursor.execute(query)
movie = list(cursor.fetchone())
cursor.close()
r = {}
lcols = cols.split(",")
movie[2] = movie[2].year
for (num,val) in enumerate(movie):
r[lcols[num]] = val
return Movie(*r)
def get_movie_by_id(self, mid):
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
cols = "mid,title,mdate,runtime,languages,description,budget,box_office,country"
#mids = ','.join(["'%s'" % (val) for val in mid])
query = """SELECT %s FROM Movies WHERE mid='%s';""" % (cols, mid)
cursor.execute(query)
results = cursor.fetchone()
cursor.close()
if not results:
return None
movie = list(results)
if movie[2]:
movie[2] = movie[2].year
return Movie(*movie)
def get_people_from_movie(self, mid):
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
cols = "People.pid,pname,pdob"
lcols = cols.split(",")
query = """SELECT %s FROM Involved_In INNER JOIN People ON People.pid=Involved_In.pid WHERE mid='%s'""" % (cols, mid)
cursor.execute(query)
results = cursor.fetchall()
cursor.close()
results = [list(result) for result in results]
people = []
for person in results:
if person[2]:
person[2] = person[2].year
else:
person[2] = '0000'
people.append(Person(*person))
return people
def get_all_credits_by_person(self, pid):
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
cols = "Movies.mid,Movies.title,directed,produced,wrote,composed,acted"
lcols = cols.split(",")
query = """SELECT %s FROM Involved_In INNER JOIN Movies ON Involved_In.mid=Movies.mid WHERE pid='%s'""" % (cols, pid)
cursor.execute(query)
results = list(cursor.fetchall())
cursor.close()
credits = []
for credit in results:
c = {}
for (num,val) in enumerate(credit):
c[lcols[num]] = val
credits.append(c)
return json.dumps(credits)
def get_movie_credits_by_person(self, mid, pid):
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
cols = "pid,mid,directed,produced,wrote,composed,acted"
lcols = cols.split(",")
query = """SELECT %s FROM Involved_In WHERE pid='%s' AND mid='%s'""" % (cols, pid, mid)
cursor.execute(query)
results = list(cursor.fetchone())
cursor.close()
credit = Credit(*results)
return credit
def get_genre(self, mid):
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
cols = "gid,gname"
query = """SELECT %s FROM Genres WHERE gid IN (SELECT gid FROM Is_Genre WHERE mid='%s');""" % (cols,mid)
cursor.execute(query)
results = cursor.fetchall()
cursor.close()
results = [list(result) for result in results]
genres = [Genre(*x) for x in results]
return genres
def get_movies_by_genre(self, gid, limit=20):
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
query = """SELECT mid FROM Is_Genre WHERE gid=%s ORDER BY RAND() LIMIT %s;""" % (gid, limit)
cursor.execute(query)
results = cursor.fetchall()
cursor.close()
results = [result[0] for result in results]
return results #mids
def get_genre_name(self, gid):
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
query = """SELECT gname FROM Genres WHERE gid=%s;""" % (gid)
cursor.execute(query)
results = cursor.fetchone()
cursor.close()
if not results:
return None
result = results[0]
return result
def get_person_name(self, pid):
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
query = """SELECT pname FROM People WHERE pid=%s;""" % (pid)
cursor.execute(query)
results = cursor.fetchone()
cursor.close()
if not results:
return None
result = results[0]
return result #pids
def get_movies_by_person(self, pid):
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
cols = "Involved_In.mid,mdate,title,directed,produced,wrote,composed,acted"
query = """SELECT %s FROM Involved_In JOIN Movies ON Involved_In.mid=Movies.mid WHERE pid=%s;""" % (cols,pid)
cursor.execute(query)
results = cursor.fetchall()
cursor.close()
lcols = cols.split(",")
lcols[0] = "mid"
if not results:
return None
results = [list(result) for result in results]
for i in xrange(len(results)):
if results[i][1]:
results[i][1] = results[i][1].year
movies = []
for idx1,m in enumerate(results):
tmp = {}
for idx2,col in enumerate(lcols):
tmp[col]=m[idx2]
movies.append(DTmp(**tmp))
return movies
def rate(self, table, uid, pkey_name, oid, rating):
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
query = """INSERT INTO %s (uid,%s,urating) VALUES ('%s','%s','%s') ON DUPLICATE KEY UPDATE urating=VALUES(urating)""" % (table, pkey_name, uid, oid, rating)
cursor.execute(query)
results = cursor.fetchone()
self.mysql.get_db().commit()
cursor.close()
if not results:
return None
results = list(results)
return results
def get_rating(self, table, uid, pkey_name, oid):
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
query = """SELECT urating FROM %s WHERE uid=%s AND %s='%s';""" % (table, uid, pkey_name, oid)
cursor.execute(query)
results = cursor.fetchone()
cursor.close()
if not results:
return False, 0
return True, results[0]
def recommend(self, uid, limit=15):
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
query = """
SELECT mid,title
FROM Movies
WHERE mid IN (
SELECT DISTINCT(mid)
FROM Movies
WHERE mid IN (
SELECT mid
FROM Involved_In
WHERE pid IN (
SELECT pid
FROM Likes_Person
WHERE uid={0}
ORDER BY urating DESC
)
)
OR mid IN (
SELECT mid
FROM Involved_In
WHERE pid IN (
SELECT pid
FROM Involved_In
JOIN Has_Watched
ON Involved_In.mid=Has_Watched.mid
WHERE uid={0}
ORDER BY urating DESC
)
)
)
AND mid NOT IN (
SELECT mid
FROM Has_Watched
WHERE uid={0}
)
ORDER BY RAND()
LIMIT {1};"""
query = query.format(uid, limit)
cursor.execute(query)
results = cursor.fetchall()
cursor.close()
results = [DTmp(**{'mid': r[0], 'title': r[1]}) for r in results]
return results
def recommend_better(self, uid, limit=30):
self.mysql.before_request()
cursor = self.mysql.get_db().cursor()
query = """
SELECT m.mid,m.title,i.pid,AVG(Likes_Person.urating) AS urt
FROM Movies m
JOIN Involved_In i
ON m.mid=i.mid
LEFT OUTER JOIN Likes_Person
ON i.pid=Likes_Person.pid
WHERE m.mid IN (
SELECT DISTINCT(mm.mid)
FROM Movies mm
WHERE mm.mid IN (
SELECT ii.mid
FROM Involved_In ii
WHERE ii.pid IN (
SELECT lp.pid
FROM Likes_Person lp
WHERE uid={0}
ORDER BY lp.urating DESC
)
)
OR mm.mid IN (
SELECT iii.mid
FROM Involved_In iii
WHERE iii.pid IN (
SELECT iiii.pid
FROM Involved_In iiii
JOIN Has_Watched hhhh
ON iiii.mid=hhhh.mid
WHERE uid={0}
ORDER BY hhhh.urating DESC
)
)
)
AND m.mid NOT IN (
SELECT hw.mid
FROM Has_Watched hw
WHERE uid={0}
)
GROUP BY m.mid
ORDER BY urt DESC
LIMIT {1};"""
query = query.format(uid, limit)
cursor.execute(query)
results = cursor.fetchall()
cursor.close()
results = [DTmp(**{'mid': r[0], 'title': r[1], 'score': r[3] if r[3] else float(0.0)}) for r in results]
return results
from werkzeug import secure_filename
from mimetypes import MimeTypes
import os
import time
import logging
import boto3
from boto3.s3.transfer import S3Transfer
from config import *
image_uploader = Flask(__name__)
mysql = MySQL()
image_uploader.config['MYSQL_DATABASE_USER'] = DB_USER
image_uploader.config['MYSQL_DATABASE_PASSWORD'] = DB_PASS
image_uploader.config['MYSQL_DATABASE_DB'] = DB_NAME
image_uploader.config['MYSQL_DATABASE_HOST'] = DB_HOST
mysql.init_app(image_uploader)
#
# Help functions
#
def allowed(filename):
return '.' in filename and filename.rsplit('.', 1)[1] in IMAGE_TYPES
def put_s3_objetct(image_name, storage_dir):
mime = MimeTypes()
s3 = boto3.client('s3', region_name=AWS_REGION)
transfer = S3Transfer(s3)
image_path = os.path.join(UPLOAD_DIR, image_name)
key_name = storage_dir + "/" + image_name
transfer.upload_file(image_path, BUCKET_NAME, key_name, extra_args={'ContentType': mime.guess_type(image_path)[0]})
from flask import Flask, render_template, json, request
from flask.ext.mysql import MySQL
from werkzeug import generate_password_hash, check_password_hash
mysql = MySQL()
application = app = Flask(__name__)
# MySQL configurations
"""
application.config['MYSQL_DATABASE_USER'] = '******'
application.config['MYSQL_DATABASE_PASSWORD'] = '******'
application.config['MYSQL_DATABASE_DB'] = 'signup'
application.config['MYSQL_DATABASE_HOST'] = 'signup.cfj54gpjcmhy.us-west-2.rds.amazonaws.com:3306'
mysql.init_app(application)"""
@app.route('/')
def main():
return render_template('index.html')
@app.route('/showSignUp')
def showSignUp():
return render_template('signup.html')
@app.route('/signUp',methods=['POST','GET'])
def signUp():
try:
_name = request.form['inputName']
_email = request.form['inputEmail']
_password = request.form['inputPassword']
app.secret_key = 'why would I tell you my secret key?'
mysql = MySQL()
# q = Queue()
q = []
current_song = ''
prev_song = ''
# MySQL configurations
app.config['MYSQL_DATABASE_USER'] = '******'
app.config['MYSQL_DATABASE_PASSWORD'] = '******'
app.config['MYSQL_DATABASE_DB'] = 'Music'
app.config['MYSQL_DATABASE_HOST'] = 'localhost'
mysql.init_app(app)
import thread
import threading
lock = threading.Lock()
def remove_elemnt():
global q
l = len(q)
if l < 1:
return []
else:
return q[1:]
import datetime
from flask import Flask, json, request, session, redirect, url_for, abort, render_template, flash
from contextlib import closing
from flask.ext.mysql import MySQL
app = Flask(__name__)
app.config['MYSQL_DATABASE_USER'] = '******'
app.config['MYSQL_DATABASE_PASSWORD'] = '******'
app.config['MYSQL_DATABASE_DB'] = 'tododb'
app.config['MYSQL_DATABASE_HOST'] = '23.253.70.25'
app.config['MYSQL_DATABASE_PORT'] = 3306
db = MySQL()
db.init_app(app)
# ROUTES
# Index page gets passed on information about tasks
@app.route("/")
def index():
conn = db.connect()
cursor = conn.cursor()
cursor.callproc('get_table', ())
tasks = [dict(id=row[0], title=row[1], descr=row[2], done=row[3], dline=row[4], finish=row[5]) for row in cursor.fetchall()]
cursor.close()
conn.close()
return render_template('index.html', tasks=tasks)
# Adds new task to list and stores relevant information
@app.route('/add', methods=['POST'])
def add_entry():
_title = request.form['title']
