def status(name): elasticsearch_url = "http://{0}:{1}/".format(ELASTICSEARCH_HOST, ELASTICSEARCH_PORT) es_state = requests.get(elasticsearch_url) if es_state.status_code == 200: return "", 204 else: Flask.abort(500)
def show_venue(venue_id): venues = Venue.query.filter(Venue.id == venue_id).one_or_none() if venues is None: Flask.abort(404) data = venues.serialize_with_shows_details return render_template('pages/show_venue.html', venue=data)
def joinGame(gameid, username): if username in getPlayers(gameid): return False db = get_db() if db.cursor().execute('SELECT * FROM userGames WHERE gameid=:id', {"id": gameid}).fetchone() is None: Flask.abort(402) db.cursor().execute('INSERT INTO userGames VALUES(?,?,?,?,?)', (None, getUserID(username), gameid, False, 0)) db.commit()
def addTorrent(): if request.is_json and request.values.has_key('mag') and QBTLOGIN: opts = {'urls': request.values.get('mag'), 'sequentialDownload': True} r = session.post(url + 'command/download', data=opts) if r.ok: return '', 201 else: Flask.abort(400)
def accountImport(): file = request.files['file'] fname = file.filename if fname in ('Transaction.csv', 'Client.csv', 'Account.csv'): file.save(saveDirectory + file.filename) csvhandler.csvhandler.parseItem(saveDirectory + file.filename) else: Flask.abort(404, 'Could not find a location for the specified file') return "happy days"
def startGame(gameid): db = get_db() sets = db.cursor().execute("SELECT sets FROM games WHERE gameid=:id", {"id": gameid}).fetchone() if sets is None: Flask.abort(401) sets = [allSets[Set] for Set in pickle.loads(sets[0])] players = getPlayers(gameid) print players, "players New Game" updateGame(gameid, Game(players, sets))
def ready(gameid): if request.method == "POST": if request.form.has_key("join"): print "join" joinGame(gameid, session['username']) return redirect(url_for('lobby')) elif request.form.has_key("start"): startGame(gameid) return redirect(url_for("game", gameid=gameid)) Flask.abort(301)
def edit_venue(venue_id): venue_form = VenueForm() venue_to_update = Venue.query.filter(Venue.id == venue_id).one_or_none() if venue_to_update is None: Flask.abort(404) venue = venue_to_update.serialize form = VenueForm(data=venue) return render_template('forms/edit_venue.html', form=form, venue=venue)
def newGame(): if request.method == "POST": sets = [] for Set in allSets: if Set in request.form: sets.append(Set) username = session['username'] createPendingGame(username, sets, request.form['numberOfPlayers']) return redirect(url_for('lobby', _method="POST", pending="See Pending Games")) else: Flask.abort(304)
def edit_artist(artist_id): artist_form = ArtistForm() artist_to_update = Artist.query.filter( Artist.id == artist_id).one_or_none() if artist_to_update is None: Flask.abort(404) artist = artist_to_update.serialize form = ArtistForm(data=artist) return render_template('forms/edit_artist.html', form=form, artist=artist)
def getPlayers(gameid): db = get_db() players = db.cursor().execute( "select username from users U, userGames uG where uG.gameid =%d and uG.userid = U.userid" % int( gameid)).fetchall() print db.cursor().execute("select * from users U, userGames uG where uG.gameid =%d and uG.userid = U.userid" % int( gameid)).fetchall(), "players..." if players is None: Flask.abort(402) elif len(players) == 0: return None return [str(player[0]) for player in players]
def createPendingGame(creator, sets=[base], numberOfPlayers=4): db = get_db() userid = getUserID(creator) if not userid: Flask.abort(402) db.cursor().execute('INSERT INTO games VALUES(?,?,?,?,?,?,?,?)', (None, pickle.dumps(sets), None, datetime.utcnow(), False, False, numberOfPlayers, userid)) gameid = getLastRow("games", "gameid") print gameid, "lastrowid" db.cursor().execute('INSERT INTO userGames VALUES(?,?,?,?,?)', (None, userid, gameid, False, 0)) db.commit()
def supply(gameid): game = getCurrentGame(gameid) if not game: return Flask.abort(401) supply = game.supply print jsonify(supply.toDict()) return jsonify(supply.toDict())
def complexity(): # double check that it is a post call if request.method == 'POST': # extract request user_input user_input = request.data.decode() # check to see if user_input is valid # check if user_input has over 1000 characters # up to 1000 characters not including if len(user_input) >= 1000: # abort with error code 413 return Response(status=413) # check if user_input has over 100 words # up to 100 words not including if len(user_input.split(' ')) >= 100: # abort with error code 413 return Response(status=413) try: argument = request.args.to_dict()['mode'] if argument == 'verbose': result = calc_lexical_density_verbose(user_input) except: # calculate lexical density for returning result = calc_lexical_density(user_input) return_dict = """""{ "data": %s }""""" % result return return_dict return Flask.abort(413)
def choice(option, gameid): game = getCurrentGame(gameid) turn = game.currentTurn if not request.values.has_key('callback'): return Flask.abort(201) turn.event(request.values['callback'], option) updateGame(gameid, game)
def new(code): if request.method == 'GET': if not flask_login.current_user.is_authenticated: session['url'] = url_for('new', code=code) return redirect(url_for('login')) return render_template('new.html', code=code) else: discovered = DiscoveredNugget.objects(code__exact=code).first() if discovered == None: Flask.abort(401) else: new_nugget = Nugget() new_nugget.message_list = [] new_nugget.name = request.form['name'] new_nugget.mac = discovered['mac'] new_nugget.assigner = request.form['assigner'] new_nugget.assignee = flask_login.current_user.username new_nugget.weather_lat = "0" new_nugget.weather_lon = "0" new_nugget.display_weather = False new_nugget.delay = 5 new_nugget.cached_weather = None new_nugget.save() return redirect(url_for('home'))
def login(): error = None if request.method == 'POST': if request.form['username'] not in users or request.form[ 'password'] == None: error = 'Invalid Credentials. Please try again.' else: user = User([ i for i, x in enumerate(users) if x == request.form['username'] ][0]) login_user(user) next = request.args.get('next') if not is_safe_url(next): return Flask.abort(400) return redirect(url_for('welcome')) return render_template('login.html', error=error)
def commit(session): try: session.commit() except AssertionError as err: session.rollback() Flask.abort(409, err) except (exc.IntegrityError, sqlite3.IntegrityError) as err: session.rollback() Flask.abort(409, err.orig) except Exception as err: session.rollback() Flask.abort(500, err)
def login(): # Here we use a class of some kind to represent and validate our # client-side form data. For example, WTForms is a library that will # handle this for us, and we use a custom LoginForm to validate. form = LoginForm() if form.validate_on_submit(): # Login and validate the user. # user should be an instance of your `User` class login_user(user) Flask.flash('Logged in successfully.') next = Flask.request.args.get('next') # next_is_valid should check if the user has valid # permission to access the `next` url if not next_is_valid(next): return Flask.abort(400) return Flask.redirect(next or flask.url_for('index')) return Flask.render_template('login.html', form=form)
def login(): # Here we use a class of some kind to represent and validate our # client-side form data. For example, WTForms is a library that will # handle this for us, and we use a custom LoginForm to validate. form = LoginForm() if form.validate_on_submit(): # Login and validate the user. # user should be an instance of your `User` class login_user(user) Flask.flash('Logged in successfully.') next = Flask.request.args.get('next') # next_is_valid should check if the user has valid # permission to access the `next` url if not next_is_valid(next): return Flask.abort(400) return Flask.redirect(next or Flask.url_for('index')) return Flask.render_template('login.html', form=form)
import os from flask import Flask, request from flask.ext.mail import Mail from ..models import db from .common import abort from flask.ext.restful import Api, output_json from . import index, users, auth app = Flask(__name__) app.abort = abort env = os.environ.get('ENV', 'dev') app.config.from_object('website.settings.%sConfig' % env.capitalize()) app.config['ERROR_404_HELP'] = False auth.init(app) db.init_app(app) mail = Mail(app) api = Api(app, catch_all_404s=True, default_mediatype='application/hal+json') api.representations = {'application/hal+json': output_json} @app.before_request def validate_mimetype(): message = "This endpoint only supports Content-Type: %s requests, not %s." json = 'application/json' if request.method in ['POST', 'PUT']: if request.mimetype != json:
from utils.common import certify_token from apps.ips import ips from apps.auths import auths # 应用初始化 app = Flask(__name__) # 配置文件 app.config.from_object(config) # 初始化数据库 db.init_app(app) # 注册所有蓝图 app.register_blueprint(user_bp) app.register_blueprint(data_bp) # 自定义异常处理 app.abort = my_abort @app.route('/') def index(): return 'index' @app.before_request def print_request_info(): # print("请求地址:" + str(request.path)) # print("请求方法:" + str(request.method)) # print("---请求headers--start--") # print(str(request.headers).rstrip()) # print("---请求headers--end----") # print("GET参数:" + str(request.args))