import io
import logging
from http import HTTPStatus
from flask import send_file, jsonify, make_response, Response, current_app as app
from flask.blueprints import Blueprint
from amundsen_application.api.preview.dashboard.dashboard_preview.preview_factory_method import \
DefaultPreviewMethodFactory, BasePreviewMethodFactory
LOGGER = logging.getLogger(__name__)
PREVIEW_FACTORY: BasePreviewMethodFactory = None # type: ignore
dashboard_preview_blueprint = Blueprint('dashboard_preview',
__name__,
url_prefix='/api/dashboard_preview/v0')
def initialize_preview_factory_class() -> None:
"""
Instantiates Preview factory class and assign it to PREVIEW_FACTORY
:return: None
"""
global PREVIEW_FACTORY
PREVIEW_FACTORY = app.config['DASHBOARD_PREVIEW_FACTORY']
if not PREVIEW_FACTORY:
PREVIEW_FACTORY = DefaultPreviewMethodFactory()
LOGGER.info('Using {} for Dashboard'.format(PREVIEW_FACTORY))
from flask.ext.login import current_user, login_user, logout_user, \
login_required
from sqlalchemy.exc import DatabaseError
from ldap3 import LDAPCommunicationError
from sipa.forms import flash_formerrors, LoginForm, AnonymousContactForm
from sipa.model import dormitory_from_name, user_from_ip, premature_dormitories
from sipa.units import dynamic_unit
from sipa.utils import get_user_name, redirect_url
from sipa.utils.exceptions import UserNotFound, InvalidCredentials
from sipa.utils.mail_utils import send_mail
from sipa.utils.git_utils import get_repo_active_branch, get_latest_commits
logger = logging.getLogger(__name__)
bp_generic = Blueprint('generic', __name__)
@bp_generic.before_app_request
def log_request():
if 'sentry' in current_app.extensions:
current_app.extensions['sentry'].client.extra_context({
'current_user':
get_user_name(current_user),
'ip_user':
get_user_name(user_from_ip(request.remote_addr))
})
logging.getLogger(__name__ + '.http').debug(
'Incoming request: %s %s',
request.method,
from flask import request
from flask.blueprints import Blueprint
from flask.templating import render_template
from libs.user_authentication import authenticate_user
from libs.graph_data import get_survey_results
from database.user_models import Participant
mobile_pages = Blueprint('mobile_pages', __name__)
@mobile_pages.route('/graph', methods=['GET', 'POST'])
@authenticate_user
def fetch_graph():
""" Fetches the patient's answers to the most recent survey, marked by survey ID. The results
are dumped into a jinja template and pushed to the device. """
patient_id = request.values['patient_id']
participant = Participant.objects.get(patient_id=patient_id)
# See docs in config manipulations for details
study_object_id = participant.study.object_id
survey_object_id_set = participant.study.surveys.values_list('object_id', flat=True)
data = []
for survey_id in survey_object_id_set:
data.append(get_survey_results(study_object_id, patient_id, survey_id, 7))
return render_template("phone_graphs.html", data=data)
# this is a debugging function, it displays the user graph for a given user without authentication.
# @mobile_pages.route("/fake", methods=["GET"] )
# def fake_survey():
# patient_id = request.values['patient_id']
# user = User(patient_id)
import json
from flask import jsonify, request
from flask import Response as flask_response
from flask.blueprints import Blueprint
from comment_svc.resources.comments_table import CommentsTable
from comment_svc.models.comment import Comment
comments = Blueprint("comments", __name__)
comments_table = CommentsTable()
# /comments
@comments.route("/comments", methods=["GET"])
def get_comments():
user = request.args.get("user")
tag = request.args.get("tag")
if user and not tag:
user_comments = comments_table.get_comments_by_user(user)
return jsonify(user_comments)
if tag and not user:
tagged_comments = comments_table.get_comments_by_tag(tag)
return jsonify(tagged_comments)
if tag and user:
tagged_user_comments = comments_table.get_user_comments_by_tag(
user, tag)
from flask_login import current_user
from itsdangerous import BadSignature, SignatureExpired
from golem.core import (environment_manager, settings_manager, test as
test_module, page as page_module, suite as
suite_module, session, utils, tags_manager,
test_directory)
from golem.core.page import Page
from golem.core.project import Project, create_project, delete_project
from golem.report import report
from golem.report import execution_report as exec_report
from golem.report import test_report
from golem.gui import gui_utils
from golem.gui.user_management import Users, Permissions
api_bp = Blueprint('api', __name__, url_prefix='/api')
def auth_required(func):
@wraps(func)
def decorated_view(*args, **kwargs):
if not current_user.is_authenticated:
token = request.headers.get('token', None)
if token:
try:
user = Users.verify_auth_token(current_app.secret_key,
token)
request.api_user = user
except SignatureExpired:
abort(401, 'Signature Expired')
except BadSignature:
from mycodo.config import LOGIN_BAN_SECONDS
from mycodo.config import LOGIN_LOG_FILE
from mycodo.databases.models import AlembicVersion
from mycodo.databases.models import Input
from mycodo.databases.models import Misc
from mycodo.databases.models import Role
from mycodo.databases.models import User
from mycodo.mycodo_flask.extensions import db
from mycodo.mycodo_flask.forms import forms_authentication
from mycodo.mycodo_flask.utils import utils_general
from mycodo.utils.utils import test_password
from mycodo.utils.utils import test_username
blueprint = Blueprint(
'routes_authentication',
__name__,
static_folder='../static',
template_folder='../templates'
)
logger = logging.getLogger(__name__)
@blueprint.context_processor
def inject_hostname():
"""Variables to send with every login page request"""
return dict(host=socket.gethostname())
@blueprint.route('/create_admin', methods=('GET', 'POST'))
def create_admin():
if admin_exists():
from secrets import randbits
from datetime import datetime
from flask import render_template, redirect, url_for
from flask.blueprints import Blueprint
from flask_login import current_user, login_required
from flask_chirper import db
from flask_chirper.models import User, Post, follower, Message
from flask_chirper.main.forms import MessageForm
from flask_chirper.post.forms import PostForm
main = Blueprint('main', __name__)
@main.route('/home', methods=['GET', 'POST'])
@login_required
def home():
form = PostForm()
if form.validate_on_submit():
post = Post(id=randbits(60),
content=form.content.data,
author=current_user)
db.session.add(post)
db.session.commit()
return redirect(url_for('main.home'))
return render_template('home.html', form=form)
@main.route('/explore', methods=['GET', 'POST'])
def explore():
return render_template('explore.html',
from flask.blueprints import Blueprint
import logging
from flask_login import login_required
from flask.templating import render_template
from waitlist.permissions import perm_manager
from waitlist.storage.database import CCVote, Account
from waitlist.base import db
from sqlalchemy.sql.functions import func
bp = Blueprint('settings_ccvote', __name__)
logger = logging.getLogger(__name__)
perm_manager.define_permission('ccvot_result_view')
@bp.route("/")
@login_required
@perm_manager.require('ccvot_result_view')
def index():
fc_results = db.session.query(Account.username, func.count('*')).join(
CCVote,
Account.id == CCVote.fcvoteID).group_by(Account.username).order_by(
func.count('*')).all()
lm_results = db.session.query(Account.username, func.count('*')).join(
CCVote,
Account.id == CCVote.lmvoteID).group_by(Account.username).order_by(
func.count('*')).all()
# unique votes
unique_votes_query_fc = db.session.query(CCVote.voterID.label("voterID"), CCVote.fcvoteID.label("fcvoteID")) \
from droplister_application.authentication.forms import LoginForm, RegistrationForm, PasswordResetForm
#from droplister_application.authentication.mailing import send_email_for_password_retrieving
from droplister_application.authentication.models import User
from droplister_application.authentication.utils import generate_secure_password, get_redirect_target, redirect_back
# from droplister_application.bj.mailing import send_register_confirmation_email
# from droplister_application.bj.models import Country
# from droplister_application.bj.utils import redirect_back, get_redirect_target
# from droplister_application.gallery.utils import handle_web_content_image
# from droplister_application.oauth import OAuthSignIn
__author__ = 'bryan'
authentication_bp = Blueprint('AUTH_BP',
__name__,
template_folder='templates',
static_folder='auth_static',
url_prefix='/<lang_code>')
@authentication_bp.url_defaults
def add_language_code(endpoint, values):
values.setdefault('lang_code', g.get('lang_code', 'en'))
@authentication_bp.url_value_preprocessor
def pull_lang_code(endpoint, values):
g.lang_code = values.pop('lang_code')
@login_manager.user_loader
from service.add_company_plane_info import add_company_plane_info
from service.get_company_plane_info import get_company_plane_info
from service.delete_company_plane_info import delete_company_plane_info
from service.add_airport_info import add_airport_info
from service.get_airport_info import get_airport_info
from service.delete_airport_info import delete_airport_info
from service.add_company_airline_info import add_company_airline_info
from service.add_flight_info import add_flight_info
from service.get_company_airline_info import get_company_airline_info
from service.get_plane_info import get_plane_info
from service.get_company_flight_infos import get_company_flight_infos
from service.delete_company_airline_info import delete_company_airline_info
from service.delete_flight_info import delete_flight_info
from typing import *
admin_management = Blueprint('admin', __name__, url_prefix='/admin')
@admin_management.route('/admin_login_api', methods=['POST'])
def admin_login_api():
data = request.get_json(silent=True)
name = data['name']
password = data['password']
if admin_login(name, password):
return {'success': True, 'info': '管理员登录成功'}
else:
return {'success': False, 'info': '您的账号或密码有错误'}
@admin_management.route('/add_company_api', methods=['POST'])
def add_company_api():
from mycodo.config import PATH_CAMERAS
from mycodo.databases.models import Camera
from mycodo.databases.models import Input
from mycodo.databases.models import Math
from mycodo.databases.models import Output
from mycodo.databases.models import PID
from mycodo.devices.camera import camera_record
from mycodo.mycodo_client import DaemonControl
from mycodo.mycodo_flask.routes_authentication import clear_cookie_auth
from mycodo.mycodo_flask.utils import utils_general
from mycodo.utils.influx import query_string
from mycodo.utils.system_pi import assure_path_exists
from mycodo.utils.system_pi import str_is_float
blueprint = Blueprint('routes_general',
__name__,
static_folder='../static',
template_folder='../templates')
logger = logging.getLogger(__name__)
influx_db = InfluxDB()
limiter = Limiter()
@blueprint.route('/')
def home():
"""Load the default landing page"""
if flask_login.current_user.is_authenticated:
if flask_login.current_user.landing_page == 'live':
return redirect(url_for('routes_page.page_live'))
elif flask_login.current_user.landing_page == 'dashboard':
#!/usr/bin/env python # -*- coding: utf-8 -*- # @Date : 2017/12/4 # @Author : wangmengcn@[email protected] from flask_restful import Api, Resource, abort, request from flask import make_response, jsonify from flask.blueprints import Blueprint from flask_jwt import jwt_required, current_identity from .user_model import User bp_user_control = Blueprint(__name__, 'userControl', url_prefix='/api/v1/user') rest_user_control = Api(bp_user_control) @rest_user_control.resource('/register') class UserRegister(Resource): """新用户注册""" def post(self): register_data = request.get_json() try: username = register_data['username'] password = register_data['password'] except Exception as e: print(str(e)) abort(400) new_user = User(username, password) flag, msg = new_user.gen_user() response = {}
from flask.blueprints import Blueprint
from flask.templating import render_template
from flask_login.utils import current_user
from api.context_processors import generate_date_from_now, generate_month_year_display, generate_server_signature, \
get_current_week_number
from extensions import config
main_menu_routes = Blueprint('main_menu', __name__)
@main_menu_routes.route("/", methods=["GET"])
def main_menu():
return render_template("main_menu.html",
company=config.company_name,
application=config.app_name,
email=config.company_email,
user=current_user,
calendar_week=get_current_week_number())
@main_menu_routes.context_processor
def faking_processor():
return dict(generate_date_from_now=generate_date_from_now,
generate_date_from_month=generate_month_year_display,
generate_server_signature=generate_server_signature)
from mycodo.mycodo_flask.routes_static import inject_variables
from mycodo.mycodo_flask.utils import utils_dashboard
from mycodo.mycodo_flask.utils import utils_general
from mycodo.utils.outputs import output_types
from mycodo.utils.outputs import parse_output_information
from mycodo.utils.system_pi import add_custom_measurements
from mycodo.utils.system_pi import add_custom_units
from mycodo.utils.system_pi import parse_custom_option_values_json
from mycodo.utils.system_pi import parse_custom_option_values_output_channels_json
from mycodo.utils.system_pi import return_measurement_info
from mycodo.utils.widgets import parse_widget_information
logger = logging.getLogger('mycodo.mycodo_flask.routes_dashboard')
blueprint = Blueprint('routes_dashboard',
__name__,
static_folder='../static',
template_folder='../templates')
@blueprint.context_processor
@flask_login.login_required
def inject_dictionary():
return inject_variables()
@blueprint.route('/save_dashboard_layout', methods=['POST'])
def save_dashboard_layout():
"""Save positions and sizes of widgets of a particular dashboard"""
if not utils_general.user_has_permission('edit_controllers'):
return redirect(url_for('routes_general.home'))
data = request.get_json()
# -*- coding: utf-8 -*-
__author__ = 'shn7798'
from flask import redirect
from flask.blueprints import Blueprint
index = Blueprint('index', __name__)
@index.route('/')
def index_page():
return redirect('/question/')
# -*-coding: utf-8-*-
# time: 2015/09/16 22:49
# author: liukaizeng
from flask import render_template
from flask.blueprints import Blueprint
from flask.ext.login import login_required
index_bp = Blueprint('index', __name__, template_folder="../templates")
@index_bp.route('/')
def index():
context = {"title": "Hello World"}
return render_template("index/index.html", **context)
@index_bp.route('/test')
@login_required
def hello_world():
return '<h1 style="color:red;">hello liuqingqing</h1>'
"""
Frontend blueprint
"""
import datetime
from flask.blueprints import Blueprint
frontend = Blueprint("frontend",
__name__,
static_folder="frontend/dist",
static_url_path="")
@frontend.route("/")
@frontend.route("/p")
@frontend.route("/p/<path:path>")
def index(path=None):
response = frontend.send_static_file("index.html")
del response.headers["Expires"]
del response.headers["ETag"]
response.headers["Last-Modified"] = datetime.datetime.now()
response.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
response.headers["Pragma"] = "no-cache"
print(response.headers)
return response
import pathlib as pl
import concurrent.futures
import requests
from flask import current_app, request
from flask.blueprints import Blueprint
from flask_socketio import emit
from rooaa.utils.filtration import filter_results
predict = Blueprint("predict", __name__)
@predict.route("/api/v1/prediction", methods=["POST"])
def send_predictions():
"""Getting filtered predictions and sending the results """
yolo_path = request.form.get("yolo_path")
dense_path = request.form.get("dense_path")
socket_id = request.form.get("socket_id")
pkl_path = yolo_path + "-pkl"
filtered_text = filter_results(pkl_path=pkl_path, dense_path=dense_path)
emit("result", filtered_text, namespace="/predict", room=socket_id)
return "Prediction sent"
def detect_objects(filename):
"""Spawns process to call MLService with input image name"""
dense_path = str(current_app.config["UPLOAD_PATH"] / pl.Path(filename))
yolo_path = dense_path + "-yolo"
from flask import jsonify, request
from flask.blueprints import Blueprint
from main.service.clientes_service import (obtener_clientes as
obtener_clientes_service, crear,
editar, obtener_cliente_por,
eliminar)
from main.settings import (CODIGO_HTTP)
clientes = Blueprint('clientes', __name__)
@clientes.route('/clientes', methods=['GET'])
def obtener_clientes():
respuesta = obtener_clientes_service()
return jsonify(respuesta), CODIGO_HTTP["OK"]
@clientes.route('/clientes/<int:id>', methods=['GET'])
def obtener_cliente(id):
try:
cliente = obtener_cliente_por(id)
return jsonify(cliente), CODIGO_HTTP["OK"]
except:
return jsonify({'mensaje':
'Cliente no encontrado'}), CODIGO_HTTP["BAD_REQUEST"]
@clientes.route('/clientes', methods=['POST'])
def crear_cliente():
try:
import json
from typing import Tuple
from flask.blueprints import Blueprint
from flask.json import jsonify
from flask.wrappers import Response
from pydantic import ValidationError
from core.use_cases.output import Failure
error = Blueprint("errors", __name__)
@error.app_errorhandler(ValidationError)
def handle_error(error_: ValidationError) -> Tuple[Response, int]:
return (
jsonify({
"error": Failure.PARAMETERS_ERROR,
"error_message": "validation_error",
"error_hint": json.loads(error_.json()),
}),
400,
)
#-*- coding:utf-8 -*-
from flask.blueprints import Blueprint
from flask.json import jsonify
from flask.globals import request
from recruit_base import dao
from recruit_base import admin_check
admin_resume_api=Blueprint("admin_resume_api", __name__)
@admin_resume_api.route("/get_resume_list", methods=["POST"])
@admin_check
def get_resume_list():
param = request.values
escape_char = ["\'", "\"", ";", "="];
for key in request.values:
#print request.values[key]
for e_char in escape_char:
if e_char in request.values[key]:
print request.values[key]
raise Exception
n_no = request.values['notice_no'] if 'notice_no' in request.values else ''
search_val = request.values['search[value]'] if 'search[value]' in request.values else ''
per_page = param.get('length')
return_data = {}
return_data['draw'] = int(param.get('draw'))
# -*- coding: utf-8 -*-
# time: 2020/3/5 上午10:46
from flask_restful import Resource, Api
from flask.blueprints import Blueprint
common_bp = Blueprint("common", __name__, url_prefix="/api/v1/common")
common_api = Api(common_bp)
@common_api.resource("/test")
class Common(Resource):
def get(self):
return {"hello": "world"}
# -*- coding: utf-8 -*-
#
# @author: Five
# Created on 2013-5-14
#
from flask.blueprints import Blueprint
from flask.globals import g
from flask_login import login_user, logout_user
import datetime
import random
import string
from mongoengine.errors import NotUniqueError
bp_auth = Blueprint('authorize', __name__)
@no_auth_required()
@bp_auth.route('/signup', methods=['post', 'get'])
@smart_render()
def signup():
''' signup user. '''
email = g.formdata.get('email')
name = g.formdata.get('name')
password = g.formdata.get('password')
# validate input
if not email or not name or not password:
raise FriendlyException.fec(error_code.ENP_REQUIRED)
# generate a verify code.
verify_code = ''.join(random.sample(string.letters, 6))
from flask.blueprints import Blueprint
from commons import to_response as r
from logs.services import LogService
logs = Blueprint('logs', __name__)
service = LogService()
@logs.route('/log', methods=['GET'])
def list_logs():
return {'data': [r(log) for log in service.list()]}
# coding=utf-8
from flask import request, jsonify, redirect, url_for
from flask.views import MethodView
from flask.blueprints import Blueprint
from flask_mako import render_template
from flask_login import current_user, logout_user
from firefly.models.topic import Post
bp = Blueprint("home", __name__, url_prefix="/")
class HomeView(MethodView):
def get(self):
posts = Post.objects.all()
return render_template('index.html', posts=posts)
class CreateView(MethodView):
def post(self):
title = request.form.get('title')
content = request.form.get('content')
post = Post(title=title, content=content)
post.save()
return jsonify(ok=0)
class LoginView(MethodView):
def get(self):
if current_user.is_authenticated():
return redirect(url_for('index'))
from flask import request, abort, render_template
from flask.blueprints import Blueprint
from flask_security import login_required
from models.user import User
from models.core import Post
from models.like import LikeItem
from models.collect import CollectItem
from models.contact import Contact
from corelib.utils import AttrDict
bp = Blueprint('account', __name__)
@bp.route('/landing')
def landing():
type = request.args.get('type')
type_map = {
'reset': '重置',
'confirm': '确认',
'register': '激活',
'confirmed': '已确认'
}
email = request.args.get('email')
if not email:
abort(404)
if type not in type_map:
type = 'register'
action = type_map.get(type)
return render_template('security/landing.html', **locals())
# -*- coding: utf-8 -*-
#
# @author: Five
# Created on 2013-9-8
#
from ifanhao.models import Av
from flask.blueprints import Blueprint
from flask.helpers import url_for, make_response
from flask.templating import render_template
bp_sitemap = Blueprint('sitemap', __name__)
domain = 'http://www.mailoop.com'
@bp_sitemap.route('/sitemap/', methods=['GET'])
@bp_sitemap.route('/sitemap.xml', methods=['GET'])
@bp_sitemap.route('/sitemap_baidu.xml', methods=['GET'])
def sitemap():
"""Generate sitemap.xml. Makes a list of urls and date modified."""
# user model pages
avs = Av.query.order_by(Av.published_on).all()
pages = []
for av in avs:
url = url_for('avs.get_av', code=av.code)
modified_time = av.published_on.date().isoformat()
pages.append([domain + url, modified_time])
sitemap_xml = render_template('sitemap.xml', pages=pages)
response = make_response(sitemap_xml)
from mycodo.databases.models import User
from mycodo.mycodo_flask.forms import forms_settings
from mycodo.mycodo_flask.routes_static import inject_variables
from mycodo.mycodo_flask.utils import utils_general
from mycodo.mycodo_flask.utils import utils_settings
from mycodo.utils.inputs import load_module_from_file
from mycodo.utils.inputs import parse_input_information
from mycodo.utils.system_pi import add_custom_measurements
from mycodo.utils.system_pi import add_custom_units
from mycodo.utils.system_pi import all_conversions
from mycodo.utils.system_pi import cmd_output
logger = logging.getLogger('mycodo.mycodo_flask.settings')
blueprint = Blueprint('routes_settings',
__name__,
static_folder='../static',
template_folder='../templates')
@blueprint.context_processor
@flask_login.login_required
def inject_dictionary():
return inject_variables()
@blueprint.route('/settings/alerts', methods=('GET', 'POST'))
@flask_login.login_required
def settings_alerts():
""" Display alert settings """
if not utils_general.user_has_permission('view_settings'):
return redirect(url_for('routes_general.home'))
from flask import request, render_template, redirect, url_for
from flask.blueprints import Blueprint
from flask_login import current_user, login_required
from cmdbmix.forms.cmdb import IdcAddForm, IdcEditForm
from cmdbmix.models.cmdb import Idc
from cmdbmix.utils import load_data_to_model, get_page_args, load_data_to_form
idc_bp = Blueprint('idc', __name__)
@idc_bp.route('/idc_manager', methods=['GET'])
@login_required
def idc_manager():
page, per_page = get_page_args(request)
pagination = Idc.query.paginate(page, per_page=per_page)
return render_template('cmdb/idc.html', pagination=pagination)
@idc_bp.route('/idc_manager/add_idc', methods=['GET', 'POST'])
@login_required
def add_idc():
form = IdcAddForm()
if form.validate_on_submit():
idc = Idc()
load_data_to_model(idc, form).save()
return redirect(url_for('idc.idc_manager'))
return render_template('cmdb/add_idc.html', form=form)
@idc_bp.route('/idc_manager/edit_idc/<int:idc_id>', methods=['GET', 'POST'])
from flask.app import Flask
from flask.blueprints import Blueprint
from flask.globals import request
from flask.helpers import url_for
from flask.templating import render_template
from sqlalchemy.engine import create_engine
from sqlalchemy.orm import scoped_session
from sqlalchemy.orm.session import sessionmaker
from werkzeug.utils import redirect
import os
import time
log = CPLog(__name__)
app = Flask(__name__, static_folder = 'nope')
web = Blueprint('web', __name__)
def get_session(engine = None):
return Env.getSession(engine)
def addView(route, func, static = False):
web.add_url_rule(route + ('' if static else '/'), endpoint = route if route else 'index', view_func = func)
""" Web view """
@web.route('/')
@requires_auth
def index():
return render_template('index.html', sep = os.sep, fireEvent = fireEvent, env = Env)
""" Api view """
