from flask import Blueprint
bp = Blueprint('augmd', __name__)
from app.augmd import routes
# feature_support['rar'] = True
# except ImportError:
# feature_support['rar'] = False
try:
from .oauth_bb import oauth_check, oauthblueprints
feature_support['oauth'] = True
except ImportError as err:
log.debug('Cannot import Flask-Dance, login with Oauth will not work: %s', err)
feature_support['oauth'] = False
oauthblueprints = []
oauth_check = {}
feature_support['gdrive'] = gdrive_support
admi = Blueprint('admin', __name__)
@admi.route("/admin")
@login_required
def admin_forbidden():
abort(403)
@admi.route("/shutdown")
@login_required
@admin_required
def shutdown():
task = int(request.args.get("parameter").strip())
showtext = {}
from flask import Flask, request, abort, Response, redirect, url_for, flash, Blueprint, send_from_directory
from flask.templating import render_template
from flask_security.decorators import roles_required, login_required, current_user
bp_public = Blueprint('public', __name__, static_folder='../static')
@bp_public.route('/')
def index():
if current_user.is_authenticated:
return redirect(url_for('capteur_bp.principale'))
else:
return render_template('home.html')
@bp_public.route('/robots.txt')
def static_from_root():
return send_from_directory(bp_public.static_folder, request.path[1:])
@bp_public.route('/contact')
def contact():
return render_template('contact.html')
@bp_public.route('/mentions')
def mentions():
return render_template('mentions.html')
@bp_public.route('/plan')
The methods are also tested in the file tests/test_api_register.py
"""
from flask import (Blueprint, request, g, current_app)
from .lib.utils import send_result, getParam
from .lib.utils import required
from privacyidea.lib.user import get_user_from_param
import logging
from privacyidea.lib.passwordreset import (create_recoverycode,
check_recoverycode)
from privacyidea.lib.policy import ACTION
from privacyidea.api.lib.prepolicy import prepolicy, check_anonymous_user
log = logging.getLogger(__name__)
recover_blueprint = Blueprint('recover_blueprint', __name__)
# The before and after methods are the same as in the validate endpoint
@recover_blueprint.route('', methods=['POST'])
@prepolicy(check_anonymous_user, request, action=ACTION.PASSWORDRESET)
def get_recover_code():
"""
This method requests a recover code for a user. The recover code it sent
via email to the user.
:queryparam user: username of the user
:queryparam realm: realm of the user
:queryparam email: email of the user
:return: JSON with value=True or value=False
from flask import Blueprint, url_for, flash, g
from werkzeug.utils import redirect
from pybo import db
from pybo.models import Question, Answer
from pybo.views.auth_views import login_required
bp = Blueprint('vote', __name__, url_prefix='/vote')
@bp.route('/question/<int:question_id>/')
@login_required
def question(question_id):
_question = Question.query.get_or_404(question_id)
if g.user == _question.user:
flash('본인이 작성한 글은 추천할 수 없습니다.')
else:
_question.voter.append(g.user)
db.session.commit()
return redirect(url_for('question.detail', question_id=question_id))
@bp.route('/answer/<int:answer_id>')
@login_required
def answer(answer_id):
_answer = Answer.query.get_or_404(answer_id)
duplicate = g.user in _answer.voter
if g.user == _answer.user:
flash('본인이 작성한 글은 추천할 수 없습니다.')
elif duplicate:
flash('중복해서 추천할 수 없습니다.')
from flask import Blueprint, render_template
from flask_restplus import Api
API_URL_PREFIX = '/api'
API_BP = Blueprint('api', __name__, url_prefix=API_URL_PREFIX)
API = Api(API_BP,
version='2.0',
title='RaceMeter APIs',
description='APIs for Racemeter application')
@API.errorhandler
def default_error_handler(error):
'''Default error handler'''
return {'message': str(error)}, getattr(error, 'code', 500)
def register_structure(name, structure):
return API.model(name, structure)
def register_model(model):
return register_structure(model.name, model)
from .api_time import API as time_api
from .api_values import API as values_api
API.add_namespace(time_api)
from flask import Blueprint
graph = Blueprint('graph', __name__, static_folder='static')
from . import routes
# 各組分別在各自的 .py 程式中建立應用程式 (第1步/總共3步)
from flask import Blueprint, render_template, make_response
# 利用 Blueprint建立 ag1, 並且 url 前綴為 /ag1, 並設定 template 存放目錄
bg9 = Blueprint('bg9', __name__, url_prefix='/bg9', template_folder='templates')
# 展示傳回 Brython 程式
@bg9.route('/task2')
def task2():
outstring = '''
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>網際 2D 繪圖</title>
<!-- IE 9: display inline SVG -->
<meta http-equiv="X-UA-Compatible" content="IE=9">
<script type="text/javascript" src="http://brython.info/src/brython_dist.js"></script>
<script type="text/javascript" src="http://cptocadp-2015fallhw.rhcloud.com/static/Cango-8v03.js"></script>
<script type="text/javascript" src="http://cptocadp-2015fallhw.rhcloud.com/static/Cango2D-6v13.js"></script>
<script type="text/javascript" src="http://cptocadp-2015fallhw.rhcloud.com/static/CangoAxes-1v33.js"></script>
</head>
<body>
<script>
window.onload=function(){
brython(1);
}
]
# app.config['SQLALCHEMY_ECHO'] = True
db.init_app(app)
cors.CORS(app)
class FlaskRestParser(FlaskParser):
def handle_error(self, error):
message = error.messages
status_code = getattr(error, 'status_code', 422)
raise exceptions.ApiError(message, status_code)
parser = FlaskRestParser()
app.config['APISPEC_WEBARGS_PARSER'] = parser
v1 = Blueprint('v1', __name__, url_prefix='/v1')
api = restful.Api(v1)
# Encode using ujson for speed and decimal encoding
api.representations['application/json'] = util.output_json
app.register_blueprint(v1)
@app.errorhandler(exceptions.ApiError)
def handle_error(error):
response = jsonify(error.to_dict())
response.status_code = error.status_code
return response
'''
This module contains all the routes for auth functionalities
'''
from json import dumps
from flask import request, Blueprint
from auth import auth_register, auth_login, auth_logout, auth_passwordreset_request, auth_passwordreset_reset
from error import RequestError
AUTH = Blueprint('auth', __name__)
@AUTH.route('/register', methods=['POST'])
def create_user():
'''
A route to register a user
'''
payload = request.get_json()
if not payload['email'] or not payload['password'] \
or not payload['name_first'] or not payload['name_last']:
raise RequestError(description="Missing data in request body")
reg_info = auth_register(
payload['email'], payload['password'], payload['name_first'], payload['name_last'])
return dumps(reg_info)
@AUTH.route('/login', methods=['POST'])
def connect():
'''
A route to login a user
'''
payload = request.get_json()
from flask import Blueprint, jsonify, session, request
from app.models import Dialogue, User, db
from flask_login import current_user
from sqlalchemy import or_
dialogues_routes = Blueprint('dialogues', __name__)
@dialogues_routes.route('/', methods=['POST'])
def new_dialogue():
"""
Create new dialogue
"""
data = request.get_json()
user = None
if current_user.is_authenticated:
user = current_user.to_dict()
else:
return {"error": "unauthorized user"}
user1 = int(
data["userId"]) if int(data["userId"]) < user["id"] else user["id"]
user2 = int(
data["userId"]) if int(data["userId"]) >= user["id"] else user["id"]
checkDialogue = Dialogue.query.filter(Dialogue.user1 == user1,
Dialogue.user2 == user2).first()
dialogue = None
from flask import Blueprint, request, abort
from managers import CarparkManager
blueprint = Blueprint("carparks", __name__)
@blueprint.route("/get", methods=["GET", "POST"])
def get_nearby_carparks():
if not request.json is None:
lat = request.json.get("lat")
lon = request.json.get("lon")
radius = request.json.get("radius")
if lat and lon and radius:
lat = float(lat)
lon = float(lon)
return {
"carparks": CarparkManager.get_nearby_carparks(lat, lon, radius)
}
return {
"carparks": CarparkManager.get_nearby_carparks(None, None, None)
}
# -*- coding: utf-8 -*-
import time
import datetime
from flask import Blueprint, current_app, request, jsonify
from sqlalchemy import asc, desc, and_, or_
from sqlalchemy.orm import joinedload, load_only
from api.models import TBBranch, TBProgram, TBGroup, TBSchedule, TBCourse, TBTutor, TBRoom, TBTurnPart_Group, TBTurn_Tutor, TBTurn, TBTurnPart, TBCoursePart, t_TBSettings
from api import db_session
api = Blueprint('api', __name__)
@api.route('/programs', methods=['POST'])
def programs():
programs = TBProgram.query.all()
response = []
[response.append(p.json()) for p in programs]
return jsonify(response)
@api.route('/groups', methods=['POST'])
def groups():
programId = int(request.form.get('program_id'))
year = int(request.form.get('year'))
groups = TBGroup.query.join(TBBranch, TBGroup.Branch_Id == TBBranch.Branch_Id)\
.filter(and_(TBBranch.Program_Id == programId, TBBranch.Year == year))\
.order_by(TBGroup.Name.asc())\
from flask import Blueprint
from App.views.refeicao import *
routesrefeicao = Blueprint('routesrefeicao',__name__)
@routesrefeicao.route('/post/refeicao',methods=['POST'])
def postrefeicao():
return post_refeicao()
@routesrefeicao.route('/refeicao/cliente/<idcliente>/', methods=['GET'])
def get_refeicaocliente(idcliente):
return get_refeicao_cliente(idcliente)
@routesrefeicao.route('/get/refeicao/atleta', methods=['GET'])
def getrefeicaoatleta():
return get_refeicao_atleta()
@routesrefeicao.route('/del/refeicao/atleta/<id>')
def deleterefeicao(id):
return delete_refeicao(id)
from flask import Blueprint
main = Blueprint("main", __name__)
api_bp = Blueprint("api", __name__, url_prefix="/api")
from app.main import views
from app.main import api
from flask import Blueprint, jsonify
api_route = Blueprint('api_route', __name__)
@api_route.route('/users')
def home():
return jsonify({ 'user': [] })
# -*- coding: utf-8 -*-
#Agregando proyect root
import sys
import os
dir = os.path.abspath(os.path.join(os.path.abspath(__file__), '../../..'))
sys.path.append(dir)
#Dependencias flask
from flask import request, session, Blueprint, json
from sqlalchemy import create_engine
from sqlalchemy.engine.url import URL
from sqlalchemy.orm import sessionmaker
from sqlalchemy.sql.expression import text
historias = Blueprint('historias', __name__)
from base import *
from app.scrum.actor import clsActor
from app.scrum.objetivo import clsObjetivo
from app.scrum.accion import clsAccion
from app.scrum.tareas import clsTarea
@historias.route('/historias/ACrearHistoria', methods=['POST'])
def ACrearHistoria():
#POST/PUT parameters
params = request.get_json()
results = [{'label':'/VHistorias', 'msg':['Historia creada']}, {'label':'/VCrearHistoria', 'msg':['Error al crear historia']}, ]
res = results[0]
#Action code goes here, res should be a list with a label and a message
from flask import Blueprint, render_template
from flask_login import login_required, current_user
main = Blueprint('main', __name__)
@main.route('/')
def index():
return render_template('index.html')
@main.route('/about')
def about():
return render_template('about.html')
@main.route('/profile')
@login_required
def profile():
return render_template('profile.html', name=current_user.name)
from CTFd.utils import user as current_user
from CTFd.utils import validators
from CTFd.utils.config import is_teams_mode
from CTFd.utils.config.integrations import mlc_registration
from CTFd.utils.config.visibility import registration_visible
from CTFd.utils.crypto import verify_password
from CTFd.utils.decorators import ratelimit
from CTFd.utils.decorators.visibility import check_registration_visibility
from CTFd.utils.helpers import error_for, get_errors, markup
from CTFd.utils.logging import log
from CTFd.utils.modes import TEAMS_MODE
from CTFd.utils.security.auth import login_user, logout_user
from CTFd.utils.security.signing import unserialize
from CTFd.utils.validators import ValidationError
auth = Blueprint("auth", __name__)
@auth.route("/confirm", methods=["POST", "GET"])
@auth.route("/confirm/<data>", methods=["POST", "GET"])
@ratelimit(method="POST", limit=10, interval=60)
def confirm(data=None):
if not get_config("verify_emails"):
# If the CTF doesn't care about confirming email addresses then redierct to challenges
return redirect(url_for("challenges.listing"))
# User is confirming email account
if data and request.method == "GET":
try:
user_email = unserialize(data, max_age=1800)
except (BadTimeSignature, SignatureExpired):
from datetime import date, timedelta
from datetime import datetime
from flask import render_template, Blueprint, abort
from sqlalchemy import text
from freezing.model import meta
from freezing.model.orm import Team, Athlete
blueprint = Blueprint('people', __name__)
def get_today():
"""
Sometimes you have an old database for testing and you need to set today to be something that is not actually today
"""
if False:
return date(2013, 2, 10)
return date.today()
@blueprint.route("/")
def people_list_users():
users_list = meta.session_factory().query(Athlete).filter(Athlete.team.has(leaderboard_exclude=0)).order_by(Athlete.name) # @UndefinedVariable
tdy = get_today()
week_start = tdy - timedelta(days=(tdy.weekday() + 1) % 7)
week_end = week_start + timedelta(days=6)
users = []
for u in users_list:
weekly_dist = 0
from flask import Blueprint
home = Blueprint("home",__name__)
import app.home.views
from listenbrainz.domain import spotify
from listenbrainz.webserver import flash
from listenbrainz.webserver.errors import APIBadRequest, APIInternalServerError
from listenbrainz.webserver.decorators import crossdomain
from listenbrainz.webserver.login import User
from listenbrainz.webserver import timescale_connection
from listenbrainz.webserver.views.api_tools import publish_data_to_queue, log_raise_400, is_valid_uuid
from datetime import datetime
from werkzeug.exceptions import NotFound, BadRequest, RequestEntityTooLarge, ServiceUnavailable, Unauthorized, InternalServerError
from listenbrainz.webserver.views.stats_api import _get_non_negative_param
from listenbrainz.listenstore.timescale_listenstore import TimescaleListenStoreException
from pydantic import ValidationError
LISTENS_PER_PAGE = 25
user_bp = Blueprint("user", __name__)
@user_bp.route("/<user_name>")
def profile(user_name):
# Which database to use to showing user listens.
db_conn = webserver.timescale_connection._ts
# Which database to use to show playing_now stream.
playing_now_conn = webserver.redis_connection._redis
user = _get_user(user_name)
# User name used to get user may not have the same case as original user name.
user_name = user.musicbrainz_id
# Getting data for current page
max_ts = request.args.get("max_ts")
import io
from flask import Blueprint, send_file, jsonify, render_template, request, g
from App.views.spider.qq_groups_spider import QQGroups
qq_group_bluprint = Blueprint('qq_gourp', __name__)
q = QQGroups()
f = {}
@qq_group_bluprint.route('/index/', methods=['GET', 'POST'])
def index():
if request.method == 'GET':
return render_template('qqun.html')
elif request.method == 'POST':
global f
print('xxxxxxxxxxxxxx')
sort = int(request.form.get('sort'))
pn = int(request.form.get('pn'))
kws = request.form.get('kws')
ft = request.form.get('ft')
token, attachments = q.start_search(sort=sort, pn=pn, kws=kws, ft=ft)
f.update(attachments=attachments,token=token)
data = {
'msg': 'ok',
'token': token
}
return jsonify(data)
def create_blueprint():
# Take a look at this SO question on hints how to organize versioned
# API with flask:
# http://stackoverflow.com/questions/28795561/support-multiple-api-versions-in-flask#28797512
return Blueprint('v1_resources', __name__)
from flask import Flask, render_template, request, jsonify, session, redirect, url_for, Blueprint
from models.conexion import Conexion
from models.usuario import Usuario
from models.empresa import Empresa
from models.configuracionCorreo import ConfiguracionCorreo
from models.departamento import Departamento
admin = Blueprint("admin",
__name__,
static_folder="../static",
template_folder="../templates/admin")
@admin.route('/cPanelAdmin', methods=['GET'])
def cPanelAdmin():
objUsuario = Usuario()
objDep = Departamento()
objEmp = Empresa()
if "ID" in session and session['Tipo'] == 1:
usuarios = objUsuario.ListarUsuariosXEstado(1)
depActivos = objDep.ListarDepartamentosXEstado(1)
empresas = objEmp.ListarEmpresasXEstado(1)
return render_template('cPanelAdmin.html',
usuarios=usuarios,
avatar=session["Avatar"],
departamentos=depActivos,
empresas=empresas,
ID=session["ID"])
else:
return redirect(url_for('inicio.index'))
from server.blueprints import encrypt_credentials
from flask import json, request, Blueprint, render_template, redirect, url_for
from server.db import db
from server.models.Admin import Admin
import os
import smtplib
import ssl
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.mime.image import MIMEImage
users = Blueprint('users', __name__, template_folder='../templates')
@users.route('/admin/users/recovery', methods=['POST'])
def register_recovery():
data = request.get_json()
found_user = Admin.query.filter_by(email=data["email"]).filter_by(first_name=data["first_name"]).filter_by(
last_name=data["last_name"]).filter_by(username=data["username"]).first()
if found_user is not None:
found_user.recovery_link = encrypt_credentials(data["email"])
db.session.add(found_user)
db.session.commit()
href_link = f"http://0.0.0.0:4001/admin/users/recovery/{found_user.recovery_link}"
port = os.environ["EMAIL_PORT"]
smtp_server = os.environ["EMAIL_SERVER"]
sender = os.environ["EMAIL_SENDER"]
receiver = os.environ["EMAIL_RECEIVER"]
from flask import Blueprint, render_template
from hf1.models import diensten_models, medewerker_models
from hf1.database import db
from datetime import datetime
bp_reserveren_poc = Blueprint('bp_reserveren_poc', __name__, url_prefix='/reserveren_poc',
template_folder='templates')
@bp_reserveren_poc.route('/')
def index():
overzicht_medewerkers = medewerker_models.Medewerker.query.all()
overzicht_diensten = diensten_models.Dienst.query.all()
overzicht_tijdslot = medewerker_models.Tijdslot.query.all()
return render_template('reserveren_poc.html',
title='reserveren',
year=datetime.now().year,
message='',
diensten=overzicht_diensten,
medewerkers = overzicht_medewerkers,
tijdslots = overzicht_tijdslot)
from flask import Blueprint
from flask_restful import Api
from resources.Hello import Hello
from resources.User import UserResource
from resources.Country import CountryResource
api_bp = Blueprint('api', __name__)
api = Api(api_bp)
# routes
# api.add_resource(Hello, '/hello')
api.add_resource(UserResource, '/user')
api.add_resource(CountryResource, '/country')
from flask import render_template, flash, redirect, url_for, request, Blueprint
from flask_login import login_user, current_user, logout_user, login_required
from flaskblog import db, bcrypt
from flaskblog.models import User, Post
from flaskblog.users.forms import RegisterationForm, LoginForm, UpdateAccountForm, RequestResetForm, ResetPasswordForm
from .utils import save_picture, send_reset_email
users = Blueprint('users', __name__)
@users.route('/register', methods=['GET', 'POST'])
def register():
if current_user.is_authenticated:
return redirect(url_for('main.home'))
form = RegisterationForm()
if form.validate_on_submit():
hashed_password = bcrypt.generate_password_hash(form.password.data).decode('utf-8')
user = User(username=form.username.data, email=form.email.data, password=hashed_password)
db.session.add(user)
db.session.commit()
flash('Your account has been created! you can login now', 'success')
return redirect(url_for('users.login'))
return render_template('register.html', title='register', form=form)
@users.route('/login', methods=['GET', 'POST'])
def login():
if current_user.is_authenticated:
return redirect(url_for('main.home'))
form = LoginForm()
if form.validate_on_submit():
user = User.query.filter_by(email=form.email.data).first()
from pypnusershub import routes as fnauth
from app.t_profils import forms as t_profilsforms
from app.models import (
TProfils,
TApplications,
CorProfilForApp,
TRoles,
Bib_Organismes,
CorRoleAppProfil,
)
URL_REDIRECT = current_app.config['URL_REDIRECT']
URL_APPLICATION = current_app.config['URL_APPLICATION']
route = Blueprint("profils", __name__)
"""
Routes des profils
"""
@route.route("profils/list", methods=["GET", "POST"])
@fnauth.check_auth(
3,
False,
redirect_on_expiration=URL_REDIRECT,
redirect_on_invalid_token=URL_REDIRECT,
)
def profils():
"""
