import flask
import flask_bouncer
import flask_login
import flask_restx
from flask import request
from flask_restx import fields
from website import decorators
from website.data.comments import models as models
from website.domain.blogs import queries as blog_queries
from website.domain.comments import operations, queries
from website.interfaces import api
from website.interfaces.api.comments import serializers
comments = flask.Blueprint(
name="api-comments", import_name=__name__, url_prefix="/api/v1/comments",
)
api_comments = api.Api(
app=comments,
version="1.0",
title="Comments API",
description="API for comments, which currently relies on session cookies.",
)
comment_marshaller = api_comments.model(
name="Comment", model=dict(body=fields.String),
)
class CommentDetail(flask_restx.Resource):
serializer = serializers.Comment()
'''
Implements the Flask API endpoints.
'''
from expertise.service.expertise import ExpertiseService
import openreview
from openreview.openreview import OpenReviewException
from .utils import mock_client
from .utils import get_user_id
import flask
from copy import deepcopy
from flask_cors import CORS
from multiprocessing import Value
from csv import reader
BLUEPRINT = flask.Blueprint('expertise', __name__)
CORS(BLUEPRINT, supports_credentials=True)
def get_client():
token = flask.request.headers.get('Authorization')
in_test_mode = 'IN_TEST' in flask.current_app.config.keys()
if in_test_mode:
return mock_client()
return openreview.Client(
token=token, baseurl=flask.current_app.config['OPENREVIEW_BASEURL'])
def format_error(status_code, description):
'''
import flask
from data import db_session
from data.jobs import Jobs
blueprint = flask.Blueprint('jobs_api', __name__, template_folder='templates')
@blueprint.route('/api/jobs')
def get_jobs():
jobs = db_session.create_session().query(Jobs).all()
return flask.jsonify({'jobs': [item.to_dict() for item in jobs]})
@blueprint.route('/api/jobs/<int:jobs_id>', methods=['GET'])
def get_one_jobs(jobs_id):
db_sess = db_session.create_session()
jobs = db_sess.query(Jobs).get(jobs_id)
if not jobs:
return flask.jsonify({'error': 'Not found'})
return flask.jsonify({
'jobs':
jobs.to_dict(only=('team_leader', 'job', 'work_size', 'collaborators',
'start_date', 'end_date', 'is_finished'))
})
@blueprint.route('/api/jobs', methods=['POST'])
def create_jobs():
if not flask.request.json:
return flask.jsonify({'error': 'Empty request'})
# Copyright 2016: Mirantis Inc.
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import flask
optimization = flask.Blueprint("optimization", __name__)
@optimization.route("/")
def get_optimization():
return flask.jsonify({"result": {"optimization": "dummy"}})
def get_blueprints():
return [["/optimization", optimization]]
import typing
import flask
import flask_apispec
import flask_jwt_extended
import flask_jwt_extended.exceptions
from flask_apispec import views
from backend import settings
from . import schema
app = flask.Blueprint('workspace', __name__)
@flask_apispec.use_kwargs(schema.AuthRequestSchema)
@flask_apispec.marshal_with(schema.AuthResponseSchema)
class OrthancAuth(views.MethodResource):
def post(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
access_token = kwargs.pop('token_value')
granted = True
try:
flask_jwt_extended.decode_token(access_token)
except flask_jwt_extended.exceptions.JWTDecodeError:
granted = False
return {
'granted': granted,
'validity': settings.ORTHANC_SESSION_VALIDITY
}
import logging
import flask
import os
import config
photos_routes = flask.Blueprint('photos', __name__, url_prefix='/api')
logger = logging.getLogger(__name__)
@photos_routes.route('/photos', methods=['DELETE'])
def delete_photos():
save_dir = os.path.join(config.root_dir, config.save_dir)
removed = []
for filename in os.listdir(save_dir):
os.unlink(os.path.join(save_dir, filename))
removed.append(filename)
return flask.jsonify({'removed': removed}), 200
import jinja2
import flask
blueprint = flask.Blueprint('filters', __name__)
@blueprint.app_template_filter()
def datetimeformat(value, format='%H:%M / %d-%m-%Y'):
from datetime import datetime
return datetime.utcfromtimestamp(value).strftime(format)
@blueprint.app_template_filter()
def folder(value):
return value.split('.')[0]
@blueprint.app_template_filter()
def slug(str):
import re
slug = re.sub("[!@#$%^&*()[\]{};:,\\|./<>?|~=+]", "", str)
slug = slug.replace(' ', '_')
return slug
from ipaddress import ip_address
import flask
from nyaa import forms, models
from nyaa.extensions import db
bp = flask.Blueprint('admin', __name__, url_prefix='/admin')
@bp.route('/log', endpoint='log', methods=['GET'])
def view_adminlog():
if not flask.g.user or not flask.g.user.is_moderator:
flask.abort(403)
page = flask.request.args.get('p',
flask.request.args.get('offset', 1,
int), int)
logs = models.AdminLog.all_logs() \
.order_by(models.AdminLog.created_time.desc()) \
.paginate(page=page, per_page=20)
return flask.render_template('adminlog.html', adminlog=logs)
@bp.route('/bans', endpoint='bans', methods=['GET', 'POST'])
def view_adminbans():
if not flask.g.user or not flask.g.user.is_moderator:
flask.abort(403)
form = forms.StringSubmitForm()
def __init__(
self,
name='__main__',
server=None,
static_folder='static',
assets_folder=None,
assets_url_path='/assets',
include_assets_files=True,
url_base_pathname='/',
compress=True,
meta_tags=None,
index_string=_default_index,
external_scripts=None,
external_stylesheets=None,
**kwargs):
# pylint-disable: too-many-instance-attributes
if 'csrf_protect' in kwargs:
warnings.warn('''
`csrf_protect` is no longer used,
CSRF protection has been removed as it is no longer
necessary.
See https://github.com/plotly/dash/issues/141 for details.
''', DeprecationWarning)
self._assets_folder = assets_folder or os.path.join(
flask.helpers.get_root_path(name), 'assets'
)
# allow users to supply their own flask server
self.server = server or Flask(name, static_folder=static_folder)
self.server.register_blueprint(
flask.Blueprint('assets', 'assets',
static_folder=self._assets_folder,
static_url_path=assets_url_path))
self.url_base_pathname = url_base_pathname
self.config = _AttributeDict({
'suppress_callback_exceptions': False,
'routes_pathname_prefix': url_base_pathname,
'requests_pathname_prefix': url_base_pathname,
'include_assets_files': include_assets_files,
'assets_external_path': '',
})
# list of dependencies
self.callback_map = {}
self._index_string = ''
self.index_string = index_string
self._meta_tags = meta_tags or []
self._favicon = None
if compress:
# gzip
Compress(self.server)
@self.server.errorhandler(exceptions.PreventUpdate)
def _handle_error(error):
"""Handle a halted callback and return an empty 204 response"""
print(error, file=sys.stderr)
return ('', 204)
# static files from the packages
self.css = Css()
self.scripts = Scripts()
self._external_scripts = external_scripts or []
self._external_stylesheets = external_stylesheets or []
self.registered_paths = {}
# urls
def add_url(name, view_func, methods=('GET',)):
self.server.add_url_rule(
name,
view_func=view_func,
endpoint=name,
methods=list(methods)
)
add_url(
'{}_dash-layout'.format(self.config['routes_pathname_prefix']),
self.serve_layout)
add_url(
'{}_dash-dependencies'.format(
self.config['routes_pathname_prefix']),
self.dependencies)
add_url(
'{}_dash-update-component'.format(
self.config['routes_pathname_prefix']),
self.dispatch,
['POST'])
add_url((
'{}_dash-component-suites'
'/<string:package_name>'
'/<path:path_in_package_dist>').format(
self.config['routes_pathname_prefix']),
self.serve_component_suites)
add_url(
'{}_dash-routes'.format(self.config['routes_pathname_prefix']),
self.serve_routes)
add_url(
self.config['routes_pathname_prefix'],
self.index)
# catch-all for front-end routes
add_url(
'{}<path:path>'.format(self.config['routes_pathname_prefix']),
self.index)
self.server.before_first_request(self._setup_server)
self._layout = None
self._cached_layout = None
self.routes = []
import flask
import flask_cors
import connexion
from . import utils
from . import config
ui_bp = flask.Blueprint('ui', __name__)
@ui_bp.route('/swagger_ui')
@ui_bp.route('/swagger_ui/')
def serve_swagger_ui_index():
'''
Swagger UI to graphically call API.
:return:
'''
return flask.render_template('swagger_ui.html',
api_url=flask.request.url_root +
'swagger_ui.json')
@ui_bp.route('/swagger_ui/<path:filename>')
def serve_swagger_ui_static_files(filename):
return flask.send_from_directory('static', filename)
@ui_bp.route('/swagger_ui.json')
def serve_swagger_ui_json():
return utils.yaml_to_json(config.wd + '/' + config.SPEC_FN)
import json
import editdistance
import flask
from flask_login import login_required
from sqlalchemy import func
from ..models.journal import Journal
journals = flask.Blueprint('journals', __name__)
@journals.route('/lookup', methods=['GET'])
@login_required
def lookup():
MAX_RESULTS = 10
typed = flask.request.args['journal_typed'].lower()
result = Journal.query.filter(func.lower(
Journal.name).like(f"%{typed}%")).all()
names = [r.name for r in result]
dists = [editdistance.eval(typed, name.lower()) for name in names]
# Sort the names by Levenshtein distance
response = list(zip(names, dists))
response.sort(key=lambda x: x[1])
response = [r[0] for r in response]
response = response[:MAX_RESULTS]
return json.dumps(response)
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import flask
import hotline.database.ext
import hotline.telephony.lowlevel
import peewee
from hotline.auth import super_admin_required
from hotline.database import highlevel as db
from hotline.database import models
blueprint = flask.Blueprint("numberadmin",
__name__,
template_folder="templates")
hotline.database.ext.init_app(blueprint)
@blueprint.route("/admin/numbers")
@super_admin_required
def list():
numbers = models.Number.select(
models.Number.number,
models.Number.country,
models.Number.pool,
models.Number.features,
models.Event.name,
models.Event.slug,
).join(
import flask
import rod
import rod.model.level
import rod.model.schemas
level_handler = flask.Blueprint('level', __name__)
@level_handler.route('/level', methods=['GET'])
def list_level():
course_id = flask.request.args.get('course_id')
query = rod.model.level.Level.query.filter_by(is_deleted=False)
if course_id:
levels = query.filter_by(course_id=course_id).all()
else:
levels = query.all()
return flask.jsonify({
'items':
rod.model.schemas.LevelSchema(many=True).dump(levels).data,
'count':
len(levels)
})
@level_handler.route('/level/<int:level_id>', methods=['GET'])
def get_level(level_id):
level_obj = rod.model.db.session.query(rod.model.level.Level).get(level_id)
import flask
import io
from bson.objectid import ObjectId
import flask_plate
image_api = flask.Blueprint('image_api', __name__)
@image_api.route('/image/<image_id>')
def get_image(image_id):
return flask.send_file(io.BytesIO(
flask_plate.db.fs.get(ObjectId(image_id)).read()),
mimetype='image/jpg')
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Place Explorer related handlers."""
import flask
from flask import current_app, g
import routes.api.place as place_api
bp = flask.Blueprint('place', __name__, url_prefix='/place')
# List of DCIDs displayed in the static place_landing.html page.
_PLACE_LANDING_DCIDS = [
'geoId/1714000',
'geoId/4805000',
'geoId/0667000',
'geoId/5363000',
'geoId/17031',
'geoId/06059',
'geoId/48201',
'geoId/06085',
'geoId/06',
'geoId/48',
'geoId/17',
'geoId/21',
"""
views.py renders html based on given URL and handles PDF and XML file generation
"""
import flask
import json
from flask import request
import StringIO
from xhtml2pdf import pisa
import dicttoxml
import logging
log = logging.getLogger(__name__)
view = flask.Blueprint("view", __name__, template_folder='templates')
app = flask.Flask(__name__)
@view.route('/reportgen/', methods=['GET', 'POST'])
def defaultview():
"""
serving landing page index.html
"""
if request.method == "POST":
#in case of report generation
dict = json.loads(request.form['data'])
if request.form['type'] == "pdf":
#Generate PDF
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
# implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import flask
from driverlog.dashboard import decorators
from driverlog.dashboard import parameters
from driverlog.dashboard import vault
blueprint = flask.Blueprint('api', __name__, url_prefix='/api/1.0')
def get_drivers_internal(**params):
drivers = vault.get_vault()['drivers_map']
filtered_drivers = []
# when release_id is not set return only drivers from active releases
if not params.get('release_id'):
all_releases = vault.get_vault()['releases_map']
active_releases = ','.join(
sorted(r['id'].lower() for r in all_releases.values()
if r.get('active')))
params['release_id'] = active_releases
for driver in drivers.values():
import flask
from pypi_org.infrastructure.view_modifiers import response
from pypi_org.services import user_service
import pypi_org.infrastructure.cookie_auth as cookie_auth
blueprint = flask.Blueprint('account', __name__, template_folder='templates')
# ################### INDEX #################################
@blueprint.route('/account')
@response(template_file='account/index.html')
def index():
user_id = cookie_auth.get_user_id_via_auth_cookie(flask.request)
if user_id is None:
return flask.redirect('/account/login')
user = user_service.find_user_by_id(user_id)
if not user:
return flask.redirect('/account/login')
return {'user': user}
# ################### REGISTER #################################
@blueprint.route('/account/register', methods=['GET'])
@response(template_file='account/register.html')
def register_get():
Generic API
To get frames
"""
import flask
import os
import json
import pymongo
import bson
import WebUI
from WebUI.utils import jsonify
import random
mod = flask.Blueprint('api', __name__)
# Shared connection
#conn = pymongo.Connection(flask.current_app.config["MONGO_SERVER"])
#db = conn[flask.current_app.config["MONGO_DB"]]
clips = WebUI.db["clips"]
clipscores = WebUI.db["clip_scores"]
frames = WebUI.db["frames"]
# Preload kit texts
path = os.path.join(WebUI.app.config['STATIC_DIR'], "data/kit_texts.js")
fin = open(path, "rt")
kit_texts = json.loads(fin.read())
# Preload top results
# Mostly obsolete
import time
import flask
from flask import request
from exts import db
from forms.front.postforms import PostForm, CommentForm
from models.common.postmodels import PostModel, BoardModel, CommentModel, PostStarModel
from utils import xtjson
from models.front.accountmodels import FrontUser, FrontRole, FrontPermission
from enumerations import PostSortType
from others.decorators.frontdecorators import login_required, json_login_required
import settings
from sqlalchemy import and_
bp = flask.Blueprint('post', __name__, url_prefix='/post/')
@bp.route('/', methods=('GET', 'POST'))
@login_required
def post():
form = PostForm(request.form)
if request.method == 'POST':
if form.validate():
title = form.title.data
content = form.content.data
board_id = form.board_id.data
board = BoardModel.query.filter_by(id=board_id).first()
author = flask.g.front_user
post = PostModel(title=title,
content=content,
'`ENABLED_IDENTITY_PROVIDERS` missing `providers` field in flask app'
' settings')
default_idp = fence.settings.ENABLED_IDENTITY_PROVIDERS['default']
idps = fence.settings.ENABLED_IDENTITY_PROVIDERS['providers']
# Mapping from IDP ID (what goes in ``fence/local_settings.py`` in
# ``ENABLED_IDENTITY_PROVIDERS``) to the name in the URL on the blueprint (see
# below).
IDP_URL_MAP = {
'fence': 'fence',
'google': 'google',
'shibboleth': 'shib',
}
blueprint = flask.Blueprint('login', __name__)
blueprint_api = Api(blueprint)
@blueprint.route('', methods=['GET'])
def default_login():
"""
The default root login route.
"""
def absolute_login_url(provider_id):
base_url = flask.current_app.config['BASE_URL']
return urlparse.urljoin(base_url,
'/login/{}'.format(IDP_URL_MAP[provider_id]))
def provider_info(idp_id):
return {
from __future__ import absolute_import
from __future__ import unicode_literals
import flask
status = flask.Blueprint('status', __name__)
@status.route('/status/healthcheck')
def healthcheck():
return ''
import flask
import json
import data
import auth
app_api = flask.Blueprint('app_api', __name__)
@app_api.route('/api/1/favourite/<movie_id>')
def toggle_favourite(movie_id):
# check if the user is logged in
if not auth.is_authenticated():
return json.dumps({
'success': False,
'message': 'You are not logged in'
})
# toggle favourite status and send the new status back
favourite_status = data.toggle_favourite(flask.session['user_id'], movie_id)
return json.dumps({
'success': True,
'favourite': favourite_status,
})
@app_api.route('/api/1/vote/<poll_id>/<choice_id>')
def vote_poll(poll_id, choice_id):
# check if the user is logged in
if not auth.is_authenticated():
return json.dumps({
'success': False,
"""Settings UI module."""
import re
import copy
import flask
from flask_babel import gettext, lazy_gettext
from superdesk.utc import utcnow
from newsroom.utils import get_json_or_400, set_version_creator
from newsroom.template_filters import newsroom_config
from newsroom.decorator import admin_only, account_manager_only
blueprint = flask.Blueprint('settings', __name__)
GENERAL_SETTINGS_LOOKUP = {'_id': 'general_settings'}
def get_settings_collection():
return flask.current_app.data.pymongo('items').db.settings
@blueprint.route('/settings/<app_id>')
@account_manager_only
def app(app_id):
for app in flask.current_app.settings_apps:
if app._id == app_id:
return flask.render_template('settings.html',
setting_type=app_id,
data=app.data())
flask.abort(404)
ACCESS_TOKEN_URI = 'https://www.googleapis.com/oauth2/v4/token'
AUTHORIZATION_URL = 'https://accounts.google.com/o/oauth2/v2/auth?access_type=offline&prompt=consent'
AUTHORIZATION_SCOPE ='openid email profile'
AUTH_REDIRECT_URI = os.environ.get("FN_AUTH_REDIRECT_URI", False)
BASE_URI = os.environ.get("FN_BASE_URI", False)
CLIENT_ID = os.environ.get("FN_CLIENT_ID", False)
CLIENT_SECRET = os.environ.get("FN_CLIENT_SECRET", False)
AUTH_TOKEN_KEY = 'auth_token'
AUTH_STATE_KEY = 'auth_state'
app = flask.Blueprint('google_auth', __name__)
def is_logged_in():
return True if AUTH_TOKEN_KEY in flask.session else False
def build_credentials():
if not is_logged_in():
raise Exception('User must be logged in')
oauth2_tokens = flask.session[AUTH_TOKEN_KEY]
return google.oauth2.credentials.Credentials(
oauth2_tokens['access_token'],
refresh_token=oauth2_tokens['refresh_token'],
import flask
import jenkins
blueprint = flask.Blueprint('jenkins', __name__)
opts = {
'url': 'http://*****:*****@blueprint.route('/jenkins', methods=['GET', 'POST'])
def jenkins_action():
conn = None
try:
conn = jenkins.Jenkins(**opts)
except:
return flask.jsonify(err, 500)
jobs = [conn.get_job_info(j['fullname']) for j in conn.get_jobs()]
context = {'jobs': jobs}
return flask.render_template('jenkins.html', context=context)
import logging
import flask
import rmc.models as m
from rmc.server import profile
import rmc.server.view_helpers as view_helpers
view = flask.Blueprint('profile_view', __name__, url_prefix='/profile')
@view.route('/demo')
def demo_profile():
fbid = c.DEMO_ACCOUNT_FBID
user = m.User.objects(fbid=fbid).first()
# To catch errors on dev. We may not all have the test account in our mongo
if user is None:
logging.error("Accessed non-existant test/demo account %s" % fbid)
return flask.redirect('/profile')
return profile.render_profile_page(user.id, user)
# TODO(mack): maybe support fbid in addition to user_id
# TODO(mack): move each api into own class
@view.route('/', defaults={'profile_user_id': None})
@view.route('/<string:profile_user_id>')
@view_helpers.login_required
def profile_page(profile_user_id):
return profile.render_profile_page(profile_user_id)
import flask
from xmltodict import parse
from flask import current_app
from .cas_urls import create_cas_login_url
from .cas_urls import create_cas_logout_url
from .cas_urls import create_cas_validate_url
try:
from urllib import urlopen
except ImportError:
from urllib.request import urlopen
blueprint = flask.Blueprint('cas', __name__)
@blueprint.route('/login/')
def login():
"""
This route has two purposes. First, it is used by the user
to login. Second, it is used by the CAS to respond with the
`ticket` after the user logs in successfully.
When the user accesses this url, they are redirected to the CAS
to login. If the login was successful, the CAS will respond to this
route with the ticket in the url. The ticket is then validated.
If validation was successful the logged in username is saved in
the user's session under the key `CAS_USERNAME_SESSION_KEY` and
the user's attributes are saved under the key
'CAS_USERNAME_ATTRIBUTE_KEY'
"""
import flask_login as login
# from flask.ext import login
import flask
import base64
from eisitirio import app
from eisitirio.database import db
from eisitirio.database import models
from eisitirio.helpers import login_manager
from eisitirio.logic import cancellation_logic
from eisitirio.scripts import create_qr_codes
APP = flask.current_app #app.APP#DB = db.DB
from eisitirio.app import eisitiriodb as DB
ADMIN_TICKETS = flask.Blueprint('admin_tickets', __name__)
@ADMIN_TICKETS.route('/admin/ticket/<int:ticket_id>/view')
@ADMIN_TICKETS.route(
'/admin/ticket/<int:ticket_id>/view/page/<int:events_page>')
@login.login_required
@login_manager.admin_required
def view_ticket(ticket_id, events_page=1):
"""View a ticket object."""
ticket = models.Ticket.query.get_or_404(ticket_id)
if ticket:
events = ticket.events.paginate(events_page, 10, True)
else:
events = None
import sqlite3
import flask
import flask_cors
import jsonschema
import dbshare.db
import dbshare.query
import dbshare.api.schema
import dbshare.api.table
import dbshare.api.user
import dbshare.api.view
from dbshare import constants
from dbshare import utils
blueprint = flask.Blueprint("api_db", __name__)
flask_cors.CORS(blueprint, methods=["GET"])
@blueprint.route("/<name:dbname>", methods=["GET", "PUT", "POST", "DELETE"])
def database(dbname):
"""GET: List the database tables, views and metadata.
PUT: Create the database, load the data if any input.
POST: Edit the database metadata.
DELETE: Delete the database.
"""
if utils.http_GET():
try:
db = dbshare.db.get_check_read(dbname, nrows=True)
except ValueError:
