from flask import Flask
from flask_admin import Admin
from flask_cors import CORS
from flask_marshmallow import Marshmallow
from flask_migrate import Migrate
from flask_sqlalchemy import SQLAlchemy
sys.path.append(os.path.realpath(os.path.join(os.path.dirname(__file__), "../", "../")))
from portfolio_backend.application.settings import BackendSettings
backend_application = Flask(
import_name=__name__,
template_folder=f"{BackendSettings.BASE_DIR}/templates/"
)
backend_application.config.from_object(BackendSettings)
CORS(backend_application)
db = SQLAlchemy(backend_application)
migrate = Migrate(backend_application, db)
ma = Marshmallow(backend_application)
admin = Admin(backend_application, name="portfolio", template_mode="bootstrap3")
from portfolio_backend import admin # noqa
from portfolio_backend import models # noqa
from portfolio_backend import routes # noqa
from portfolio_backend import schemas # noqa
# fmt: on
# Import standard library modules
import re
# Import installed packages
from flask_cors import CORS
# Import app code
from app.main import app
from app.core import config
# Anything from SERVER_NAME
use_domain = config.SERVER_NAME.replace(".", r"\.")
cors_origins_regex = re.compile(r"^(https?:\/\/(?:.+\.)?(" + use_domain +
r")(?::\d{1,5})?)$")
CORS(app, origins=cors_origins_regex, supports_credentials=True)
from flask import Flask, jsonify, request
from flask_cors import CORS
app = Flask(__name__)
cors = CORS(app, resources={r"/getMsg": {"origins": "*"}})
@app.route('/')
def hello_world():
return 'Hello World!'
@app.route('/getMsg', methods=['GET', 'POST'])
def home():
response = request.json
print(response)
return jsonify(response)
# return response
# 启动运行
if __name__ == '__main__':
app.run() # 这样子会直接运行在本地服务器，也即是 localhost:5000
# app.run(host='your_ip_address') # 这里可通过 host 指定在公网IP上运行
app.config["ADMIN_PASSWORD"] = os.getenv("ADMIN_PASSWORD", "admin-password")
app.config["PERMITTED_SOURCE_IP_RANGES"] = os.getenv(
"PERMITTED_SOURCE_IP_RANGES", "")
app.config["CORS_PERMITTED_ORIGINS"] = os.getenv("CORS_PERMITTED_ORIGINS", "*")
app.config["JWT_SECRET_KEY"] = os.getenv("JWT_SECRET_KEY", "super-secret")
app.config["JWT_ACCESS_TOKEN_EXPIRES"] = 3 * 3600 # 3 hours
app.config["JWT_IDENTITY_CLAIM"] = "sub"
app.config["RESTPLUS_MASK_SWAGGER"] = False
app.config["SWAGGER_UI_REQUEST_DURATION"] = True
app.config["SWAGGER_UI_DOC_EXPANSION"] = "list"
app.config["SWAGGER_UI_JSONEDITOR"] = True
api.init_app(app)
db.init_app(app)
jwt.init_app(app)
jwt._set_error_handler_callbacks(api)
marshmallow.init_app(app)
CORS(app, origins=app.config["CORS_PERMITTED_ORIGINS"])
with db.database:
db.database.create_tables([
AuditTable, ContactTable, ScanTable, TaskTable, VulnTable, ResultTable
])
@app.after_request
def add_header(response):
response.headers[
"Cache-Control"] = "private, no-store, no-cache, must-revalidate"
return response
from flask import Flask, jsonify, request
from flask_cors import CORS
import uuid
# configuration
DEBUG = True
# instantiate the app
app = Flask(__name__)
app.config.from_object(__name__)
# enable CORS
CORS(app, resources={r'/*': {'origins': '*'}})
BOOKS = [{
'id': uuid.uuid4().hex,
'title': 'On the Road',
'author': 'Jack Kerouac',
'read': True
}, {
'id': uuid.uuid4().hex,
'title': 'Harry Potter and the Philosopher\'s Stone',
'author': 'J. K. Rowling',
'read': False
}, {
'id': uuid.uuid4().hex,
'title': 'Green Eggs and Ham',
'author': 'Dr. Seuss',
'read': True
}]
def create_app(test_config=None):
# create and configure the app
app = Flask(__name__)
setup_db(app)
CORS(app)
@app.route('/')
def index():
return "Welcome to Musicakes!"
@app.route('/artists', methods=['GET'])
def get_artists():
try:
all_artists = Artist.query.all()
formatted_all_artists = [artist.short() for artist in all_artists]
return jsonify({
'success': True,
'artists': formatted_all_artists
})
except:
abort(404)
@app.route('/releases', methods=['GET'])
def get_releases():
try:
all_releases = Release.query.all()
formatted_all_releases = [release.short()
for release in all_releases]
return jsonify({
'success': True,
'releases': formatted_all_releases
})
except:
abort(404)
@app.route('/tracks', methods=['GET'])
def get_tracks():
try:
all_tracks = Track.query.all()
formatted_all_tracks = [track.short() for track in all_tracks]
return jsonify({
'success': True,
'tracks': formatted_all_tracks
})
except:
abort(404)
@app.route('/artists', methods=['POST'])
@requires_auth('create:artist')
def create_artist(payload):
try:
name = request.get_json()['name']
country = request.get_json()['country']
new_artist = Artist(
name=name,
country=country
)
new_artist.insert()
return jsonify({
'success': True,
'name': new_artist.name,
'country': new_artist.country
})
except:
abort(422)
@app.route('/releases', methods=['POST'])
@requires_auth('create:release')
def create_release(payload):
try:
name = request.get_json()['name']
artist_id = request.get_json()['artist_id']
price = request.get_json()['price']
new_release = Release(
name=name,
artist_id=artist_id,
price=price
)
new_release.insert()
return jsonify({
'success': True,
'name': new_release.name,
'artist_id': new_release.artist_id,
'price': new_release.price
})
except:
abort(422)
@app.route('/tracks', methods=['POST'])
@requires_auth('create:track')
def create_track(payload):
try:
name = request.get_json()['name']
artist_id = request.get_json()['artist_id']
release_id = request.get_json()['release_id']
price = request.get_json()['price']
new_track = Track(
name=name,
artist_id=artist_id,
release_id=release_id,
price=price
)
new_track.insert()
return jsonify({
'success': True,
'name': new_track.name,
'artist_id': new_track.artist_id,
'release_id': new_track.release_id,
'price': new_track.price
})
except:
abort(422)
@app.route('/artists/<int:id>', methods=['PATCH'])
@requires_auth('update:artist')
def update_artist(payload, id):
try:
current_artist = Artist.query.get(id)
if current_artist is None:
abort(404)
if 'name' in request.get_json():
name = request.get_json()['name']
current_artist.name = name
if 'country' in request.get_json():
country = request.get_json()['country']
current_artist.country = country
current_artist.update()
return jsonify({
'success': True,
'name': current_artist.name,
'country': current_artist.country
})
except:
abort(400)
@app.route('/releases/<int:id>', methods=['PATCH'])
@requires_auth('update:release')
def update_release(payload, id):
try:
current_release = Release.query.get(id)
if current_release is None:
abort(404)
if 'name' in request.get_json():
name = request.get_json()['name']
current_release.name = name
if 'artist_id' in request.get_json():
artist_id = request.get_json()['artist_id']
current_release.artist_id = artist_id
if 'price' in request.get_json():
price = request.get_json()['price']
current_release.price = price
current_release.update()
return jsonify({
'success': True,
'name': current_release.name,
'artist_id': current_release.artist_id,
'price': current_release.price
})
except:
abort(400)
@app.route('/tracks/<int:id>', methods=['PATCH'])
@requires_auth('update:track')
def update_track(payload, id):
try:
current_track = Track.query.get(id)
if current_track is None:
abort(404)
if 'name' in request.get_json():
name = request.get_json()['name']
current_track.name = name
if 'artist_id' in request.get_json():
artist_id = request.get_json()['artist_id']
current_track.artist_id = artist_id
if 'release_id' in request.get_json():
release_id = request.get_json()['release_id']
current_track.release_id = release_id
if 'price' in request.get_json():
price = request.get_json()['price']
current_track.price = price
current_track.update()
return jsonify({
'success': True,
'name': current_track.name,
'artist_id': current_track.artist_id,
'release_id': current_track.release_id,
'price': current_track.price
})
except:
abort(400)
@app.route('/artists/<int:id>', methods=['DELETE'])
@requires_auth('delete:artist')
def delete_artist(payload, id):
try:
artist = Artist.query.get(id)
if artist is None:
abort(404)
artist.delete()
return jsonify({
'success': True
})
except Exception as e:
print(e)
abort(422)
@app.route('/releases/<int:id>', methods=['DELETE'])
@requires_auth('delete:release')
def delete_release(payload, id):
try:
release = Release.query.get(id)
if release is None:
abort(404)
release.delete()
return jsonify({
'success': True
})
except:
abort(422)
@app.route('/tracks/<int:id>', methods=['DELETE'])
@requires_auth('delete:track')
def delete_track(payload, id):
try:
track = Track.query.get(id)
if track is None:
abort(404)
track.delete()
return jsonify({
'success': True
})
except:
abort(422)
"""
Errors handling
"""
@app.errorhandler(400)
def bad_request(error):
return jsonify({
'success': False,
'error': 400,
'message': 'bad request'
}), 400
@app.errorhandler(404)
def not_found(error):
return jsonify({
'success': False,
'error': 404,
'message': 'resource not found'
}), 404
@app.errorhandler(405)
def method_not_allowed(error):
return jsonify({
'success': False,
'error': 405,
'message': 'method not allowed'
}), 405
@app.errorhandler(422)
def unprocessable(error):
return jsonify({
'success': False,
'error': 422,
'message': 'unprocessable'
}), 422
@app.errorhandler(500)
def internal_server_error(error):
return jsonify({
'success': False,
'error': 500,
'message': 'internal server error'
}), 500
@app.errorhandler(AuthError)
def auth_error(AuthError):
return jsonify({
'success': False,
'error': AuthError.status_code,
'message': AuthError.error['description']
}), 401
return app
length = 102400
if byte1 < file_size:
start = byte1
if byte2:
length = byte2 + 1 - byte1
else:
length = file_size - start
with open(full_path, 'rb') as f:
f.seek(start)
chunk = f.read(length)
return chunk, start, length, file_size
CORS(server)
@server.route('/download_video', methods=('GET', 'POST'))
def download():
if request.method == 'POST':
url = request.args['url']
print(url)
db = get_db()
if not is_video_exists(url):
video_path = download_video(url)
print(video_path, url)
db.execute('INSERT INTO video (url, file_path) VALUES (?, ?) ',
(url, video_path))
db.commit()
return "download successfully"
print("Cannot load RPi.GPIO")
try:
from wireless import Wireless
wireless = Wireless()
except:
print("Cannot load wireless")
try:
import alsaaudio
mixer = alsaaudio.Mixer("Headphone")
except:
print("Cannot load alsaaudio")
app = Flask(__name__)
CORS(app, supports_credentials=True)
# Setup -------------------------------
def loadData():
try:
with open('config.json', encoding='utf-8') as json_file:
return json.load(json_file)
except:
print("Cannot load config file")
return
data = loadData()
OHP_PORT = data["server"]["port"]
OHP_DEBUG = data["server"]["debug"]
import os
import json
from flask import Blueprint, jsonify, request
from flask_cors import CORS
from data_management.db import getDb
from data_management.get import getVideo
from data_management.streams import rebootStream
from data_management.tempFileManger import moveFiles
bp = Blueprint('save', __name__, url_prefix='/save')
CORS(bp)
@bp.route('/settings', methods=(['POST']))
def settings():
"""updates the settings in both the file and backend"""
data = request.json
wheelRadius = data['wheelRad']
mainCam = data['mainCamFPS']
secondaryCam = data['backCamFPS']
if 'WHEEL_RADIUS' not in os.environ:
os.environ['WHEEL_RADIUS'] = '6'
elif (wheelRadius and wheelRadius != os.environ.get('WHEEL_RADIUS')):
os.environ.pop('WHEEL_RADIUS')
os.environ['WHEEL_RADIUS'] = str(wheelRadius)
def create_app():
# Flask app initialization
app = Flask(__name__)
app.config.from_object(Config())
# Creating database
if not os.path.exists(DB_PATH + DB_NAME):
os.mknod(DB_PATH + DB_NAME)
# Database configuration
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = bool(os.getenv('SQLALCHEMY_TRACK_MODIFICATIONS'))
app.config['SQLALCHEMY_DATABASE_URI'] = DB_URL
# Database initialization in Flask app
db.init_app(app)
scheduler.init_app(app)
scheduler.start()
@app.before_first_request
def load_tasks():
pass
# Defining secret key for encryption and time of expiration of each access token that will be generated
app.config['JWT_SECRET_KEY'] = str(os.getenv('JWT_SECRET_KEY'))
app.config['JWT_ACCESS_TOKEN_EXPIRES'] = int(os.getenv('JWT_ACCESS_TOKEN_EXPIRES'))
# JWT management initialization in Flask app
jwt.init_app(app)
# Defining general configuration for SMTP server
app.config['MAIL_SERVER'] = os.getenv('MAIL_SERVER')
app.config['MAIL_PORT'] = os.getenv('MAIL_PORT')
app.config['MAIL_USE_TLS'] = os.getenv('MAIL_USE_TLS')
app.config['MAIL_USERNAME'] = os.getenv('MAIL_USERNAME')
app.config['MAIL_PASSWORD'] = os.getenv('MAIL_PASSWORD')
app.config['FLASKY_MAIL_SENDER'] = os.getenv('FLASKY_MAIL_SENDER')
# Flask mail handler initialization in Flask app
out_server_sender.init_app(app)
# Flask CORS configuration to allow access
CORS(app, resources={r"/*": {"origins": "*", "expose_headers": ['X-Total-Count']}})
# When the database is "connected in Flask app, the primary keys will activate"
with app.app_context():
from sqlalchemy import event
event.listen(db.engine, 'connect', activate_primary_keys)
# Defining urls for each resource
api.add_resource(controller.SensorController, '/sensors/<id_num>')
api.add_resource(controller.SensorsController, '/sensors')
api.add_resource(controller.USeismController, '/seisms/unverified/<id_num>')
api.add_resource(controller.USeismsController, '/seisms/unverified/')
api.add_resource(controller.VSeismController, '/seisms/verified/<id_num>')
api.add_resource(controller.GSeismsController, '/seisms/coordinates')
api.add_resource(controller.VSeismsController, '/seisms/verified/')
api.add_resource(controller.UserController, '/users/<id_num>')
api.add_resource(controller.UsersController, '/users')
api.add_resource(controller.UsersFilter, '/users/filter')
api.add_resource(controller.SensorsFilter, '/sensors/filter')
# Defining blueprints for each blueprint
app.register_blueprint(auth_controller)
app.register_blueprint(mail_controller)
# Final app initialization
api.init_app(app)
return app
def create_app(test_config=None):
# create and configure the app
app = Flask(__name__)
setup_db(app)
CORS(app, resources={r"/*": {"origins": "*"}})
@app.after_request
def after_request(response):
response.headers.add('Access-Control-Allow-Headers',
'Content-Type, Authorization')
response.headers.add('Access-Control-Allow-Methods',
'GET, POST, PATCH, DELETE, OPTIONS')
return response
@app.route('/')
def health():
return jsonify({'health': 'Running!!'}), 200
@app.route('/categories')
def get_categories():
categories_query = Category.query.order_by(Category.id).all()
categories_data = {}
if len(categories_query) == 0:
abort(500)
for category in categories_query:
categories_data[category.id] = category.type
return jsonify({'categories': categories_data}), 200
@app.route('/questions')
def get_questions():
search_term = request.args.get('search_term', '')
current_category = request.args.get('current_category', None)
current_category = None if current_category == '' else current_category
page = request.args.get('page', 1, type=int)
start = (page - 1) * QUESTIONS_PER_PAGE
end = start + QUESTIONS_PER_PAGE
try:
questions_query = Question.query.filter(
Question.question.ilike("%{}%".format(search_term)))
if current_category is not None:
questions_query = questions_query.filter(
Question.category == current_category)
questions_query = questions_query.order_by(Question.id).all()
questions_data = [
question.format() for question in questions_query
]
selected_questions_data = questions_data[start:end]
if len(selected_questions_data) == 0:
raise IndexError
categories_query = Category.query.order_by(Category.id).all()
categories_data = {}
for category in categories_query:
categories_data[category.id] = category.type
return jsonify({
'questions': selected_questions_data,
'total_questions': len(questions_data),
'categories': categories_data,
'current_category': current_category,
'search_term': search_term
}), 200
except IndexError:
abort(404)
except:
abort(500)
@app.route('/questions/<int:question_id>', methods=['DELETE'])
def delete_question_by_id(question_id):
question = Question.query.get_or_404(question_id)
try:
question.delete()
return jsonify({'success': True}), 200
except:
abort(500)
@app.route('/questions', methods=['POST'])
def create_question():
try:
request_body = request.get_json()
if request_body['question'] == '' or request_body['answer'] == '':
raise TypeError
new_question = Question(request_body['question'],
request_body['answer'],
request_body['category'],
request_body['difficulty'])
new_question.insert()
return jsonify({'success': True}), 201
except TypeError:
abort(422)
except:
abort(500)
@app.route('/questions/search', methods=['POST'])
def search_questions():
try:
request_body = request.get_json()
if 'searchTerm' not in request_body or 'currentCategory' not in request_body:
raise TypeError
questions_search_term = request_body['searchTerm']
current_category = request_body['currentCategory']
questions_query = Question.query.filter(
Question.question.ilike("%{}%".format(questions_search_term)))
if current_category is not None:
questions_query = questions_query.filter(
Question.category == current_category)
questions_query = questions_query.order_by(Question.id).all()
questions_data = [
question.format() for question in questions_query
]
categories_query = Category.query.order_by(Category.id).all()
categories_data = {}
for category in categories_query:
categories_data[category.id] = category.type
return jsonify({
'questions': questions_data[:QUESTIONS_PER_PAGE],
'total_questions': len(questions_data),
'categories': categories_data,
'current_category': current_category,
'search_term': questions_search_term
}), 200
except TypeError:
abort(400)
except:
abort(500)
@app.route('/categories/<category_id>/questions')
def get_category_specific_question(category_id):
try:
questions_search_term = request.args.get('search_term', '')
questions_query = Question.query.filter(
Question.category == category_id,
Question.question.ilike(
"%{}%".format(questions_search_term))).order_by(
Question.id).all()
questions_data = [
question.format() for question in questions_query
]
if len(questions_data) == 0:
raise IndexError
categories_query = Category.query.order_by(Category.id).all()
categories_data = {}
for category in categories_query:
categories_data[category.id] = category.type
return jsonify({
'questions': questions_data[:QUESTIONS_PER_PAGE],
'total_questions': len(questions_data),
'categories': categories_data,
'current_category': category_id,
'search_term': questions_search_term
}), 200
except IndexError:
abort(404)
except:
abort(500)
@app.route('/quizzes', methods=['POST'])
def play_quiz():
try:
request_body = request.get_json()
if 'previous_questions' not in request_body \
or 'quiz_category' not in request_body \
or 'id' not in request_body['quiz_category']:
raise TypeError
previous_questions = request_body['previous_questions']
category_id = request_body['quiz_category']['id']
questions_query = Question.query.with_entities(Question.id).filter(
Question.id.notin_(previous_questions))
if category_id != 0:
questions_query = questions_query.filter(
Question.category == str(category_id))
questions_query = questions_query.order_by(Question.id).all()
question_ids = [q.id for q in questions_query]
if len(question_ids) == 0:
return jsonify({'question': None}), 200
random_question_id = random.choice(question_ids)
next_question = Question.query.get(random_question_id).format()
return jsonify({'question': next_question}), 200
except TypeError:
abort(400)
except:
abort(500)
@app.errorhandler(400)
@app.errorhandler(404)
@app.errorhandler(405)
@app.errorhandler(422)
@app.errorhandler(500)
def error_handler(error):
return jsonify({
'success': False,
'error': error.code,
'message': error.description
}), error.code
return app
from d7a.alp.command import Command
from d7a.alp.interface import InterfaceType
from d7a.d7anp.addressee import IdType, Addressee
from d7a.phy.channel_header import ChannelBand, ChannelCoding, ChannelClass
from d7a.sp.configuration import Configuration
from d7a.sp.qos import QoS, ResponseMode
from d7a.system_files.system_files import SystemFiles
from d7a.system_files.system_file_ids import SystemFileIds
from d7a.types.ct import CT
from modem.modem import Modem
app = Flask(__name__, static_url_path='/static')
app.config[
'SEND_FILE_MAX_AGE_DEFAULT'] = 0 # do not cache static assets for now
CORS(
app
) # TODO can be removed after integrating the ng project (and serving ng through flask)
socketio = SocketIO(app)
eventlet.monkey_patch()
modem = None
@app.route('/')
def index():
return render_template('index.html',
systemfiles=SystemFiles().get_all_system_files(),
qos_response_modes=ResponseMode.__members__,
id_types=IdType.__members__)
data['num_ab_readings'] = 0
data['speed_ab_readings'] = 0
else:
data['num_ab_readings'] = len(ab_data)
data['speed_ab_readings'] = max(item['speed_at_enable']
for item in ab_data)
data['last_updated'] = datetime.datetime.now().strftime(
"%Y-%m-%dT%H:%M:%SZ")
with open(app_config['datastore']['filename'], 'w') as outfile:
json.dump(data, outfile)
logger.debug(data)
logger.info("Ending Periodic Processing")
def init_scheduler():
sched = BackgroundScheduler(daemon=True)
sched.add_job(populate_stats,
'interval',
seconds=app_config['scheduler']['period_sec'])
sched.start()
app = connexion.FlaskApp(__name__, specification_dir='')
CORS(app.app)
app.app.config['CORS_HEADERS'] = 'Content-Type'
app.add_api("openapi.yml", strict_validation=True, validate_responses=True)
if __name__ == "__main__":
init_scheduler()
app.run(port=8100, use_reloader=False)
def create_app(test_config=None):
# Initialize the flask application
app = Flask(__name__)
db = setup_db(app)
cors = CORS(app, resources={r'/*': {'origins': '*'}})
# Add CORS headers to response
@app.after_request
def add_cors_headers(response):
response.headers.add('Access-Control-Allow-Headers', 'Content-Type')
response.headers.add('Access-Control-Allow-Methods',
'GET,POST,PATCH,DELETE,OPTIONS')
return response
# GET /categories
@app.route('/categories')
def get_categories():
try:
# Query all the categories
categories = Category.query.all()
if not categories:
abort(404)
# Format the categories
categories_data = {}
for category in categories:
categories_data[category.id] = category.type
return jsonify({
'success': True,
'categories': categories_data,
}), 200
except Exception:
print(sys.exc_info())
db.session.rollback()
abort(422)
finally:
db.session.close()
# GET /questions?page=1
@app.route('/questions')
def get_questions():
try:
# Get the page no. from query string
page = int(request.args.get('page', 1))
# Get paginated questions and format data
questions = Question.query.paginate(page, QUESTIONS_PER_PAGE)
questions_data = [
question.format() for question in questions.items
]
# Get all categories and format data
categories = Category.query.all()
categories_data = {}
for category in categories:
categories_data[category.id] = category.type
if not questions_data or not categories:
abort(404)
return jsonify({
'success': True,
'total_questions': questions.total,
'questions': questions_data,
'categories': categories_data,
'current_category': None
}), 200
except Exception:
print(sys.exc_info())
db.session.rollback()
abort(422)
finally:
db.session.close()
# DELETE /questions/id
@app.route('/questions/<int:id>', methods=['DELETE'])
def delete_question(id):
try:
# Get the question by id
question = Question.query.get(id)
if not question:
abort(404)
# Delete question
db.session.delete(question)
db.session.commit()
return jsonify({'success': True, 'id': question.id}), 200
except Exception:
print(sys.exc_info())
db.session.rollback()
abort(422)
finally:
db.session.close()
# POST /questions
@app.route('/questions', methods=['POST'])
def add_question():
try:
# Get the data submitted
data = request.get_json()
question = data.get('question')
answer = data.get('answer')
difficulty = int(data.get('difficulty'))
category = data.get('category')
if not (data and question and answer and difficulty and category):
abort(400)
# Create a new question and add it
new_question = Question(question, answer, difficulty, category)
db.session.add(new_question)
db.session.commit()
return jsonify({'success': True, 'id': new_question.id}), 200
except Exception:
print(sys.exc_info())
db.session.rollback()
abort(422)
finally:
db.session.close()
# POST /questions/search
@app.route('/questions/search', methods=['POST'])
def search_questions():
try:
# Get the search term
data = request.get_json()
search_term = data.get('searchTerm')
# if not search_term:
# abort(400)
# Query the database based on search
questions = Question.query.filter(
Question.question.ilike(f'%{search_term}%')).all()
questions = [question.format() for question in questions]
# if not questions:
# abort(404)
return jsonify({
'success': True,
'questions': questions,
'total_questions': len(questions),
'current_category': None
}), 200
except Exception:
print(sys.exc_info())
db.session.rollback()
abort(422)
finally:
db.session.close()
# GET /categories/id/questions
@app.route('/categories/<int:id>/questions')
def get_questions_by_category(id):
try:
# Get the questions with category id
questions = Question.query.filter_by(category=id).all()
questions_data = [question.format() for question in questions]
if not questions_data:
abort(404)
return jsonify({
'success': True,
'total_questions': len(questions),
'questions': questions_data,
'current_category': id
}), 200
except Exception:
print(sys.exc_info())
db.session.rollback()
abort(422)
finally:
db.session.close()
# POST /quizzes
@app.route('/quizzes', methods=['POST'])
def play_quiz():
try:
data = request.get_json()
previous_questions = data.get('previous_questions')
quiz_category = data.get('quiz_category')
# Get the questions by category
if quiz_category['id'] == 0:
questions = Question.query.all()
else:
questions = Question.query.filter_by(
category=quiz_category['id']).all()
# Filter out previous questions
while True:
question = random.choice(questions)
if question.id not in previous_questions:
break
return jsonify({
'success': True,
'question': question.format()
}), 200
except Exception:
print(sys.exc_info())
db.session.rollback()
abort(422)
finally:
db.session.close()
@app.errorhandler(400)
def bad_request(error):
return jsonify({
'success': False,
'error': 400,
'message': 'Bad request error'
}), 400
@app.errorhandler(404)
def not_found(error):
return jsonify({
'success': False,
'error': 404,
'message': 'Resource not found'
}), 404
@app.errorhandler(500)
def internal_server_error(error):
return jsonify({
'success': False,
'error': 500,
'message': 'An error has occured, please try again'
}), 500
@app.errorhandler(422)
def unprocesable_entity(error):
return jsonify({
'success': False,
'error': 422,
'message': 'Unprocessable entity'
}), 422
return app
from flask import Flask, render_template
import responder
from flask_cors import CORS
ALLOWED_HOSTS = {r"/": {"origins": "*"}}
app = Flask(__name__, static_folder='static/')
cors = CORS(app, resources=ALLOWED_HOSTS)
api = responder.API(allowed_hosts=[])
app.config['CORS_HEADERS'] = 'Content-Type'
@app.route("/", methods=['post', 'get'])
def home():
return 'its working'
if __name__ == "__main__":
app.run(host='0.0.0.0')
def create_app(config=None) -> connexion.FlaskApp:
# configure_logger()
logger.info("creating flask app", config=config)
region = "localhost"
host = f"http://dynamodb:{CFG.DYNALITE_PORT}" if is_docker() else CFG.DYNALITE_URL
stripe.api_key = CFG.STRIPE_API_KEY
logger.debug("aws", aws=CFG.AWS_EXECUTION_ENV)
if CFG.AWS_EXECUTION_ENV:
region = "us-west-2"
host = None
logger.info("app", port=CFG.DYNALITE_PORT, table_name=CFG.DELETED_USER_TABLE)
options = dict(swagger_ui=CFG.SWAGGER_UI)
app = connexion.FlaskApp(__name__, specification_dir="./", options=options)
app.add_api(
"swagger.yaml",
pass_context_arg_name="request",
strict_validation=True,
validate_responses=True,
)
app.app.subhub_account = SubHubAccount(
table_name=CFG.USER_TABLE, region=region, host=host
)
app.app.subhub_deleted_users = SubHubDeletedAccount(
table_name=CFG.DELETED_USER_TABLE, region=region, host=host
)
if not app.app.subhub_account.model.exists():
app.app.subhub_account.model.create_table(
read_capacity_units=1, write_capacity_units=1, wait=True
)
if not app.app.subhub_deleted_users.model.exists():
app.app.subhub_deleted_users.model.create_table(
read_capacity_units=1, write_capacity_units=1, wait=True
)
# Setup error handlers
@app.app.errorhandler(SubHubError)
def display_subhub_errors(e: SubHubError):
if e.status_code == 500:
logger.error("display sub errors", error=e)
response = jsonify(e.to_dict())
response.status_code = e.status_code
return response
for error in (
stripe.error.APIConnectionError,
stripe.error.APIError,
stripe.error.RateLimitError,
stripe.error.IdempotencyError,
):
app.app.errorhandler(error)(intermittent_stripe_error)
for error in (stripe.error.AuthenticationError,):
app.app.errorhandler(error)(server_stripe_error)
for error in (
stripe.error.InvalidRequestError,
stripe.error.StripeErrorWithParamCode,
):
app.app.errorhandler(error)(server_stripe_error_with_params)
for error in (stripe.error.CardError,):
app.app.errorhandler(error)(server_stripe_card_error)
for error in (pynamodb.exceptions.GetError,):
app.app.errorhandler(error)(database_connection_error)
@app.app.before_request
def before_request():
headers = dump_safe_headers(request.headers)
logger.bind(correlation_id=extract_safe(headers, "X-Amzn-Trace-Id"))
logger.debug("Request headers", headers=headers)
logger.debug("Request body", body=request.get_data())
g.subhub_account = current_app.subhub_account
g.subhub_deleted_users = current_app.subhub_deleted_users
g.app_system_id = None
if CFG.PROFILING_ENABLED:
if "profile" in request.args and not hasattr(sys, "_called_from_test"):
from pyinstrument import Profiler
g.profiler = Profiler()
g.profiler.start()
@app.app.after_request
def after_request(response):
logger.unbind("correlation_id")
if not hasattr(g, "profiler") or hasattr(sys, "_called_from_test"):
return response
if CFG.PROFILING_ENABLED:
g.profiler.stop()
output_html = g.profiler.output_html()
return app.app.make_response(output_html)
return response
CORS(app.app)
return app
import logging # make our life easier when debugging.
import os # path joining.
from flask import Flask, jsonify, make_response
from flask_cors import CORS # if someone loads the front end via file browser, localhost is CORS
DATA_DIR = 'data'
TOTALS_FILE = 'oys_totals.tsv'
FREQ_FILE = 'oys_freq.tsv'
"""
I'd much rather be using connexion (https://github.com/zalando/connexion) or blueprint
for loading API routes from an OpenAPI specification, but I ran out of time when putting
this brief demo together to do everything 'by the book'.
"""
APP = Flask(__name__)
CORS(
APP
) # allow cross domain requests so the API doesn't get disallowed by the browser.
def get_tsv_dataset(dataset_path):
"""
Helper function to get a single TSV row from a data file.
:param dataset_path: str: path to a TSV that contains a one line dataset.
:return: list of str, or None if data could not be read.
"""
if not os.path.exists(dataset_path):
logging.error('No such path %s', dataset_path)
return None
try:
ds_file = open(dataset_path)
import os
from werkzeug.exceptions import HTTPException
# Global Flask Application Variable: app
app = Flask(__name__)
swagger = Swagger(app)
# global strict slashes
app.url_map.strict_slashes = False
# flask server environmental setup
host = os.getenv('HBNB_API_HOST', '0.0.0.0')
port = os.getenv('HBNB_API_PORT', 5000)
# Cross-Origin Resource Sharing
cors = CORS(app, resources={r"/api/v1/*": {'origins': "*"}})
# app_views BluePrint defined in api.v1.views
app.register_blueprint(app_views)
# begin flask page rendering
@app.teardown_appcontext
def teardown_db(exception):
"""
after each request, this method calls .close() (i.e. .remove()) on
the current SQLAlchemy Session
"""
storage.close()
import os
from flask import Flask
from flask_cors import CORS
cors = CORS()
def create_app():
app = Flask(__name__)
cors.init_app(app)
app_settings = os.getenv("APP_SETTINGS")
app.config.from_object(app_settings)
app.config["CORS_HEADERS"] = "Access-Control-Allow-Origin"
from project.api.api import views_blueprint
app.register_blueprint(views_blueprint)
return app
reset_password_salt = "reset-password-salt"
# supported_languages = ["en", "fr", "pt", "it", "de", "es"]
supported_languages = ["en", "fr"]
origins = []
if flask_env == "development":
origins = ["http://localhost:3000", "http://dev.localhost:3000"]
elif flask_env == "production":
origins = ["https://www.dofuslab.io", "https://dofuslab.io"]
db = SQLAlchemy(app)
CORS(
app,
resources={r"/*": {
"origins": origins
}},
supports_credentials=True,
)
from contextlib import contextmanager
@contextmanager
def session_scope():
"""Provide a transactional scope around a series of operations."""
db_session = db.session
try:
yield db_session
db_session.commit()
except:
def create_app(test_config=None):
# Create the app
app = Flask(__name__)
setup_db(app)
CORS(app, resources={r"/api/*": {"origins": "*"}})
# CORS Headers
@app.after_request
def after_request(response):
response.headers.add('Access-Control-Allow-Headers', 'Content-Type,Authorization,true')
response.headers.add('Access-Control-Allow-Methods', 'GET,PUT,POST,DELETE,OPTIONS')
return response
# Endpoint to return all categories
@app.route('/categories')
def retrieve_categories():
categories = Category.query.order_by(Category.id).all()
formatted_categories = {category.id: category.type for category in categories}
if len(categories) == 0:
abort(404)
return jsonify({
'success': True,
'categories': formatted_categories
})
# Endpoint to return all questions
@app.route('/questions')
def retrieve_questions():
selection = Question.query.order_by(Question.id).all()
current_questions = paginate_questions(request, selection)
total_questions = len(Question.query.all())
categories = Category.query.order_by(Category.id).all()
formatted_categories = {category.id: category.type for category in categories}
current_category = Category.query.order_by(Category.id).first()
if len(current_questions) == 0:
abort(404)
return jsonify({
'success': True,
'questions': current_questions,
'total_questions': total_questions,
'categories': formatted_categories,
'current_category': {current_category.id: current_category.type}
})
# Endpoint to delete a question from the database
@app.route('/questions/<int:question_id>', methods=['DELETE'])
def delete_questions(question_id):
try:
question = Question.query.filter(Question.id == question_id).one_or_none()
if question is None:
abort(404)
db.session.delete(question)
db.session.commit()
except:
db.session.rollback()
abort(422)
finally:
db.session.close()
return jsonify({
'success': True,
'deleted': question_id,
})
# Endpoint that will will create a new question in the database, or complete a search in the text
# of the questions based on a search term entered by the user.
@app.route('/questions', methods=['POST'])
def create_question():
body = request.get_json()
search_term = body.get('searchTerm')
if search_term:
search_matches = Question.query.order_by(Question.id).filter(Question.question.ilike('%{}%'.format(search_term)))
current_questions = paginate_questions(request, search_matches)
total_questions = len(search_matches.all())
current_category = Category.query.order_by(Category.id).first()
return jsonify({
'success': True,
'questions': current_questions,
'total_questions': total_questions,
'current_category': {current_category.id: current_category.type}
})
else:
try:
question = body.get('question', None)
answer = body.get('answer', None)
difficulty = body.get('difficulty', None)
category = body.get('category', None)
new_question = Question(question=question,answer=answer,category=category,difficulty=difficulty)
db.session.add(new_question)
db.session.commit()
except:
db.session.rollback()
abort(422)
finally:
new_question_id = new_question.id
db.session.close()
return jsonify({
'success': True,
'question_id': new_question_id
})
# Endpoint to return questions in a specified category
@app.route('/categories/<int:category_id>/questions')
def retrieve_questions_by_category(category_id):
selection = Question.query.order_by(Question.id).filter(Question.category == category_id)
total_questions = len(selection.all())
current_questions = paginate_questions(request, selection)
current_category = Category.query.get(category_id)
if total_questions == 0:
abort(404)
return jsonify({
'success': True,
'questions': current_questions,
'total_questions': total_questions,
'current_category': {current_category.id: current_category.type}
})
# Endpoint that will provide the next question to a quiz. The query will get a random question from the database
# (by category if specified), not including previous questions.
@app.route('/quizzes', methods=['POST'])
def create_quiz():
body = request.get_json()
previous_questions = body.get('previous_questions', None)
quiz_category = body.get('quiz_category', None)
if quiz_category['id'] == 0:
current_question = Question.query.filter(Question.id.notin_(previous_questions)).order_by(func.random()).first()
else:
current_question = Question.query.filter(Question.category == quiz_category['id']).filter(Question.id.notin_(previous_questions)).order_by(func.random()).first()
if current_question:
current_question = current_question.format()
return jsonify({
'success': True,
'question': current_question
})
@app.errorhandler(400)
def bad_request(error):
return jsonify({
"success": False,
"error": 400,
"message": "bad request"
}), 400
@app.errorhandler(404)
def not_found(error):
return jsonify({
"success": False,
"error": 404,
"message": "resource not found"
}), 404
@app.errorhandler(422)
def unprocessable(error):
return jsonify({
"success": False,
"error": 422,
"message": "unprocessable"
}), 422
return app
from flask import Flask, jsonify, request from flask_cors import CORS from flask_sqlalchemy import SQLAlchemy from model import * from user_mngmnt import * from pre_exam import * from atm import * from exam import * from evm import * from rvm import * CORS(application) api = Api(application) #=================================================# # USER MANAGEMENT MODULE # #=================================================# api.add_resource(UserLogin, '/api/v1/user_login') api.add_resource(UserLogout, "/api/v1/logout") api.add_resource(Forgotpassword, "/api/v1/forgotpassword") api.add_resource(Newpassword, "/api/v1/newpassword") api.add_resource(Changepassword, "/api/v1/changepassword") api.add_resource(AdditionalExaminerLogin, "/api/v1/additional_examiner_login") api.add_resource(CacheClear, "/api/v1/cache_clear") #=================================================# # PRE EXAMINATION MODULE # #=================================================# api.add_resource(ExamCenter_Add, '/api/v1/examcenter_add') api.add_resource(Designation_Add, "/api/v1/designation_add") api.add_resource(Role_Add, '/api/v1/role_add')
import sys
import os
from flask_cors import CORS, cross_origin
from connections import api
from model import User, Post, Search
from view import view
template_dir = os.path.abspath('templates')
print(template_dir)
static_dir = os.path.abspath('static')
print(static_dir)
app = Flask(__name__, template_folder=template_dir, static_folder=static_dir)
cors = CORS(app)
app.config["TEMPLATES_AUTO_RELOAD"] = True
app.config['CORS_HEADERS'] = 'Content-Type'
app.config.update(TESTING=True, SECRET_KEY='DevTest')
app.app_context().push()
users = User.users
Last_search = []
Search_Results = []
userPublicData = {'username': ""}
Search_word = 'aaaaaaaaa'
@app.route('/')
@cross_origin()
import os
import json
from flask import Flask, request
app = Flask(__name__)
from flask_cors import CORS, cross_origin
app.config['CORS_HEADERS'] = 'Content-Type'
CORS(app, resources={r"/": {"origins": os.getenv('FRONTEND_BASE_URL')}})
from datetime import datetime
import logging
if os.getenv('FLASK_DEBUG') == 'true':
logging.basicConfig(level=logging.DEBUG)
# import helper functions
from helpers import missed_job, error_in_job, send_email
# APScheduler imports and config
from apscheduler.schedulers.background import BackgroundScheduler
from apscheduler.jobstores.sqlalchemy import SQLAlchemyJobStore
# import event constants
from apscheduler.events import EVENT_JOB_MISSED, EVENT_JOB_ERROR
# configure postgres jobstore
POSTGRES_URI = os.getenv('POSTGRES_URI')
jobstore = {
'default': SQLAlchemyJobStore(url=POSTGRES_URI)
}
scheduler = BackgroundScheduler(
class Server:
ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg', 'gif'}
MATRIX_PATH = Path('gen_data/matrix.npy')
NEW_META_PATH = Path('gen_data/processed_reddit_data.pth')
IMAGE_FOLDER = Path('images')
PAINTING_FOLDER = 'painting'
matrix = np.load(MATRIX_PATH)
meta = torch.load(NEW_META_PATH)
sampler = TextSampler(matrix, meta)
printer = Printer()
with open(f'latent_space/{PAINTING_FOLDER}.p', 'rb') as fp:
paintings = pickle.load(fp)
app = Flask(__name__, static_folder='static')
CORS(app)
isearcher = ISearcher(IMAGE_FOLDER)
tsearcher = TextSearcher()
def __init__(self):
self.logger = logging.getLogger(self.__class__.__name__)
def run(self, host: str):
self.app.run(host=host)
@staticmethod
def allowed_file(filename):
return '.' in filename and \
filename.rsplit('.', 1)[1].lower() in Server.ALLOWED_EXTENSIONS
@orm.db_session
def download_images(self):
self.logger.info('Downloading images...')
if not self.IMAGE_FOLDER.exists():
self.IMAGE_FOLDER.mkdir()
for meme in Meme.select():
image = self.IMAGE_FOLDER / str(meme.id)
if not image.exists():
r = requests.get(meme.image, stream=True)
if r.status_code == 200:
with image.open('wb') as f:
for chunk in r:
f.write(chunk)
@staticmethod
@app.route('/memes')
@orm.db_session
def get_memes():
id_ = request.args.get('id')
if id_ is not None and Meme.exists(id=int(id_)):
return jsonify(Server._get_meme_long_desc(Meme.get(id=int(id_))))
memes = [Server._get_meme_short_desc(meme) for meme in Meme.select()]
memes.append(Server._get_quiz_desc(1))
memes.append(Server._get_generator_desc(1))
memes.append(Server._get_generator_desc(2))
return jsonify(memes)
@staticmethod
@app.route('/isearch', methods=['POST'])
@orm.db_session
def image_search():
file = request.files['file']
if file and Server.allowed_file(file.filename):
image = PILImage.open(io.BytesIO(file.read()))
result = Server.isearcher.search_img(image, top_k=3)
return jsonify({'results': result})
@staticmethod
@app.route('/search')
@orm.db_session
def text_search():
query = request.args.get('q')
result = list(map(str, Server.tsearcher.search(query)[:3]))
return jsonify({'results': result})
@staticmethod
@app.route('/generate', methods=['POST'])
def generate_meme():
id_ = int(request.values['id'])
file = request.files['file']
if file and Server.allowed_file(file.filename):
image = PILImage.open(io.BytesIO(file.read()))
if id_ == 1:
text = Server.sampler.sample(image)
meme = Server.printer.print(image, text)
else:
image = np.array(image.convert('RGB'))
embeddings = face_recognition.face_encodings(image)
if len(embeddings) > 0:
photo = embeddings[0]
key = min(Server.paintings.items(),
key=lambda x: np.sum(
np.sqrt((photo - np.array(x[1]))**2)))[0]
else:
key = random.choice(list(Server.paintings.keys()))
folder = '' if key[0] == '1' else ' 2'
file_to_load = f'dataset_updated/{folder}/training_set/{Server.PAINTING_FOLDER}/{key[1:]}.jpg'
meme = PILImage.open(file_to_load)
current_date = datetime.now().strftime('%Y.%m.%d.%H.%M.%S')
file_name = f'{current_date}.png'
meme.save(f'static/{file_name}')
return jsonify({'result': file_name})
@staticmethod
@app.route('/quiz')
@orm.db_session
def get_quiz():
id_ = int(request.args.get('id'))
return jsonify({
'id':
id_,
'questions': [{
'text': q.text,
'answer': q.answer,
'memes': [q.meme_1, q.meme_2, q.meme_3]
} for q in Question.select(lambda it: it.quiz == id_)]
})
@orm.db_session
def build_text_index(self):
data = [(it.id, it.about) for it in Meme.select()]
self.tsearcher.build_index(data)
@staticmethod
@orm.db_session
def _get_meme_long_desc(meme) -> dict:
return {
'id':
meme.id,
'url':
meme.image,
'name':
meme.name,
'about':
meme.about,
'origin':
meme.origin,
'tags':
meme.type.split(',') if meme.type else [],
'images':
list(
map(lambda it: it.url,
Image.select(lambda it: it.meme == meme.id)))
}
@staticmethod
@orm.db_session
def _get_meme_short_desc(meme) -> dict:
return {
'id': meme.id,
'quiz': None,
'generator': None,
'url': meme.image,
'about': meme.about
}
@staticmethod
@orm.db_session
def _get_quiz_desc(quiz_id: int) -> dict:
return {'quiz': quiz_id}
@staticmethod
@orm.db_session
def _get_generator_desc(generator_id: int) -> dict:
return {'generator': generator_id}
# -*- coding: utf-8 -*-# # ------------------------------------------------------------------------------- # Name: __init__.py.py # Description: # Author: [email protected] # Date: 2020/3/17 23:51 # ------------------------------------------------------------------------------- from flask import Blueprint from app import Mongodb from flask_cors import CORS # create BluePrint object api = Blueprint("api", __name__) CORS(api) from . import demo from . import microbe
from flask import Flask, request, jsonify, Response
from flask_cors import CORS, cross_origin
from generators import get_room_artifacts
app = Flask(__name__)
# cors = CORS(app)
cors = CORS(app, resources={r"/*": {"origins": "*"}})
#############################################################
# API
#############################################################
@app.route("/")
def api_root():
return "Malloci Artifact Generator"
#############################################################
# POST /generate
# Returns links of all images uploaded with this service
#############################################################
@app.route("/generate", methods=['POST'])
@cross_origin(origin="*", headers=['Content-Type','Authorization'])
def parse_doc():
content = request.json
for room in content['rooms']:
room['artifacts'] = get_room_artifacts(room['text'])
if 'subRooms' in room:
for subroom in room['subRooms']:
def create_app(test_config=None):
# create and configure the app
app = Flask(__name__)
setup_db(app)
CORS(app)
@app.errorhandler(400)
def handle_bad_request(e):
return jsonify({
"success": False,
"error": 400,
"message": "bad request"
}), 400
@app.errorhandler(404)
def not_found(error):
return jsonify({
"success": False,
"error": 404,
"message": "resource not found"
}), 404
@app.errorhandler(422)
def not_found(error):
return jsonify({
"success": False,
"error": 422,
"message": str(error)
}), 422
# CORS Headers
@app.after_request
def after_request(response):
response.headers.add('Access-Control-Allow-Headers',
'Content-Type,Authorization,true')
response.headers.add('Access-Control-Allow-Methods',
'GET,PUT,POST,DELETE,OPTIONS')
return response
@app.route('/books')
def retrieve_books():
selection = Book.query.order_by(Book.id).all()
current_books = paginate_books(request, selection)
if len(current_books) == 0:
abort(404)
return jsonify({
'success': True,
'books': current_books,
'total_books': len(Book.query.all())
})
@app.route('/books/<int:book_id>', methods=['PATCH'])
def update_book(book_id):
body = request.get_json()
try:
book = Book.query.filter(Book.id == book_id).one_or_none()
if book is None:
print('!!!!!!!!!HERE!!!!!!!!!')
abort(404)
if 'rating' in body:
book.rating = int(body.get('rating'))
book.update()
return jsonify({
'success': True,
})
except:
abort(400)
@app.route('/books/<int:book_id>', methods=['DELETE'])
def delete_book(book_id):
try:
book = Book.query.filter(Book.id == book_id).one_or_none()
if book is None:
abort(404)
book.delete()
selection = Book.query.order_by(Book.id).all()
current_books = paginate_books(request, selection)
return jsonify({
'success': True,
'deleted': book_id,
'books': current_books,
'total_books': len(Book.query.all())
})
except:
abort(422, description="Unprocessable")
@app.route('/books', methods=['POST'])
def create_book():
body = request.get_json()
new_title = body.get('title', None)
new_author = body.get('author', None)
new_rating = body.get('rating', None)
try:
book = Book(title=new_title, author=new_author, rating=new_rating)
book.insert()
selection = Book.query.order_by(Book.id).all()
current_books = paginate_books(request, selection)
return jsonify({
'success': True,
'created': book.id,
'books': current_books,
'total_books': len(Book.query.all())
})
except:
abort(422, description="Unprocessable")
# @TODO: Review the above code for route handlers.
# Pay special attention to the status codes used in the aborts since those are relevant for this task!
# @TODO: Write error handler decorators to handle AT LEAST status codes 400, 404, and 422.
# TEST: Practice writing curl requests. Write some requests that you know will error in expected ways.
# Make sure they are returning as expected. Do the same for other misformatted requests or requests missing data.
# If you find any error responses returning as HTML, write new error handlers for them.
# @app.errorhandler(404)
# def not_found(error):
# return jsonify({
# "success": False,
# "error": 404,
# "message": "Not found"
# }), 404
# @app.errorhandler(422)
# def resource_not_found(e):
# return jsonify(error=str(e)), 422
# @app.errorhandler(422)
# def not_found(error):
# return jsonify({
# "success": False,
# "error": 422,
# "message": error
# }), 422
return app
import datetime
from flask import Flask, request, redirect, jsonify
from flask_cors import CORS
from json import loads
import math
import random
import requests
import twilio.twiml
from twilio.twiml.messaging_response import MessagingResponse
from twilio.rest import Client
client = Client("AC4e7890114509da5929a4bc79ebf8bdc0",
"47ee8d75ad0e2973601122c2a65d7b7c")
app = Flask(__name__)
CORS(app)
database = {}
comments = {}
new_event_id = -1
subscribers = {"+16475153544"}
# This has a sample user.
# They want to be alerted via text, for all crimes that occur.
def distance(loc, event):
x_loc = loc[0]
y_loc = loc[1]
x_event = event[2]
y_event = event[3]
sq = lambda x: x * x
app = Flask(__name__)
app.secret_key = 'secret'
app.config['FLASK_ADMIN_SWATCH'] = 'cyborg'
app.config['JWT_SECRET_KEY'] = 'super-secret'
app.config['JWT_TOKEN_LOCATION'] = ['cookies']
app.config[
'JWT_COOKIE_SECURE'] = False # Set to True in production (for HTTPS)
app.config['JWT_COOKIE_CSRF_PROTECT'] = True
app.config['JWT_ACCESS_COOKIE_PATH'] = '/'
app.config['JWT_REFRESH_COOKIE_PATH'] = '/token/refresh'
app.config['JWT_ACCESS_TOKEN_EXPIRES'] = config.config()['accessExpiration']
app.config['JWT_REFRESH_TOKEN_EXPIRES'] = config.config()['refreshExpiration']
cors = CORS(app,
resources={r"/*": {
"origins": config.config()['clientOrigin']
}},
supports_credentials=True)
api = Api(app)
jwt = JWTManager(app)
admin = Admin(app, name='KLAP4', template_mode='bootstrap3')
#TODO: Make custom model views for each model (like genre)
admin.add_view(GenreModelView(Genre, session))
admin.add_view(ArtistModelView(Artist, session))
admin.add_view(AlbumModelView(Album, session))
admin.add_view(SongModelView(Song, session))
admin.add_view(AlbumReviewModelView(AlbumReview, session))
admin.add_view(AlbumProblemModelView(AlbumProblem, session))
admin.add_view(ProgramFormatModelView(ProgramFormat, session))
admin.add_view(ProgramModelView(Program, session))
