def startdb(inapp):
mysql = MySQL()
inapp.config['MYSQL_DATABASE_USER'] = '******'
inapp.config['MYSQL_DATABASE_PASSWORD'] = '******'
inapp.config['MYSQL_DATABASE_DB'] = 'EmpData'
inapp.config['MYSQL_DATABASE_HOST'] = 'localhost'
mysql.init_app(inapp)
class DataBase:
def __init__(self):
self.mysql = MySQL()
self.mysql.init_app(app)
def get_mysql(self):
return self.mysql
def conexion(self):
mysql = MySQL()
control = Flask(__name__)
control.config['MYSQL_DATABASE_USER'] = '******'
control.config['MYSQL_DATABASE_PASSWORD'] = '******'
control.config['MYSQL_DATABASE_DB'] = 'wtec_webapp'
control.config['MYSQL_DATABASE_HOST'] = '192.168.227.135'
mysql.init_app(control)
return mysql
def __init__(self):
# MySQL configurations
mysql = MySQL()
app.config['MYSQL_DATABASE_USER'] = '******'
app.config['MYSQL_DATABASE_PASSWORD'] = '******'
app.config['MYSQL_DATABASE_DB'] = 'qh_logistics'
app.config['MYSQL_DATABASE_HOST'] = 'localhost'
mysql.init_app(app)
self.conn = mysql.connect()
def startConnection(self): mysql = MySQL() # MySQL configurations self.app.config['MYSQL_DATABASE_USER'] = self.username self.app.config['MYSQL_DATABASE_PASSWORD'] = self.password self.app.config['MYSQL_DATABASE_DB'] = self.dbname self.app.config['MYSQL_DATABASE_HOST'] = self.host mysql.init_app(self.app) Dbconn = mysql.connect() return Dbconn
class DataBase():
# 커넥션 맺자
def __init__(self):
self.mysql = MySQL()
self.mysql.init_app(app)
self.connection = self.mysql.connect()
self.connection.autocommit(True)
# 쿼리 실행
def execute(self, query):
cursor = self.connection.cursor(MySQLdb.cursors.DictCursor)
cursor.execute(query)
return cursor
def create_database(app, sqlpie_config):
config_mysql = MySQL()
env = sqlpie.DBSetup.environment()
curr_db_config = sqlpie_config['db'][env]['mysql_database_db']
app.config['MYSQL_DATABASE_DB'] = "mysql"
app.config['MYSQL_DATABASE_PASSWORD'] = sqlpie_config['db'][env]['mysql_database_password']
app.config['MYSQL_DATABASE_USER'] = sqlpie_config['db'][env]['mysql_database_user']
app.config['MYSQL_DATABASE_HOST'] = sqlpie_config['db'][env]['mysql_database_host']
app.config['MYSQL_DATABASE_PORT'] = sqlpie_config['db'][env]['mysql_database_port']
config_mysql.init_app(app)
try:
local_conn = config_mysql.connect()
local_cursor = local_conn.cursor()
drop_db_sql_command = "DROP DATABASE IF EXISTS SQLpie_%s; " % (env);
local_cursor.execute(drop_db_sql_command)
local_cursor.close()
local_cursor = local_conn.cursor()
create_db_sql_command = "CREATE DATABASE SQLpie_%s; " % (env);
use_db_sql_command = "USE SQLpie_%s; " % (env);
f = open("sqlpie/db/sql/schema.sql","r")
schema = f.read()
sql_commands = create_db_sql_command + use_db_sql_command + schema
local_cursor.execute(sql_commands)
local_cursor.close()
local_cursor = local_conn.cursor()
f = open("sqlpie/db/sql/seed.sql","r")
seed_commands = f.read()
sql_commands = use_db_sql_command + seed_commands
local_cursor.execute(seed_commands)
local_conn.commit()
print "Successfully created SQLpie_%s database on %s server." % (env, sqlpie_config['db'][env]['mysql_database_host'])
except Exception as e:
print "[Error] creating SQLpie_%s database on %s server." % (env, sqlpie_config['db'][env]['mysql_database_host'])
if sqlpie.Util.is_debug():
traceback.print_tb(sys.exc_info()[2])
finally:
try:
local_cursor.close()
local_conn.close()
except:
pass
app.config['MYSQL_DATABASE_DB'] = curr_db_config
from flask import Flask, render_template, request, json, redirect, session, flash
from flaskext.mysql import MySQL
from werkzeug.security import generate_password_hash, check_password_hash
app = Flask(__name__)
app.secret_key = 'why would I tell you my secret key?'
mysql = MySQL() # # # # # # # #
app.config[
'MYSQL_DATABASE_USER'] = '******' # Create my MySQL Object named mysql #
app.config[
'MYSQL_DATABASE_PASSWORD'] = '******' # #
app.config[
'MYSQL_DATABASE_DB'] = 'what' # MySQL configurations (Todo move to config.file) #
app.config[
'MYSQL_DATABASE_HOST'] = 'localhost' # #
mysql.init_app(app) # Start MySQL Application inside Flask #
# # # # # # # #
# # # # Function endpoints Frontpage # # # # # # # #
#When user hits signup DO::
@app.route('/test')
def test():
return render_template('test.html')
@app.route('/')
def index():
return render_template('test.html')
import sys
sys.path.append("..")
from flask import redirect, url_for
from flaskext.mysql import MySQL
mysql = MySQL()
appHandler.config['MYSQL_DATABASE_USER'] = '******'
appHandler.config['MYSQL_DATABASE_PASSWORD'] = '******'
appHandler.config['MYSQL_DATABASE_DB'] = 'kups'
appHandler.config['MYSQL_DATABASE_HOST'] = 'localhost'
mysql.init_app(appHandler)
class LoginController:
def authenticate(self,form):
username = form['username']
password = form['password']
cursor = mysql.connect().cursor
cursor.execute("select * from users where username='******' and password='******'")
data = cursor.fetchone();
if data is None :
return "Username or Password is Wrong"
else :
return 'Login Successful'
from flask import Flask, request, send_file;
from flaskext.mysql import MySQL;
import json;
import os;
UPLOAD_FOLDER = "/User/Taejun/Documents/nexta/image"
app = Flask(__name__);
mysql = MySQL();
app.config['MYSQL_DATABASE_USER'] = '******';
app.config['MYSQL_DATABASE_PASSWORD'] = '******';
app.config['MYSQL_DATABASE_DB'] = 'nextagram';
mysql.init_app(app);
@app.route("/")
def helloWrold():
return "helloWrold";
@app.route("/loadData", methods = ["GET", "POST"])
def loadData():
cursor = mysql.connect().cursor();
cursor.execute("select * from next_android_nextagram")
result = []
columns = tuple( [d[0] for d in cursor.description] )
for row in cursor:
result.append(dict(zip(columns, row)))
def init_db(app, run_db):
if run_db:
mysql = MySQL()
database_setup.add_config_params(app)
mysql.init_app(app)
from flask import Flask, request, jsonify
from flaskext.mysql import MySQL
from flask_api import status
from os import system
app = Flask(__name__)
mySql = MySQL()
config = {}
execfile("settings.conf", config)
app.config['MYSQL_DATABASE_USER'] = config['user']
app.config['MYSQL_DATABASE_PASSWORD'] = config['password']
app.config['MYSQL_DATABASE_DB'] = config['database']
app.config['MYSQL_DATABASE_HOST'] = config['host']
mySql.init_app(app)
conn = mySql.connect()
@app.route("/led", methods=['POST'])
def led():
print(request)
_message = request.json['message']
try:
cursor = conn.cursor()
cursor.execute("insert into Messages(message) values (%s)", _message)
conn.commit()
system('python ledbadge.py effect=left speed=5 "'+_message+'"')
cursor.close()
except conn.IntegrityError:
return jsonify({'status': 'Failed'}), status.HTTP_500_INTERNAL_SERVER_ERROR
from flask import Flask from flaskext.mysql import MySQL dir_app = Flask(__name__) dir_mysql = MySQL() dir_app.config['MYSQL_DATABASE_USER'] = '******' dir_app.config['MYSQL_DATABASE_PASSWORD'] = '******' dir_app.config['MYSQL_DATABASE_DB'] = 'directory' dir_app.config['MYSQL_DATABASE_HOST'] = 'colab-sbx-245.oit.duke.edu' dir_mysql.init_app(dir_app) cal_app = Flask(__name__) cal_mysql = MySQL() cal_app.config['MYSQL_DATABASE_USER'] = '******' cal_app.config['MYSQL_DATABASE_PASSWORD'] = '******' cal_app.config['MYSQL_DATABASE_DB'] = 'calendar' cal_app.config['MYSQL_DATABASE_HOST'] = 'colab-sbx-245.oit.duke.edu' cal_mysql.init_app(cal_app)
def create_app(test_config=None):
# create and configure the app
app = Flask(__name__, instance_relative_config=True)
app.config['MYSQL_DATABASE_HOST'] = 'localhost'
app.config['MYSQL_DATABASE_USER'] = '******'
app.config['MYSQL_DATABASE_PASSWORD'] = '******'
app.config['MYSQL_DATABASE_DB'] = 'tododb'
mysql = MySQL(app)
mysql.init_app(app)
# ensure the instance folder exists
try:
os.makedirs(app.instance_path)
except OSError:
pass
#MODEL STRATS HERE
def get_from_db(name):
conn=mysql.connect()
cur=conn.cursor()
cur.execute("SELECT work FROM todolisttable WHERE name = %s",(name))
data=cur.fetchall()
data1=[A[0] for A in data]
conn.commit()
if len(data1) == 0 :
return None
return data1
def get_todos_by_name(name):
try:
return get_from_db(name)
except:
return None
def add_in_list(name,work):
conn=mysql.connect()
cur = conn.cursor()
cur.execute("INSERT INTO todolisttable(name, work) VALUES (%s, %s)", (name, work))
conn.commit()
#mysql.connection.commit()
#cur.close()
return
def verify_before_add(name,work):
return add_in_list(name,work)
#MODELS ENDS HERE
#...............................................................................................................#
#CONTROLLER STARTS HERE
@app.route('/add_todo')
def add_todo():
name=request.args.get('name')
work=request.args.get('work')
verify_before_add(name,work)
return 'ADDED SUCCESFULLY'
# a simple page that list my todos
@app.route('/todos')
def todos():
name = request.args.get('name')
dolist = get_todos_by_name(name)
if dolist!=None :
return render_template('todo_view.html',worklist = dolist)
else :
return render_template('404.html'),404
#...................................................................................................................#
return app
from flask import Flask
from flask_restful import Api
from flaskext.mysql import MySQL
import config
from api_get_user import GetUser
from api_register import RegisterUser
mysql = MySQL()
app = Flask(__name__)
api = Api(app)
mysql.init_app(config.db_config(app))
api.add_resource(GetUser, '/get_user', resource_class_kwargs={'mysql': mysql})
api.add_resource(RegisterUser,
'/register_user',
resource_class_kwargs={'mysql': mysql})
if __name__ == '__main__':
app.run(debug=True)
import os
import sys
# Import flask and template operators & SQLAlchemy
from flask import Flask, render_template
from flaskext.mysql import MySQL
# Define the WSGI application object & Configurations
weblogin = Flask(__name__)
weblogin.config.from_object('config')
# Database
mysql = MySQL()
mysql.init_app(weblogin)
# Configure Secret Key
def install_secret_key(weblogin, filename='secret_key'):
# Configure the SECRET_KEY from a file
# in the instance directory.
# If the file does not exist, print instructions
# to create it from a shell with a random key,
# then exit.
filename = os.path.join(weblogin.instance_path, filename)
try:
weblogin.config['SECRET_KEY'] = open(filename, 'rb').read()
except IOError:
print('Error: No secret key. Create it with:')
full_path = os.path.dirname(filename)
if not os.path.isdir(full_path):
def create_app():
mysql = MySQL()
app = Flask(__name__)
app.secret_key = 'webtechproject'
app_data = {
"name": "Disease Identification Using Images",
"description": "Flask application for WT-2 Project",
"author": "Harsh Garg, Gaurav Peswani, Hardik Mahipal Surana",
"html_title": "Home",
"project_name": "Disease Identification Using Images",
"keywords": "flask, webapp, machine learning"
}
app.config["MYSQL_DATABASE_USER"] = '******'
app.config["MYSQL_DATABASE_PASSWORD"] = '******'
app.config["MYSQL_DATABASE_DB"] = "leafDiseaseIdentification"
app.config["MYSQL_DATABASE_HOST"] = "localhost"
mysql.init_app(app)
photos = UploadSet('photos', IMAGES)
app.config['UPLOADED_PHOTOS_DEST'] = './static/'
configure_uploads(app, photos)
@app.route('/')
def index():
return render_template('index.html', app_data=app_data)
@app.route("/login", methods=["GET", "POST"])
def login():
if (request.method == "GET"):
return render_template("login.html")
elif (request.method == "POST"):
POST_USERNAME = str(request.form["username"])
POST_PASSWORD = str(request.form["password"])
print(POST_USERNAME)
print(POST_PASSWORD)
session["username"] = POST_USERNAME
query = "SELECT name from register where username='******'"
print("query is ", query)
conn = mysql.connect()
cursor = conn.cursor()
res = cursor.execute(query)
data = cursor.fetchall()
print("data for details of user is ", data)
nameOfUser = data[0][0]
session["nameOfUser"] = nameOfUser
print("session['username'] is ", session["username"])
# Make DB query to see if User with 'email' and 'acc_type'
# has the same password as in the DB.
result = models.loginCheck(mysql, POST_USERNAME, POST_PASSWORD)
# if (result=="Error"):
# flash("Error")
print("result is ", result)
if (result == True):
return redirect(url_for("classify_tomato"))
else:
flash('wrong password!')
return redirect(url_for("login"))
else:
flash("Error")
@app.route('/b1')
def b1():
return render_template('b1.html', app_data=app_data)
# # getting our trained model from a file we created earlier
model = pickle.load(open("./model/model.pkl", "rb"), encoding='utf-8')
@app.route("/register", methods=["GET", "POST"])
def register_user():
if (request.method == "GET"):
# print("nameList is ",nameList)
# print("emailList is ",emailList)
# print("usernamesList is ",usernamesList)
# print("passwordList is ",passwordList)
return render_template("register.html", title="Patient")
elif (request.method == "POST"):
newUserDict = {
"name": str(request.form["name"]),
"email": str(request.form["email"]),
"username": str(request.form["username"]),
"password": str(request.form["password"]),
}
if not models.isExistingUser(mysql, newUserDict["username"]):
# nameList.append(newUserDict["name"])
# emailList.append(newUserDict["email"])
# usernamesList.append(newUserDict["username"])
# passwordList.append(newUserDict["password"])
res = models.insertNewUser(mysql, newUserDict)
if (res == True):
return redirect(url_for("login"))
else:
return redirect(url_for("register"))
else:
return redirect(url_for("login"))
@app.route('/predict', methods=['POST'])
def predict():
#grabbing a set of wine features from the request's body
feature_array = json.loads(request.data)['feature_array']
# feature_array = request.get_json()['feature_array']
#our model rates the wine based on the input array
prediction = model.predict([feature_array]).tolist()
#preparing a response object and storing the model's predictions
response = {}
response['predictions'] = prediction
#sending our response object back as json
return jsonify(response)
# getting our trained model from a file we created earlier
# model = pickle.load(open("./model/data/model_info/alexnet_trained_model.pkl","rb"), encoding='utf-8')
@app.route('/classify_tomato', methods=['GET', 'POST'])
def classify_tomato():
if request.method == 'POST' and 'photo' in request.files:
filename = photos.save(request.files['photo'])
result = predict_disease('./static/' + filename)
return render_template('result.html', app_data={"result": result})
return render_template('upload.html',
app_data=app_data,
name=session["nameOfUser"])
@app.route('/logout', methods=["GET", "POST"])
def logout():
print("Inside logout")
if (request.method == "GET"
and request.args.get("logout", "", type=int) == 1):
try:
session.pop("username")
except KeyError:
pass
try:
session.pop("nameOfUser")
except:
pass
return redirect(url_for("login"))
return render_template("login.html")
# @app.route('/getDetailsOfUser', methods=['GET','POST'])
# def getDetailsOfUser():
# if(request.method == 'GET'):
# # res = models.getDetailsOfUser(mysql,session["username"])
# query = "SELECT name from register where username='******'"
# print("query is ",query)
# conn = mysql.connect()
# cursor = conn.cursor()
# res = cursor.execute(query)
# data = cursor.fetchall()
# print("data for details of user is ",data)
# nameOfUser = data[0][0]
# return render_template("register.html",title="Patient")
@app.route('/fetch_multistage', methods=['GET'])
def fetch_multistage():
print(request.files)
FILES_LOC = "/home/harshgarg/Desktop/7thSem/WebTech-Project/WT-2/code/flaskr/static/text_for_msd/"
if request.method == 'GET':
if request.args.get("image", "", type=int) == 1:
FILE_NAME = "images.json"
elif request.args.get("link", "", type=int) == 1:
FILE_NAME = "links.json"
else:
FILE_NAME = "content.json"
file_ = open(FILES_LOC + FILE_NAME, 'r')
res = file_.read()
# print(res, type(res))
return res
return "Invalid fetch"
return app
from flask import Flask, render_template, json, request
from flaskext.mysql import MySQL
#from werkzeug import generate_password_hash, check_password_hash
app = Flask(__name__)
alex = MySQL()
# MySQL configurations
app.config['MYSQL_DATABASE_USER'] = '******'
app.config['MYSQL_DATABASE_PASSWORD'] = '******'
app.config['MYSQL_DATABASE_DB'] = 'Bucketlist'
app.config['MYSQL_DATABASE_HOST'] = 'localhost'
alex.init_app(app)
conn = alex.connect()
cursor = conn.cursor()
cursor.callproc('sp_createUser', ("name", "email", "password"))
data = cursor.fetchall()
if len(data) is 0:
conn.commit()
return json.dumps({'message': 'User created successfully !'})
else:
return json.dumps({'error': str(data[0])})
@app.route("/")
def main():
return render_template("index.html")
from flask import current_app from flaskext.mysql import MySQL mysql_mod = MySQL() mysql_mod.init_app(current_app) mysql = mysql_mod.connect()
from flask import Flask
from random import randint
from flaskext.mysql import MySQL
mysql = MySQL()
application = Flask(__name__)
application.debug = True
application.config['MYSQL_DATABASE_USER'] = '******'
application.config['MYSQL_DATABASE_PASSWORD'] = '******'
application.config['MYSQL_DATABASE_DB'] = 'flask_test'
application.config['MYSQL_DATABASE_HOST'] = 'localhost'
mysql.init_app(application)
@application.route('/')
def hello_world():
return 'Hello World!'
@application.route('/test')
def test():
# print str(randint(1, 100))
return str(randint(1, 100))
@application.route("/dbtest")
def dbtest():
cursor = mysql.connect().cursor()
cursor.execute("SELECT * from testtable")
from flask import render_template, flash, redirect, request, session
from flaskext.mysql import MySQL
from app import myApp
from .forms import LoginForm, RegisterForm, EventForm
#can use variable parts to url with <variable_name> or convertor with <convertor:varname>
# can use int, float, and path as convertor (path accepts slashes)
# urls endind in / will work both with and without slash, without slash, it has to match
mysql = MySQL()
myApp.config['MYSQL_DATABASE_USER'] = '******'
myApp.config['MYSQL_DATABASE_PASSWORD'] = '******'
myApp.config['MYSQL_DATABASE_DB'] = 'watchWithMe'
myApp.config['MYSQL_DATABASE_HOST'] = 'localhost'
mysql.init_app(myApp)
@myApp.route('/')
@myApp.route('/index')
def index():
db = mysql.connect()
cursor = db.cursor()
if 'userName' in session:
cursor.execute("SELECT First, PID FROM Person WHERE Username=%s", [session['userName']])
result = cursor.fetchone()
name = "%s" % result[0]
PID = "%s" % result[1]
cursor.execute("""SELECT Name, Time, date, Title, Genre, e.EID
FROM Event as e, Media as m, EventHasMedia as ehm, Attend as a, Media_2 as mtwo
from flask import Flask, render_template, request, json, session, redirect, url_for, escape, flash
from hashlib import md5
from flaskext.mysql import MySQL
import os
application = Flask(__name__)
mysql = MySQL()
# MySQL configurations
application.config['MYSQL_DATABASE_USER'] = '******'
application.config['MYSQL_DATABASE_PASSWORD'] = '******'
application.config['MYSQL_DATABASE_DB'] = 'qa_course'
application.config['MYSQL_DATABASE_HOST'] = '52.2.195.57'
application.secret_key = 'FEF9B%399-!8EF6- 4B16-[9BD4-092B1<85D632D'
mysql.init_app(application)
class ServerError(Exception):
pass
@application.errorhandler(404)
def page_not_found(e):
# return render_template('index.html'), 404
return render_template('WIP.html'), 404
@application.route("/index")
@application.route("/")
def index():
if 'username' in session:
from flask import Flask, render_template, request, url_for, redirect
from flaskext.mysql import MySQL
from os import path, makedirs
from werkzeug.utils import secure_filename
from database import *
app = Flask(__name__)
bd = MySQL()
bd.init_app(app)
upload_dir = ('static')
makedirs(upload_dir, exist_ok=True)
# verificar se o funcionário está logado type 1 = gerente / type 0 = vendedor
login_type = None
login_name = None
@app.route('/')
def home(erro=None):
conn = bd.connect()
cursor = conn.cursor()
vips = show_vips(cursor)
cursor.close()
conn.close()
return render_template('index.html')
@app.route('/cadastro_carro')
def insercao(erro=None):
if login_type:
return render_template('inserir.html', erro=erro, logado=login_type)
class DBSetup(object):
def __init__(self, config={}):
self.config = config
def init(self, app):
self.mysql = MySQL()
params = self.get_database_params()
app.config['MYSQL_DATABASE_USER'] = params['MYSQL_DATABASE_USER']
app.config['MYSQL_DATABASE_PASSWORD'] = params['MYSQL_DATABASE_PASSWORD']
app.config['MYSQL_DATABASE_DB'] = params['MYSQL_DATABASE_DB']
app.config['MYSQL_DATABASE_HOST'] = params['MYSQL_DATABASE_HOST']
app.config['MYSQL_DATABASE_PORT'] = params['MYSQL_DATABASE_PORT']
self.mysql.init_app(app)
def db(self):
return self.mysql
def get_database_params(self):
ret = {}
if os.environ.get('mysql_database_user') and os.environ.get('mysql_database_password') and \
os.environ.get('mysql_database_db') and os.environ.get('mysql_database_host') and \
os.environ.get('mysql_database_port'):
ret['MYSQL_DATABASE_USER'] = os.environ.get('mysql_database_user')
ret['MYSQL_DATABASE_PASSWORD'] = os.environ.get('mysql_database_password')
ret['MYSQL_DATABASE_DB'] = os.environ.get('mysql_database_db')
ret['MYSQL_DATABASE_HOST'] = os.environ.get('mysql_database_host')
ret['MYSQL_DATABASE_PORT'] = int(os.environ.get('mysql_database_port'))
else:
env = sqlpie.DBSetup.environment()
if env in self.config['db']:
ret['MYSQL_DATABASE_USER'] = self.config['db'][env]['mysql_database_user']
ret['MYSQL_DATABASE_PASSWORD'] = self.config['db'][env]['mysql_database_password']
ret['MYSQL_DATABASE_DB'] = self.config['db'][env]['mysql_database_db']
ret['MYSQL_DATABASE_HOST'] = self.config['db'][env]['mysql_database_host']
ret['MYSQL_DATABASE_PORT'] = int(self.config['db'][env]['mysql_database_port'])
else:
ret['MYSQL_DATABASE_USER'] = None
ret['MYSQL_DATABASE_PASSWORD'] = None
ret['MYSQL_DATABASE_DB'] = None
ret['MYSQL_DATABASE_HOST'] = None
ret['MYSQL_DATABASE_PORT'] = None
return ret
@staticmethod
def environment():
env = "development"
if os.environ.get('sqlpie_env'):
env = os.environ.get('sqlpie_env').lower()
return env
@staticmethod
def reset_database():
sqlpie.Bucket.reset()
sqlpie.Document.reset()
sqlpie.Content.reset()
sqlpie.Term.reset()
sqlpie.ContentKey.reset()
sqlpie.ContentTerm.reset()
sqlpie.RankingIDF.reset()
sqlpie.RankingTF.reset()
sqlpie.Observation.reset()
sqlpie.Predicate.reset()
sqlpie.Cache.reset()
sqlpie.Model.reset()
sqlpie.ModelClassifier.reset()
@staticmethod
def create_database(app, sqlpie_config):
config_mysql = MySQL()
env = sqlpie.DBSetup.environment()
curr_db_config = sqlpie_config['db'][env]['mysql_database_db']
app.config['MYSQL_DATABASE_DB'] = "mysql"
app.config['MYSQL_DATABASE_PASSWORD'] = sqlpie_config['db'][env]['mysql_database_password']
app.config['MYSQL_DATABASE_USER'] = sqlpie_config['db'][env]['mysql_database_user']
app.config['MYSQL_DATABASE_HOST'] = sqlpie_config['db'][env]['mysql_database_host']
app.config['MYSQL_DATABASE_PORT'] = sqlpie_config['db'][env]['mysql_database_port']
config_mysql.init_app(app)
try:
local_conn = config_mysql.connect()
local_cursor = local_conn.cursor()
drop_db_sql_command = "DROP DATABASE IF EXISTS SQLpie_%s; " % (env);
local_cursor.execute(drop_db_sql_command)
local_cursor.close()
local_cursor = local_conn.cursor()
create_db_sql_command = "CREATE DATABASE SQLpie_%s; " % (env);
use_db_sql_command = "USE SQLpie_%s; " % (env);
f = open("sqlpie/db/sql/schema.sql","r")
schema = f.read()
sql_commands = create_db_sql_command + use_db_sql_command + schema
local_cursor.execute(sql_commands)
local_cursor.close()
local_cursor = local_conn.cursor()
f = open("sqlpie/db/sql/seed.sql","r")
seed_commands = f.read()
sql_commands = use_db_sql_command + seed_commands
local_cursor.execute(seed_commands)
local_conn.commit()
print "Successfully created SQLpie_%s database on %s server." % (env, sqlpie_config['db'][env]['mysql_database_host'])
except Exception as e:
print "[Error] creating SQLpie_%s database on %s server." % (env, sqlpie_config['db'][env]['mysql_database_host'])
if sqlpie.Util.is_debug():
traceback.print_tb(sys.exc_info()[2])
finally:
try:
local_cursor.close()
local_conn.close()
except:
pass
app.config['MYSQL_DATABASE_DB'] = curr_db_config
from flask import Flask, render_template, request, redirect, url_for
from flaskext.mysql import MySQL
app = Flask(__name__)
db = MySQL(app)
db.init_app(app)
#MySQL config
app.config['MYSQL_DATABASE_USER'] = '******'
app.config['MYSQL_DATABASE_PASSWORD'] = '******'
app.config['MYSQL_DATABASE_DB'] = 'ZooFood'
app.config['MYSQL_DATABASE_HOST'] = 'localhost'
app.config['TESTING'] = True
conn = db.connect()
@app.route('/animal/<species>')
def animalDiet(species=None):
cursor = conn.cursor()
details = getDietDetails(cursor, species)
return render_template('animal.html', dietDetails=details, species=species)
def getDietDetails(cursor, species):
dietDetails = []
cursor.execute(
'''SELECT food, amountPerAnimal FROM Diet
WHERE speciesName = "''' + species + '"'
)
for detail in cursor.fetchall():
def create_app(configfile='config.cfg'):
app = Flask(__name__)
AppConfig(app, configfile)
app.debug = app.config['DEBUG']
mysql = MySQL()
pb = Pushbullet(app.config['PUSHBULLET']['apiKey'])
app.config['MYSQL_DATABASE_HOST'] = app.config['MYSQL']['host']
app.config['MYSQL_DATABASE_USER'] = app.config['MYSQL']['user']
app.config['MYSQL_DATABASE_PASSWORD'] = app.config['MYSQL']['password']
app.config['MYSQL_DATABASE_DB'] = app.config['MYSQL']['database']
mysql.init_app(app)
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
pins = app.config['PINS']
for pin in pins:
GPIO.setup(pin, GPIO.OUT)
GPIO.output(pin, GPIO.LOW)
def get_credentials():
home_dir = os.path.expanduser('~')
credential_dir = os.path.join(home_dir, '.credentials')
if not os.path.exists(credential_dir):
os.makedirs(credential_dir)
credential_path = os.path.join(credential_dir, 'flask-calendar.json')
store = oauth2client.file.Storage(credential_path)
credentials = store.get()
if not credentials or credentials.invalid:
flow = client.flow_from_clientsecrets(app.config['GMAIL']['client_secret_file'], 'https://www.googleapis.com/auth/calendar')
flow.user_agent = 'Raspberry Flask Calendar'
flags = tools.argparser.parse_args(args=[])
credentials = tools.run_flow(flow, store, flags)
print('Storing credentials to ' + credential_path)
return credentials
def bytes2human(n):
symbols = (' Ko', ' Mo', ' Go', ' To', ' Po', ' Eo', ' Zo', ' Yo')
prefix = {}
for i, s in enumerate(symbols):
prefix[s] = 1 << (i + 1) * 10
for s in reversed(symbols):
if n >= prefix[s]:
value = float(n) / prefix[s]
return '%.1f%s' % (value, s)
return "%sB" % n
def getRevision():
revision = "ERROR"
try:
f = open('/proc/cpuinfo', 'r')
for line in f:
if line[0:8] == 'Revision':
revision = line[11:15]
full_revision = line[11:17]
f.close()
except:
revision = "ERROR"
if revision[0] == "a" or revision[0] == "9":
revision = full_revision
return revision
def revToModel():
rev = getRevision()
model = [
"0002", ["Model B Rev 1.0", "256MB"],
"0003", ["Model B Rev 1.0 (no fuses,D14)", "256MB"],
"0004", ["Model B Rev 2.0 (mounting holes,Sony)", "256MB"],
"0005", ["Model B Rev 2.0 (mounting holes,Qisda)", "256MB"],
"0006", ["Model B Rev 2.0 (mounting holes,Egoman)", "256MB"],
"0007", ["Model A (Egoman)", "256MB"],
"0008", ["Model A (Sony)", "256MB"],
"0009", ["Model A (Qisda)", "256MB"],
"000d", ["Model B Rev 2.0 (mounting holes,Egoman)", "512MB"],
"000e", ["Model B Rev 2.0 (mounting holes,Sony)", "512MB"],
"000f", ["Model B Rev 2.0 (mounting holes,Qisda)", "512MB"],
"0010", ["Model B+", "512MB"],
"0011", ["Compute Module", "512MB"],
"0012", ["Model A+", "256MB"],
"0014", ["Compute Module", "512MB"],
"900092", ["PiZero", "512MB"],
"a01041", ["Model 2B (Sony)", "1GB"],
"a21041", ["Model 2B (Embest)", "1GB"]
]
ix = model.index(rev)
board, memory = model[ix+1]
return (rev, board, memory)
def get_ip_address(ifname):
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
return socket.inet_ntoa(fcntl.ioctl(
s.fileno(),
0x8915,
struct.pack('256s', ifname[:15])
)[20:24])
def datetimeformat(value, format='%H:%M'):
return value.strftime(format)
def timestampformat(value, format='%Y-%m-%d %H:%M:%S'):
return datetime.fromtimestamp(int(value)).strftime(format)
def tempformat(value):
return value.replace("temp=", "").replace("'C\n", "")
def dhtformat(value):
return int(value)
def duration(value):
return datetime.fromtimestamp(int(value)).strftime('%M:%S')
def currentDuration(value):
tmp = value.split(':')
duration = datetime.fromtimestamp(int(tmp[0])).strftime('%M:%S')
return duration
def timeAgo(time=False):
now = datetime.now()
if type(time) is int:
diff = now - datetime.fromtimestamp(time)
elif isinstance(time, datetime):
diff = now - time
elif not time:
diff = now - now
second_diff = diff.seconds
day_diff = diff.days
if day_diff < 0:
return ''
if day_diff == 0:
if second_diff < 10:
return "just now"
if second_diff < 60:
return str(second_diff) + " seconds ago"
if second_diff < 120:
return "a minute ago"
if second_diff < 3600:
return str(second_diff / 60) + " minutes ago"
if second_diff < 7200:
return "an hour ago"
if second_diff < 86400:
return str(second_diff / 3600) + " hours ago"
if day_diff == 1:
return "Yesterday"
if day_diff < 7:
return str(day_diff) + " days ago"
if day_diff < 31:
return str(day_diff / 7) + " weeks ago"
if day_diff < 365:
return str(day_diff / 30) + " months ago"
return str(day_diff / 365) + " years ago"
app.jinja_env.filters['datetimeformat'] = datetimeformat
app.jinja_env.filters['timestampformat'] = timestampformat
app.jinja_env.filters['tempformat'] = tempformat
app.jinja_env.filters['dhtformat'] = dhtformat
app.jinja_env.filters['duration'] = duration
app.jinja_env.filters['timeAgo'] = timeAgo
app.jinja_env.filters['currentDuration'] = currentDuration
@app.route('/')
def index():
cursor = mysql.connect().cursor()
cursor.execute("SELECT * FROM (SELECT * FROM sensors ORDER BY id DESC limit 8) AS sensors ORDER BY id ASC")
sensors = cursor.fetchall()
for pin in pins:
pins[pin]['state'] = GPIO.input(pin)
jsonWeather = urllib2.urlopen('http://api.openweathermap.org/data/2.5/forecast/daily?q=' + app.config['WEATHER']['city'] + '&units=' + app.config['WEATHER']['units'] + '&lang=' + app.config['WEATHER']['lang'] + '&appid=' + app.config['WEATHER']['apikey'] + '&cnt=6&mode=json')
weather = json.load(jsonWeather)
templateData = {
'sensors': sensors,
'pins': pins,
'weather': weather
}
return render_template('index.html', **templateData)
@app.route('/sensor')
def sensor():
cursor = mysql.connect().cursor()
cursor.execute("SELECT * FROM (SELECT * FROM sensors ORDER BY id DESC limit 24) AS sensors ORDER BY id ASC")
sensors = cursor.fetchall()
templateData = {
'sensors': sensors,
'realtime': dht.read_retry(dht.DHT22, app.config['DHT22_PIN'])
}
return render_template('sensor.html', **templateData)
@app.route('/switch')
def switch():
for pin in pins:
pins[pin]['state'] = GPIO.input(pin)
templateData = {
'pins': pins
}
return render_template('switch.html', **templateData)
@app.route('/switch/<master>')
def master(master):
if master == 'on':
for pin in pins:
GPIO.output(pin, GPIO.HIGH)
if master == 'off':
for pin in pins:
GPIO.output(pin, GPIO.LOW)
if master == 'toggle':
for pin in pins:
GPIO.output(pin, not GPIO.input(pin))
if master == 'reset':
for pin in pins:
GPIO.output(pin, GPIO.LOW)
time.sleep(5)
GPIO.output(pin, GPIO.HIGH)
return redirect(url_for('switch'))
@app.route('/switch/<changePin>/<action>')
def action(changePin, action):
changePin = int(changePin)
if action == 'on':
GPIO.output(changePin, GPIO.HIGH)
if action == 'off':
GPIO.output(changePin, GPIO.LOW)
if action == 'toggle':
GPIO.output(changePin, not GPIO.input(changePin))
if action == 'reset':
GPIO.output(changePin, GPIO.LOW)
time.sleep(5)
GPIO.output(changePin, GPIO.HIGH)
return redirect(url_for('switch'))
@app.route('/calendar')
def calendar():
credentials = get_credentials()
http = credentials.authorize(httplib2.Http())
service = discovery.build('calendar', 'v3', http=http)
events = service.events().list(singleEvents=True, calendarId=app.config['GMAIL']['calendar_id']).execute()
today = datetime.today()
now = today.strftime('%Y-%m-%d')
templateData = {
'now': now,
'agenda': events['items']
}
return render_template('calendar.html', **templateData)
@app.route('/calendar/add', methods=['POST'])
def add():
if request.method == 'POST':
credentials = get_credentials()
http = credentials.authorize(httplib2.Http())
service = discovery.build('calendar', 'v3', http=http)
start = ""+request.form['StartDate']+"T"+request.form['StartTime']+":00+01:00"
end = ""+request.form['EndDate']+"T"+request.form['EndTime']+":00+01:00"
event = {
"summary": request.form['Summary'],
"description": request.form['Description'],
"start": {
"dateTime": start,
"timeZone": "Europe/Paris"
},
"end": {
"dateTime": end,
"timeZone": "Europe/Paris"
}
}
service.events().insert(calendarId=app.config['GMAIL']['calendar_id'], body=event).execute()
return redirect(url_for('calendar'))
@app.route('/calendar/delete/<idevent>')
def delete(idevent):
credentials = get_credentials()
http = credentials.authorize(httplib2.Http())
service = discovery.build('calendar', 'v3', http=http)
service.events().delete(calendarId=app.config['GMAIL']['calendar_id'], eventId=idevent).execute()
return redirect(url_for('calendar'))
@app.route('/feed')
def feed():
templateData = {
'rspy': feedparser.parse(app.config['FEEDS']['feed_1']),
'rpypod': feedparser.parse(app.config['FEEDS']['feed_2'])
}
return render_template('feed.html', **templateData)
@app.route('/player')
def player():
client = MPDClient()
client.connect(app.config['MPD']['host'], app.config['MPD']['port'])
client.timeout = None
client.idletimeout = None
splitTemp = client.status()['time']
split = splitTemp.split(':')
templateData = {
'variable': (int(split[0]) * 100) / int(split[1]),
'status': client.status(),
'current': client.currentsong(),
'playlist': client.playlistinfo()
}
return render_template('player.html', **templateData)
@app.route('/player/<player_action>')
def player_action(player_action):
client = MPDClient()
client.connect(app.config['MPD']['host'], app.config['MPD']['port'])
client.timeout = None
client.idletimeout = None
if player_action == 'backward':
client.previous()
elif player_action == 'forward':
client.next()
elif player_action == 'play':
client.play()
elif player_action == 'pause':
client.pause()
return redirect(url_for('player'))
@app.route('/player/play/<play_id>')
def play_id(play_id):
client = MPDClient()
client.connect(app.config['MPD']['host'], app.config['MPD']['port'])
client.timeout = None
client.idletimeout = None
client.playid(play_id)
return redirect(url_for('player'))
@app.route('/message')
def message():
templateData = {
'my_adress': app.config['PUSHBULLET']['mail'],
'contacts': pb.contacts,
'logs': pb.get_pushes()
}
return render_template('message.html', **templateData)
@app.route('/message/send', methods=['POST'])
def send_push():
if request.method == 'POST':
pb.push_note('[Notification Rpi]', request.form['Content'], email=request.form['Contact'])
return redirect(url_for('message'))
@app.route('/message/delete/<iden>')
def delete_push(iden):
pb.delete_push(iden)
return redirect(url_for('message'))
@app.route('/message/dismissed/<iden>')
def dismissed_push(iden):
pb.dismiss_push(iden)
return redirect(url_for('message'))
@app.route('/camera')
def camera():
return render_template('camera.html')
@app.route('/system')
def system():
memory = psutil.virtual_memory()
disk = psutil.disk_usage('/')
cursor = mysql.connect().cursor()
cursor.execute("SELECT * FROM (SELECT * FROM cpu ORDER BY id DESC limit 24) AS cpu ORDER BY id ASC")
cpu_graph = cursor.fetchall()
templateData = {
'cpu_graph': cpu_graph,
'uname': os.uname(),
'ip': get_ip_address(app.config['INTERNET']),
'raspberry': revToModel(),
'uptime': str(datetime.now() - datetime.fromtimestamp(psutil.boot_time())).split('.')[0],
'cpu': str(psutil.cpu_percent()),
'cpu_temp': os.popen('/opt/vc/bin/vcgencmd measure_temp').readline(),
'mem_percent': memory.percent,
'mem_used': bytes2human(memory.used),
'mem_total': bytes2human(memory.total),
'disk_used': bytes2human(disk.used),
'disk_total': bytes2human(disk.total),
'disk_percent': disk.percent
}
return render_template('system.html', **templateData)
@app.route('/network')
def network():
ping_cur = mysql.connect().cursor()
ping_cur.execute("SELECT * FROM (SELECT * FROM ping ORDER BY id DESC limit 5) AS ping ORDER BY id ASC")
ping = ping_cur.fetchall()
templateData = {
'ping': ping
}
return render_template('network.html', **templateData)
return app
# setting up the app
app = Flask(__name__)
# config
app.config['DEBUG'] = True
app.config['SECRET_KEY'] = os.urandom(24)
# MYSQL configurations
app.config['MYSQL_DATABASE_USER'] = '******'
app.config['MYSQL_DATABASE_PASSWORD'] = '******'
app.config['MYSQL_DATABASE_DB'] = 'strata'
app.config['MYSQL_DATABASE_HOST'] = 'localhost'
flaskmysql = MySQL()
flaskmysql.init_app(app)
def connect_db(flaskmysql):
"""
connecting to the database
:param flaskmysql:
:return:
"""
con = flaskmysql.connect()
return con
def get_db(flaskmysql):
if not hasattr(g,'mysql_db'):
g.mysql_db = connect_db(flaskmysql)
def init_db(app):
db = MySQL()
db.init_app(app)
db_handler = connect_db(db)
db_handler.ensure_tables()
return db_handler
from flaskext.mysql import MySQL
from app import APP
from config import config
mysql = MySQL()
# MySQL configurations
APP.config['MYSQL_DATABASE_USER'] = config['MYSQL_DATABASE_USER']
APP.config['MYSQL_DATABASE_PASSWORD'] = config['MYSQL_DATABASE_PASSWORD']
APP.config['MYSQL_DATABASE_DB'] = config['MYSQL_DATABASE_DB']
APP.config['MYSQL_DATABASE_HOST'] = config['MYSQL_DATABASE_HOST']
APP.config['MYSQL_DATABASE_PORT'] = config['MYSQL_DATABASE_PORT']
mysql.init_app(APP)
conn = mysql.connect()
cursor = conn.cursor()
def get_drawings():
try:
query = """
SELECT id, image_url, description
FROM drawing"""
cursor.execute(query)
drawings = cursor.fetchall()
response = []
for drawing in drawings:
response.append({
# Load default config and override config from an environment variable
app.config.update(dict(
DEBUG=True,
SECRET_KEY='development key',
USERNAME='******',
PASSWORD='******',
MYSQL_DATABASE_HOST='localhost',
MYSQL_DATABASE_PORT=3306,
MYSQL_DATABASE_USER='******',
MYSQL_DATABASE_PASSWORD='',
MYSQL_DATABASE_DB='PIN'
))
app.config.from_object(__name__)
db = MySQL()
db.init_app(app)
conn = db.connect()
def get_cursor():
"""Connects to the specific database."""
return conn.cursor()
def commit():
conn.commit()
def init_db():
with app.open_resource('schema.sql', mode='r') as f:
get_cursor().executescript(f.read())
commit()
@app.route('/')
import hashlib
from flaskext.mysql import MySQL
import ConfigParser
import re
root = "/home/sol315/server/uniquemachine/"
config = ConfigParser.ConfigParser()
config.read(root + 'password.ignore')
mysql = MySQL()
app = Flask(__name__)
app.config['MYSQL_DATABASE_USER'] = config.get('mysql', 'username')
app.config['MYSQL_DATABASE_PASSWORD'] = config.get('mysql', 'password')
app.config['MYSQL_DATABASE_DB'] = 'uniquemachine'
app.config['MYSQL_DATABASE_HOST'] = 'localhost'
mysql.init_app(app)
CORS(app)
mask = []
mac_mask = []
with open(root + "mask.txt", 'r') as f:
mask = json.loads(f.read())
with open(root + "mac_mask.txt", 'r') as fm:
mac_mask = json.loads(fm.read())
@app.route("/")
def hello():
return "Hello World!"
from flask import Flask
from flaskext.mysql import MySQL
from flask_login import LoginManager
app = Flask(__name__)
app.config.from_object('config')
mysql = MySQL()
mysql.init_app(app)
login_manager = LoginManager()
login_manager.init_app(app)
from app import views
#flask app
nlpsql = Flask(__name__)
nlpsql.secret_key = 'nlpsql key'
mysql = MySQL(nlpsql)
#Database Configuration
nlpsql.config['MYSQL_DATABASE_USER'] = '******'
nlpsql.config['MYSQL_DATABASE_PASSWORD'] = '******'
nlpsql.config['MYSQL_DATABASE_DB'] = 'nlpproj'
nlpsql.config['MYSQL_DATABASE_HOST'] = 'localhost'
#start flask app
mysql.init_app(nlpsql)
#route for home
@nlpsql.route('/')
def home():
if 'error' in session:
error=session['error']
session.pop('error',None)
else:
error=''
return render_template('login.html',error=error)
#route for getting example pdf
@nlpsql.route('/results')
def returnResultsPDF():
file_name = 'results.pdf'
