def setup_database():
""" Initialize the database file, maybe drop all tables. """
# -------------------------------------------------------------------------
# Set up the database.
# -------------------------------------------------------------------------
# !!AI uncomment me when needed.
#models.drop_all()
models.initialize()
def setUp(self):
"""Runs before every test, creating the User table and
one entry if either are not present"""
# Opens connection, creates table, and closes connection
models.initialize()
# Creates one mock entry in the database
models.User.create_user(username='******',
email='*****@*****.**',
password='******')
# Retrieves mock entry from database and stores it locally
self.user = models.User.get(email='*****@*****.**')
def init():
db_session = DBSession()
system_version = SystemVersion.get(db_session)
# Handles database schema migration
for version in range(system_version.schema_version, CURRENT_SCHEMA_VERSION+1):
handler_class = get_schema_migrate_class(version)
if handler_class is not None:
try:
handler_class(version).execute()
except:
print(traceback.format_exc())
# Initialize certain tables
initialize()
def __init__(self, db_name, encrypter=None, store_text=True):
self.session_maker = models.initialize(db_name)
self.session = None
models.ENCRYPTER = encrypter
self.store_text = store_text
self.nrmoves = 0
self.latestx = 0
self.latesty = 0
self.lastspecial = None
self.specials_in_row = 0
self.curtext = u""
self.key_presses = []
self.last_key_time = time.time()
self.started = NOW()
self.cur_class = None
self.cur_window = None
self.cur_name = None
self.cur_process_id = None
self.cur_win_id = None
self.cur_win_proc = None
def init():
db_session = DBSession()
system_version = SystemVersion.get(db_session)
# Handles database schema migration starting from the next schema version
for version in range(system_version.schema_version + 1, CURRENT_SCHEMA_VERSION + 1):
handler_class = get_schema_migrate_class(version)
if handler_class is not None:
try:
handler_class(version).execute()
except:
print(traceback.format_exc())
apply_dialect_specific_codes()
# Initialize certain tables
initialize()
def index():
return 'Hey'
if __name__ == '__main__':
models.initialize()
try:
models.User.create_user(
username='******',
email='*****@*****.**',
password='******',
admin=True
)
except ValueError:
pass
app.run(debug=DEBUG, host=HOST, port=PORT)
def init():
if not is_ldap_supported():
print('LDAP authentication is not supported because it has not been installed.')
db_session = DBSession()
system_version = SystemVersion.get(db_session)
# Handles database schema migration starting from the next schema version
for version in range(system_version.schema_version + 1, CURRENT_SCHEMA_VERSION + 1):
handler_class = get_schema_migrate_class(version)
if handler_class is not None:
try:
handler_class(version).execute()
except:
print(traceback.format_exc())
# Initialize certain tables
initialize()
def __init__(self, db_name, encrypter=None, store_text=True):
self.session_maker = models.initialize(db_name)
models.ENCRYPTER = encrypter
self.store_text = store_text
self.curtext = u""
self.key_presses = []
self.mouse_path = []
self.current_window = Display()
self.last_key_time = time.time()
self.started = NOW()
def delete_post(postid):
post_id = int(postid)
post = models.Post.get(models.Post.id == post_id)
post.delete_instance()
return redirect(url_for('posts'))
@app.route('/post/<postid>/edit', methods=['GET', 'POST']
) # called inside of post.html during second phase of editing logic
@login_required
def edit_post(postid):
post_id = int(postid) # convert str to int
post = models.Post.get(models.Post.id == post_id)
form = forms.PostForm(
) # forms.py call class PostForm inherit its properties
post.title = form.title.data # assign selected post.title tobe overwritten by form.title.data
post.content = form.content.data # assign selected post.content tobe overwritten by form.content.data
post.save() # http://docs.peewee-orm.com/en/latest/peewee/querying.html
flash("Great, Your diary has been edited", "success")
return redirect(f"/posts/{post_id}")
if 'ON_HEROKU' in os.environ:
print('hitting ')
models.initialize()
if __name__ == '__main__':
models.initialize(
) # before our app runs we initialize a connection to the models
app.run(debug=DEBUG, port=PORT)
try:
email = g.user._get_current_object().email
models.Taco.select().where(models.Taco.id == taco_id).get().delete_instance()
flash('Deleted Taco!', 'success')
except models.DoesNotExist:
abort(404)
return redirect(url_for('profile', email=email))
@app.errorhandler(404)
def not_found(error):
return render_template('404.html'), 404
@app.route('/')
def index():
tacos = models.Taco.select().limit(100)
return render_template('index.html', tacos=tacos)
if __name__ == '__main__':
models.initialize()
try:
models.User.create_user(
email='*****@*****.**',
password='******'
)
except ValueError:
pass
app.run()
from database import PooledMDB as Database
import tornado.httpserver
import tornado.ioloop
import tornado.options
import tornado.web
from tornado.options import define, options
define("port", default=5000, help="port to bind to", type=int)
from config import settings, dbconf, bsconf
from routes import routes
import models
class Application(tornado.web.Application):
def __init__(self, dbconf, bsconf, handlers=None, **settings):
super(Application, self).__init__(handlers, **settings)
self.blobstore = None # Blobstore(bsconf.nodes, **bsconf.opts)
self.database = Database(stale_timeout=599, **dbconf)
if __name__ == "__main__":
tornado.options.parse_command_line()
app = Application(dbconf, bsconf, routes, **settings)
models.initialize(app.database, app.blobstore)
server = tornado.httpserver.HTTPServer(app)
server.listen(tornado.options.options.port)
tornado.ioloop.IOLoop.instance().start()
def students():
models.initialize()
students = models.Student.select()
return render_template("entries.html", students=students)
@app.before_request # decorator function, that runs before a function
def before_request():
"""Connect to the database before each request."""
g.db = models.DATABASE
g.db.connect()
@app.after_request
def after_request(response):
"""Close the database connection after each request."""
g.db.close()
return response
# test
@app.route('/')
def index():
return 'Hello, world!'
if 'ON_HEROKU' in os.environ:
print('\non heroku!')
models.initialize()
# Run the app when the program starts!
if __name__ == '__main__':
models.initialize() # invokes the function that creates our tables
# in models.py
app.run(debug=DEBUG, port=PORT)
def setUp(self):
models.initialize()
self.app = app.test_client()
def index():
models.initialize()
return render_template("index.html",)
#!/usr/bin/env python
from database import MDB as Database
from config import dbconf, bsconf
from models import *
import models
if __name__ == "__main__":
database = Database(**dbconf)
blobstore = None # Blobstore(bsconf.nodes, **bsconf.opts)
models.initialize(database, blobstore)
database.create_tables([
User,
Token,
Repo,
HMap,
CSet,
Blob,
CommitMessage
], safe=True)
flash("El usuario o la contraseña no son correctos", 'error')
else:
if check_password_hash(usuario.clave, form.clave.data):
login_user(usuario)
try:
next = session['next']
except:
response = redirect(url_for('inicio'))
else:
response = redirect(next)
del session['next']
response.set_cookie(
'userdata',
json.dumps({'usuario': usuario.persona.nombres}))
return response
else:
flash("El usuario o la contraseña no son correctos",
'error')
elif request.args.get('next') is not None:
session['next'] = request.args.get('next')
return render_template('login.html', form=form)
if __name__ == '__main__':
m.initialize()
app.run(debug=config.DEBUG, host=config.HOST, port=config.PORT)
def index():
models.initialize()
return render_template("polling.html")
@login_required
def logout():
logout_user()
return redirect(url_for("index"))
@app.route("/taco", methods=('GET', 'POST'))
@login_required
def taco():
form = TacoForm()
if form.validate_on_submit():
Taco.create(
protein=form.protein.data,
shell=form.shell.data,
cheese=form.cheese.data,
extras=form.extras.data,
user=current_user._get_current_object()
)
return redirect(url_for("index"))
return render_template("taco.html", form=form)
@app.route("/")
def index():
return render_template("index.html", tacos=Taco.select())
if __name__ == "__main__":
initialize()
app.run(port=8000,debug=True, host="localhost")
def __init__(self):
models.initialize()
self.task_table = models.Task()
from flask import Flask, jsonify, render_template
from config import HOST, PORT, DEBUG
from peewee import *
import models
from resources.todos import todo_api
app = Flask(__name__)
app.register_blueprint(todo_api, url_prefix="/api/v1/todos")
models.DATABASE.init('todo_api.db')
models.initialize(models.Todo)
@app.errorhandler(404)
def not_found(e):
message = str(e).split(':')[1]
return jsonify(error=message), 404
@app.errorhandler(400)
def bad_request(e):
message = str(e).split(':')[1]
return jsonify(error=message), 400
@app.route('/')
def my_todos():
return render_template('index.html')
def events():
models.initialize()
events = models.models.Myentry.select()
return render_template("Events.html", events = events)
def test_create_todo_defaults(self):
models.initialize()
def see_contacts():
models.initialize()
contacts = models.Contact.select()
return render_template("contacts.html", contacts=contacts)
import tornado.httpserver
import tornado.ioloop
import tornado.options
import tornado.web
from tornado.options import define, options
define("port", default=5000, help="port to bind to", type=int)
from config import settings, dbconf, bsconf
from routes import routes
import models
class Application(tornado.web.Application):
def __init__(self, dbconf, bsconf, handlers=None, **settings):
super(Application, self).__init__(handlers, **settings)
self.blobstore = None # Blobstore(bsconf.nodes, **bsconf.opts)
self.database = Database(stale_timeout=599, **dbconf)
if __name__ == "__main__":
tornado.options.parse_command_line()
app = Application(dbconf, bsconf, routes, **settings)
models.initialize(app.database, app.blobstore)
server = tornado.httpserver.HTTPServer(app)
server.listen(tornado.options.options.port)
tornado.ioloop.IOLoop.instance().start()
def _initialize_models():
models.initialize()
# deleting course
@app.route('/api/v1/course/<int:course_id>', methods=['DELETE'])
def delete_course(course_id):
course = try_course(course_id)
if course.delete_instance():
return jsonify(generate_response(data={}))
else:
abort(422)
# helpers methods
def try_course(course_id):
try:
return Course.get(Course.id == course_id)
except Course.DoesNotExist as e:
abort(404)
def generate_response(status=200, data=None, error=None):
return {'status': status, 'data': data, 'error': error}
if __name__ == "__main__":
# running the model function
initialize()
app.run(port=PORT, debug=DEBUG)
return None
@app.before_request #decorator function that runs before function
def before_request():
# this connect to a db before a request
g.db = models.DATABASE
g.db.connect()
@app.after_request
def after_request(response):
g.db.close()
return response
CORS(user, origins=['http://localhost:3000'], supports_credentials=True)
app.register_blueprint(user, url_prefix='/user')
CORS(movie, origins=['http://localhost:3000'], supports_credentials=True)
app.register_blueprint(movie, url_prefix='/movie')
CORS(movie_pref, origins=['http://localhost:3000'], supports_credentials=True)
app.register_blueprint(movie_pref, url_prefix='/movie_pref')
CORS(food_pref, origins=['http://localhost:3000'], supports_credentials=True)
app.register_blueprint(food_pref, url_prefix='/food_pref')
if __name__ == '__main__':
models.initialize() #invokes function to create tables in models.py
app.run(debug=DEBUG, port=PORT)
def __init__(self, db_name, args):
self.args = args
self.session_maker = models.initialize(db_name)
self.inmouse = False
self.check_needs()
def __init__(self, db_name, args):
self.args = args
self.session_maker = models.initialize(db_name)
self.inmouse = False
self.check_needs()
try:
user = models.User.get(models.User.email == form.email.data)
except models.DoesNotExist:
flash("Your email or password doesn't match.", "error")
else:
if check_password_hash(user.password, form.password.data):
login_user(user)
flash("You've been logged in!", "success")
return redirect(url_for('index'))
else:
flash("Your email or password doesn't match.", "error")
return render_template('login.html', form = form)
@app.route('/')
def index():
return 'Hey'
if __name__ == '__main__':
models.initialize()
try:
models.User.create_user(
username = '******',
email = '*****@*****.**',
password = '******',
admin=True
)
except ValueError:
pass
app.run(debug=DEBUG, host = HOST, port = PORT)
else:
flash('You have unfollowing {}!'.format(to_user.username), 'alert-success')
return redirect(url_for('stream', username=to_user.username))
@app.errorhandler(404) # error handeling view function
def not_found(error):
return render_template('404.html'), 404
if __name__ == '__main__': # launching our falsk application
models.initialize() # initializing our models in the database
try:
models.User.create_user(username='******', email='*****@*****.**', password='******', name='Athoug Alsoughayer', department='CS') # for testing purposes
except ValueError:
pass
app.run(debug=DEBUG)
