from .db.BingoPostgresAdapter import BingoPostgresAdapter
from .db.models import LibraryMeta, User as Usermodel
from .db.database import db_session
from .common.util import item_to_sdf_chunk, merge_dicts, api_route
from .celery_app import celery
from .validation import LibrarySchema, SearcherSchema, UserSchema
libraries_api = Blueprint('libraries_api', __name__)
if not os.path.exists(config.__dict__['UPLOAD_FOLDER']):
os.makedirs(config.__dict__['UPLOAD_FOLDER'])
libraries_api.indigo = Indigo()
libraries_api.renderer = IndigoRenderer(libraries_api.indigo)
libraries_api.indigo_inchi = IndigoInchi(libraries_api.indigo)
libraries_api.config = config.__dict__
libraries_api.adapter = BingoPostgresAdapter(libraries_api.config,
libraries_api.indigo,
libraries_api.indigo_inchi)
libraries_api.redis = redis.StrictRedis(host='localhost', port=6379, db=0)
libraries_api_app = flask_restful.Api(libraries_api)
libraries_api_logger = logging.getLogger('libraries')
#libraries_api_logger.addHandler(logging.FileHandler('/srv/api/app.log'))
auth = HTTPBasicAuth()
libraries_api_app.route = types.MethodType(api_route, libraries_api_app)
@auth.verify_password
def verify_password(email, password):
user = Usermodel.query.filter(Usermodel.email == email).first()
if not user or not user.check_password(password):
from flask import Blueprint, jsonify, request, url_for
from flask_login import current_user
import flask_restful as restful
from flask_restful import reqparse, fields, marshal_with
from flask_restful.representations.json import output_json
from server.autograder import submit_continous
from server.constants import STAFF_ROLES, VALID_ROLES
from server.controllers import files
from server.extensions import cache
import server.models as models
from server.utils import encode_id, decode_id
endpoints = Blueprint('api', __name__)
endpoints.config = {}
@endpoints.record
def record_params(setup_state):
""" Load used app configs into local config on registration from
server/__init__.py """
app = setup_state.app
endpoints.config['tz'] = app.config.get('TIMEZONE', 'utc') # sample config
endpoints.config['debug'] = app.debug
api = restful.Api(endpoints)
API_VERSION = 'v3'
import requests
from urllib.request import urlopen
from werkzeug import wsgi
from flask import Flask, abort, Blueprint, jsonify, render_template, Response, request
from flask import redirect, url_for, send_file, current_app
from flask.ext.login import login_required, login_user, current_user
from flask_wtf import CsrfProtect
from rdfframework import RdfProperty, get_framework as rdfw
from rdfframework.utilities import render_without_request, code_timer, \
remove_null, pp, clean_iri, uid_to_repo_uri, cbool, make_list
from rdfframework.forms import rdf_framework_form_factory
from rdfframework.api import rdf_framework_api_factory, Api
from rdfframework.security import User
base_site = Blueprint("base_site", __name__, template_folder="templates")
base_site.config = {}
'''@base_site.before_request
def before_request():
if request.url.startswith('http://'):
url = request.url.replace('http://', 'https://', 1)
code = 301
return redirect(url, code=code)'''
@base_site.route("/")
def home():
print("Current user is {}".format(current_user))
return render_template("index.html")
@base_site.route("/tester.html")
from flask_negotiate import produces
from flask.ext.login import login_required, login_user, current_user
from flask_wtf import CsrfProtect
from . import new_badge_class, issue_badge
from rdfframework import RdfProperty, get_framework as rdfw
from rdfframework.utilities import render_without_request, code_timer, \
remove_null, pp, clean_iri, uid_to_repo_uri, cbool, make_list
from rdfframework.forms import rdf_framework_form_factory
from rdfframework.api import rdf_framework_api_factory, Api
from rdfframework.security import User
DEBUG = True
open_badge = Blueprint("open_badge", __name__,
template_folder="templates")
open_badge.config = {}
@open_badge.record
def record_params(setup_state):
"""Function takes the setup_state and updates configuration from
the active application.
Args:
setup_state -- Setup state of the application.
"""
app = setup_state.app
open_badge.config = dict(
[(key, value) for (key, value) in app.config.items()]
)
from flask import abort, Blueprint, flash, jsonify, Markup, redirect, render_template, request, url_for
from flask.ext.login import current_user, login_required
from .forms import ProjectForm
from .models import Project
from rndapp.data import query_to_list
import config
application = Blueprint("application", __name__)
application.config = config.ANALYTICS
#@application.route("/")
#@application.route("/home")
#def index():
# return render_template("index.html")
@application.route("/")
@application.route("/home")
def index():
return render_template("comingsoon.html", surpress_rcontent=True)
@application.route('/about')
def about():
return render_template("about.html")
@application.route('/events')
def events():
return render_template("events.html")
@application.route('/news')
# -*- coding: utf-8 -*-
import logging
from flask import Blueprint
from cassandra.cluster import Cluster
from cassandra.cqlengine import connection
from cassandra.cqlengine.management import create_keyspace_simple
logger = logging.getLogger()
db = Blueprint('db', __name__)
db.config = {}
cluster = None
session = None
@db.record
def record_params(setup_state):
app = setup_state.app
db.config = dict([(key,value) for (key,value) in app.config.iteritems()])
def init_db_blueprint():
global cluster
cluster = Cluster(
db.config['CASSANDRA_CONTACT_POINTS']
)
global session
from flask import Blueprint
from fhir_server.configs import DefaultConfig
api_auth = Blueprint("api_auth", __name__, url_prefix="")
api_auth.config = DefaultConfig.OAUTH2_CONFIG
from .models import * # noqa
from .urls import * # noqa
from flask import render_template, request
from .controllers import ChartDisplayController, ChartCreateController, ChartEditController
from flask import Blueprint
charts = Blueprint('charts', __name__)
charts.config = {}
@charts.record
def record_config(setup_state):
config = setup_state.app.config
charts.config = config
@charts.route('/home')
def index():
return render_template("charts/home.html", controller=None)
@charts.route('/preview')
def preview():
controller = ChartDisplayController()
controller.load_demo_plot()
return render_template("charts/preview.html", controller=controller)
@charts.route('/create', methods=['GET', 'POST'])
def create():
import json
from flask import jsonify, Blueprint, request, current_app
from db.postgres import db
from flask_cors import cross_origin
from sqlalchemy import Sequence
from flask_json_schema import JsonSchema
from models.department import Department
from models.location import Location
from models.category import Category
import pdb
department_api = Blueprint('department_api', __name__)
department_api.config = {}
schema = JsonSchema(department_api)
@department_api.route("/api/v1/department", methods=['POST'])
@cross_origin("*")
def create():
try:
input_json_data = request.get_json()
db.create_all()
db.session.commit()
if not input_json_data:
return {"message": "No input data provided"}, 400
new_category = input_json_data['category']
new_department = input_json_data['department']
department_results = Department.query.filter(
Department.department == new_department)
# validation of department details
from flask import Blueprint, render_template
blueprint = Blueprint('electrostatic', __name__, template_folder='templates', static_folder='static')
from instruments import app
blueprint.config = app.config['ELECTROSTATIC']
import electrostatic.core
LABEL = 'Electrostatic'
ICON = 'pencil'
def get_admin_panel():
return render_template('electrostatic_admin_panel.html')
from flask import Blueprint
from flask_restplus import Resource, Api, reqparse
auth_bp = Blueprint('auth', __name__)
auth_bp.config = {}
auth_api = Api(auth_bp)
parser = reqparse.RequestParser()
class LoginApi(Resource):
def post(self):
print('hello')
parser.add_argument('email',type=str)
parser.add_argument('pasword',type=str)
args = parser.parse_args()
email = args.get('email',None)
password = args.get('password',None)
if not email:
return {'status': 'success', 'message': 'missing email'}, 200
if not password:
return {'status': 'success', 'message': 'missing password'}, 200
def get(self):
print('hello')
parser.add_argument('email',type=str)
parser.add_argument('pasword',type=str)
args = parser.parse_args()
email = args.get('email',None)
password = args.get('password',None)
from flask import request, session, redirect, url_for, \
render_template, flash, Blueprint, g
import sqlite3
mainui = Blueprint('mainui', __name__)
mainui.config = {}
## Overide to allow access to configuration values
@mainui.record
def record_params(setup_state):
app = setup_state.app
mainui.config = dict([(key, value)
for (key, value) in app.config.iteritems()])
# Pages
@mainui.route('/')
def index():
channels = query_db("SELECT * FROM channel_with_category")
scenes = query_db("SELECT * FROM scene_with_category")
stacks = query_db("SELECT * FROM stack_with_category")
bpm = query_db("SELECT value FROM settings WHERE name='bpm'")[0]["value"]
fadetime = query_db(
"SELECT value FROM settings WHERE name='fadetime'")[0]["value"]
return render_template('index.html',
channels=channels,
scenes=scenes,
stacks=stacks,
fadetime=fadetime,
"""__init__.py index/
"""
from flask import Blueprint
index_blueprint = Blueprint(
"index",
__name__,
static_url_path="",
static_folder="web/static",
template_folder="web/templates",
)
index_blueprint.config = {}
@index_blueprint.record
def record_params(setup_state):
app = setup_state.app
index_blueprint.config = dict([(key, value)
for key, value in app.config.items()])
from . import routes
from flask import Blueprint
api = Blueprint('api',
'api',
url_prefix='',
static_folder='../../instance/dist/static')
api.config = {}
@api.record
def record_params(setup_state):
app = setup_state.app
api.config = dict([(key, value) for (key, value) in app.config.items()])
from .dataset_api import *
from .document_api import *
from .project_api import *
from .user_api import *
from .summary_api import *
try:
from flask import Blueprint
from flask_sqlalchemy import SQLAlchemy
from flask_praetorian import Praetorian
from flask_cors import CORS
from flask_migrate import Migrate
import flask_login
except ImportError as IE:
print(f"Error importing Models Blueprint: {IE}")
# Initializes (routes) blueprint
model = Blueprint('model', __name__, None)
model.config = {}
# Sets DB Terms
db = SQLAlchemy()
guard = Praetorian()
cors = CORS()
login_manager = flask_login.LoginManager()
try:
# Imports model Classes
from .user import User
from .post import Post
from .room import Room
from .comment import Comment
except Exception as e:
print(f"Error loading models: {e}")
@model.record
-> app creates interactive message
-> 0-n people vote using interactive message buttons
-> Votes are closed, scores shown
-> *
"""
import json
from urllib.parse import urlparse, parse_qs
from pprint import pprint
from itertools import islice
import slack
from flask import Blueprint, current_app, request, g, jsonify
bp = Blueprint("poker", __name__, template_folder='templates')
bp.config = {}
class SlackError(Exception):
status_code = 400
def __init__(self, message, status_code=None, payload=None):
Exception.__init__(self)
self.message = message
if status_code is not None:
self.status_code = status_code
self.payload = payload
def to_dict(self):
rv = dict(self.payload or ())
rv['message'] = self.message
"""
Initialize Flask Blueprint for admin api.
"""
from flask import Blueprint
from flask_restful import Api
from .resource.fluency import DatasetsResource, FluencyResource
from .resource.clarity import ClarityResource
from .resource.fluencylist import FluencyListResource
from .resource.claritylist import ClarityListResource
from .resource.user import UserResource
admin_api = Blueprint('admin_api',
__name__,
static_folder='../../instance/dist/static')
admin_api.config = {}
api = Api()
api.init_app(admin_api)
api.add_resource(DatasetsResource, '/dataset')
api.add_resource(FluencyResource, '/fluency', '/fluency/<int:project_id>')
api.add_resource(ClarityResource, '/clarity', '/clarity/<int:project_id>')
api.add_resource(FluencyListResource, '/fluencylist')
api.add_resource(ClarityListResource, '/claritylist')
api.add_resource(UserResource, '/login')
@admin_api.record
def record_params(setup_state):
"""
Copy flask app config into the api config
"""
app = setup_state.app
from flask_login import (LoginManager, login_user, logout_user, login_required,
current_user)
import requests
import datetime as dt
import logging
from server import utils
from server.models import db, User, Enrollment, Client, Token, Grant
from server.extensions import csrf, oauth_provider, cache
logger = logging.getLogger(__name__)
auth = Blueprint('auth', __name__)
auth.config = {}
@auth.record
def record_params(setup_state):
""" Load used app configs into local config on registration from
server/__init__.py """
app = setup_state.app
oauth.init_app(app)
oauth = OAuth()
google_auth = oauth.remote_app(
'google',
app_key='GOOGLE',
request_token_params={
from threading import Thread
import slack
from flask import Blueprint, current_app
events = Blueprint("events", __name__, template_folder='templates')
events.config = {}
@events.record
def record_slack_config(setup_state):
'''make a copy of relevant config upon blueprint register so we don't need to reference current_app'''
events.config = {
k: v
for k, v in setup_state.app.config.get_namespace('COMPUTER_').items()
}
from computer.slack.route import default_handler, register, EVENT_TYPES
def bg_slack(method=None, token=None, **kwargs):
print(
f'backgrounding task: method={method}, token={"<redacted>" if token else token}, kwargs={kwargs}'
)
if not token:
token = events.config['slack_oauth_access_token']
def send_slack(token, **kwargs):
slackclient = slack.WebClient(token=token)
fun = getattr(slackclient, method)
# @Time : 2019/10/23 17:03
# @Author : Wind
# @Des : 在蓝图中读取config.py配置信息
# @Des : 蓝图中url_for取函数名时，需要加"."，比如url_for('.login')，url_for('.index')
# @Software: PyCharm
from flask import Blueprint, render_template, redirect, request, session, url_for, g, flash
import sqlite3
import config
mytest_bp = Blueprint('mytest',
__name__,
url_prefix='/mytest',
template_folder='templates',
static_folder='static')
mytest_bp.config = config
@mytest_bp.before_request
def before_request():
g.db = sqlite3.connect(mytest_bp.config.DATABASE)
@mytest_bp.teardown_request
def teardown_request(exception):
db = getattr(g, 'db', None)
if db is not None:
db.close()
@mytest_bp.route('/')
#-*-encoding:utf-8-*-
from flask import Flask, request
from flask import Blueprint
from flask.ext import restful
from flask.ext.restful.utils import cors
from database import db
api = restful.Api()
blueprint = Blueprint('hello_blueprint', __name__)
api.init_app(blueprint)
blueprint.config = {}
api.decorators = [cors.crossdomain(origin='*', headers=["Authorization", "Content-Type"])]
class UserModule:
def __init__(self, *args, **kwargs):
if len(args) > 0:
url_prefix = kwargs.get('url_prefix', '/api')
self.init_app(args[0], url_prefix=url_prefix)
def init_app(self, app, url_prefix='/api'):
db.init_app(app)
app.register_blueprint(blueprint, url_prefix=url_prefix)
# Declaração das Rotas da API
from users import ListUsersRest
import json
from flask import jsonify, Blueprint, request, current_app
from db.postgres import db
from flask_cors import cross_origin
from sqlalchemy import Sequence
from flask_json_schema import JsonSchema
from models.department import Department
from models.location import Location
from models.category import Category
from models.sub_category import Subcategory
import pdb
category_api = Blueprint('category_api', __name__)
category_api.config = {}
schema = JsonSchema(category_api)
@category_api.route("/api/v1/category", methods=['POST'])
@cross_origin("*")
def create():
try:
input_json_data = request.get_json()
db.create_all()
db.session.commit()
if not input_json_data:
return {"message": "No input data provided"}, 400
new_category = input_json_data['category']
new_subcategory = input_json_data['subcategory']
category_results = Category.query.filter(
Category.category == new_category)
# Hope we're not using a swift backend
pass
from .exceptions import Error, ObjectNotFoundError, \
ObjectAlreadyExistsError, FunctionalityOmittedError, UserError
__author__ = "Brian Balsamo"
__email__ = "*****@*****.**"
__version__ = "0.1.2"
BLUEPRINT = Blueprint('archstor', __name__)
BLUEPRINT.config = {
'BUFF': 1024 * 1000
}
API = Api(BLUEPRINT)
log = logging.getLogger(__name__)
@BLUEPRINT.errorhandler(Error)
def handle_errors(error):
response = jsonify(error.to_dict())
response.status_code = error.status_code
return response
def check_limit(x):
from .exceptions import Error
from nothashes import crc32, adler32
import multihash
# Add crc32 and adler32 to the multihash interface
multihash.additional_hashers.add(crc32)
multihash.additional_hashers.add(adler32)
__author__ = "Brian Balsamo"
__email__ = "*****@*****.**"
__version__ = "0.2.2"
BLUEPRINT = Blueprint('checksummit', __name__)
BLUEPRINT.config = {}
API = Api(BLUEPRINT)
log = logging.getLogger(__name__)
@BLUEPRINT.errorhandler(Error)
def handle_errors(error):
response = jsonify(error.to_dict())
response.status_code = error.status_code
return response
class Version(Resource):
def get(self):
"""
Initialize Flask Blueprint for user api.
"""
from flask import Blueprint
from flask_restful import Api
from .resource.fluency import FluencyResource
from .resource.clarity import ClarityResource
user_api = Blueprint('user_api', __name__, static_folder='../../../instance/dist/static')
user_api.config = {}
api = Api()
api.init_app(user_api)
api.add_resource(FluencyResource, '/fluency', '/fluency/<int:project_id>')
api.add_resource(ClarityResource, '/clarity', '/clarity/<int:project_id>')
@user_api.record
def record_params(setup_state):
"""
Copy flask app config into the api config
"""
app = setup_state.app
user_api.config = dict([(key, value) for (key, value) in app.config.items()])
current_user)
import requests
import datetime as dt
import logging
from server import utils
from server.models import db, User, Enrollment, Client, Token, Grant
from server.extensions import csrf, oauth_provider, cache
from server.constants import GOOGLE, MICROSOFT
logger = logging.getLogger(__name__)
auth = Blueprint('auth', __name__)
auth.config = {}
provider_auth = None
provider_name = None
oauth = None
@auth.record
def record_params(setup_state):
""" Load used app configs into local config on registration from
server/__init__.py """
global provider_name
global provider_auth
global oauth
oauth = OAuth()
app = setup_state.app
from flask import Blueprint, render_template
proposals = Blueprint('proposals',
__name__,
static_folder='../static',
template_folder='templates')
proposals.config = {}
proposals.logger = None
__author__ = 'Administrator'
from flask import Blueprint
import sys
sys.path.append("../..")
dataExtract = Blueprint('dataExtract', __name__)
dataExtract.config = {}
from app_src.dataExtract import views
from urllib.request import urlopen
from werkzeug import wsgi
from flask import Flask, abort, Blueprint, jsonify, render_template, Response, request
from flask import redirect, url_for, send_file, current_app
from flask.ext.login import login_required, login_user, current_user
from flask_wtf import CsrfProtect
from rdfframework import RdfProperty, get_framework as rdfw
from rdfframework.utilities import render_without_request, code_timer, \
remove_null, pp, clean_iri, uid_to_repo_uri, cbool, make_list
from rdfframework.forms import rdf_framework_form_factory
from rdfframework.api import rdf_framework_api_factory, Api
from rdfframework.security import User
base_site = Blueprint("base_site", __name__,
template_folder="templates")
base_site.config = {}
'''@base_site.before_request
def before_request():
if request.url.startswith('http://'):
url = request.url.replace('http://', 'https://', 1)
code = 301
return redirect(url, code=code)'''
@base_site.route("/")
def home():
print("Current user is {}".format(current_user))
return render_template(
"index.html")
@base_site.route("/tester.html")
from urllib.request import urlopen
from werkzeug import wsgi
from flask import Flask, abort, Blueprint, jsonify, render_template, Response,\
request, redirect, url_for, send_file, current_app
from flask.ext.login import login_required, login_user, current_user, \
logout_user
from flask_wtf import CsrfProtect
from rdfframework import RdfProperty, get_framework as rdfw
from rdfframework.utilities import render_without_request, code_timer, \
remove_null, pp, clean_iri, uid_to_repo_uri, cbool, make_list
from rdfframework.forms import rdf_framework_form_factory
from rdfframework.api import rdf_framework_api_factory, Api
from rdfframework.security import User
rdfw_core = Blueprint("rdfw_core", __name__, template_folder="templates")
rdfw_core.config = {}
@rdfw_core.record
def record_params(setup_state):
"""Function takes the setup_state and updates configuration from
the active application.
Args:
setup_state -- Setup state of the application.
"""
app = setup_state.app
rdfw_core.config = dict([(key, value)
for (key, value) in app.config.items()])
from flask import redirect, url_for, send_file, current_app
from flask_negotiate import produces
from flask.ext.login import login_required, login_user, current_user
from flask_wtf import CsrfProtect
from . import new_badge_class, issue_badge
from rdfframework import RdfProperty, get_framework as rdfw
from rdfframework.utilities import render_without_request, code_timer, \
remove_null, pp, clean_iri, uid_to_repo_uri, cbool, make_list
from rdfframework.forms import rdf_framework_form_factory
from rdfframework.api import rdf_framework_api_factory, Api
from rdfframework.security import User
DEBUG = True
open_badge = Blueprint("open_badge", __name__, template_folder="templates")
open_badge.config = {}
@open_badge.record
def record_params(setup_state):
"""Function takes the setup_state and updates configuration from
the active application.
Args:
setup_state -- Setup state of the application.
"""
app = setup_state.app
open_badge.config = dict([(key, value)
for (key, value) in app.config.items()])
from pymongo import MongoClient, ASCENDING
from gridfs import GridFS
from pypremis.lib import PremisRecord
from pypremis.nodes import Event, EventDetailInformation, EventIdentifier
from pypremis.factories import LinkingObjectIdentifierFactory, \
LinkingEventIdentifierFactory
BLUEPRINT = Blueprint('materialsuite_endpoint', __name__)
BLUEPRINT.config = {
'MONGO_LTS_HOST': None,
'MONGO_PREMIS_HOST': None,
'MONGO_LTS_PORT': 27017,
'MONGO_PREMIS_PORT': 27017,
'MONGO_LTS_DB': 'lts',
'MONGO_PREMIS_DB': 'premis',
'_LTS_FS': None,
'_PREMIS_FS': None
}
API = Api(BLUEPRINT)
log = logging.getLogger(__name__)
def check_limit(x):
if x > BLUEPRINT.config.get("MAX_LIMIT", 1000):
return BLUEPRINT.config.get("MAX_LIMIT", 1000)
return x
from flask import flash, redirect, url_for, make_response, current_app
from flask.ext.mail import Mail, Message
from jinja2 import TemplateNotFound
from flask_login import login_required
from hawkers.models import User, Hawker, CutOffTime, Food, Order, OrderItem, db
from wtforms import form, fields, validators, ValidationError
from wtforms_components import TimeField
import re, os
from werkzeug import secure_filename
from werkzeug.security import check_password_hash, generate_password_hash
from PIL import Image
vendor_page = Blueprint('vendor_page', __name__, template_folder='vendor_templates')
# Manage Configurations
vendor_page.config = {}
@vendor_page.record
def record_app_settings(setup_state) :
app = setup_state.app
vendor_page.mail = Mail(app)
vendor_page.config = dict([(key, value) for (key, value) in app.config.items()])
def allowed_file(filename) :
ret = '.' in filename and filename.rsplit('.', 1)[1] in ('jpg')
return ret
# Forms
class UserForm(form.Form) :
login = fields.TextField('Login Name', [validators.InputRequired(), validators.Length(max=80)])
first_name = fields.TextField('First Name', [validators.InputRequired(), validators.Length(max=100)])
last_name = fields.TextField('Last Name', [validators.InputRequired(), validators.Length(max=100)])
from flask import Blueprint, request, session, redirect, url_for, \
abort, render_template, flash, send_from_directory
from decorators import async, ad_login_req
import MySQLdb
from hashids import Hashids
admin = Blueprint('admin', __name__)
admin.config = {}
## Overide to allow access to configuration values
@admin.record
def record_params(setup_state):
app = setup_state.app
admin.config = dict([(key, value)
for (key, value) in app.config.iteritems()])
@admin.route('/')
@ad_login_req
def admin_main():
return render_template('admin.html')
@admin.route('/login', methods=['POST', 'GET'])
def admin_login():
if request.method == "POST":
username = request.form['username']
password = request.form['password']
if username == admin.config[
'ADMIN_UNAME'] and password == admin.config['ADMIN_PWORD']:
import os
import functools
from flask import Blueprint, render_template, flash, redirect, url_for, request
from flask.ext.login import current_user
REDBERRY_ROOT = os.path.dirname(os.path.realpath(__file__))
cms = Blueprint('redberry',
__name__,
template_folder='templates',
static_folder='static/redberry')
cms.config = {'db': None, 'meta': {'title': None}}
##############
# Jinja Filters
###############
@cms.app_template_filter()
def pretty_date(dttm):
return dttm.strftime("%m/%d")
@cms.app_template_filter()
def date(dttm):
return dttm.strftime('%Y-%m-%d')
########
# Config
########
# Automatically called once when the Blueprint is registered on the app.
from flask import Blueprint, request
# from cerberus import Validator
# from admin.exception import BadRequest, YMException
main = Blueprint("main", __name__)
main.config = {}
# @main.record
# def record_params(setup_state):
# apps = setup_state.apps
# main.config = dict([(key, value) for (key, value) in apps.config.items()])
from . import login
import json
from flask import jsonify, Blueprint, request, current_app
from models.location import Location
from db.postgres import db
from flask_json_schema import JsonSchema
from flask_cors import cross_origin
from sqlalchemy import Sequence
import pdb
location_api = Blueprint('location_api', __name__)
location_api.config = {}
schema = JsonSchema(location_api)
@location_api.route("/api/v1/location", methods=['POST'])
@cross_origin("*")
def create():
try:
input_json_data = request.get_json()
if not input_json_data:
return {"message": "No input data provided"}, 400
new_location = input_json_data['location']
new_department = input_json_data['department']
location_results = Location.query.filter(
Location.location == new_location)
# validation of location
for temp in location_results:
string_val = temp.serialize()
if (new_location == string_val.get('location')
and new_department == string_val.get('department')):
from functools import wraps
from flask import Blueprint, jsonify, request, url_for
from flask_login import current_user
import flask_restful as restful
from flask_restful import reqparse, fields, marshal_with
from flask_restful.representations.json import output_json
from server.extensions import cache
from server.utils import encode_id, decode_id
import server.models as models
from server.autograder import submit_continous
from server.constants import STAFF_ROLES
endpoints = Blueprint('api', __name__)
endpoints.config = {}
@endpoints.record
def record_params(setup_state):
""" Load used app configs into local config on registration from
server/__init__.py """
app = setup_state.app
endpoints.config['tz'] = app.config.get('TIMEZONE', 'utc') # sample config
endpoints.config['debug'] = app.debug
api = restful.Api(endpoints)
API_VERSION = 'v3'
from werkzeug import wsgi
from flask import Flask, abort, Blueprint, jsonify, render_template, Response,\
request, redirect, url_for, send_file, current_app
from flask.ext.login import login_required, login_user, current_user, \
logout_user
from flask_wtf import CsrfProtect
from rdfframework import RdfProperty, get_framework as rdfw
from rdfframework.utilities import render_without_request, code_timer, \
remove_null, pp, clean_iri, uid_to_repo_uri, cbool, make_list
from rdfframework.forms import rdf_framework_form_factory
from rdfframework.api import rdf_framework_api_factory, Api
from rdfframework.security import User
rdfw_core = Blueprint("rdfw_core", __name__,
template_folder="templates")
rdfw_core.config = {}
@rdfw_core.record
def record_params(setup_state):
"""Function takes the setup_state and updates configuration from
the active application.
Args:
setup_state -- Setup state of the application.
"""
app = setup_state.app
rdfw_core.config = dict(
[(key, value) for (key, value) in app.config.items()]
)
DEBUG = True
