import requests
from flask import Flask
from flask import request
from flask import Response
import json
import re
from flask_sslify import SSLify
# importing request object from flask framework not same as request library
app = Flask(__name__)
sslify = SSLify(app) # comment this if testing locally
token = 'xxxxxxxxxxxxxxxxx' #take from env variables
APP_ID = 'xxxxxxxxxxxxxxxx' #take from env variables
def write_json(data, filename='response.json'):
with open(filename, 'w') as f:
json.dump(data, f, indent=4, ensure_ascii=False)
def get_weather_data(district):
url = 'http://api.openweathermap.org/data/2.5/weather?q={}&appid={}'.format(
district, APP_ID)
r = requests.get(url).json()
if str(r["cod"]) == "404":
return r["message"]
lat = "Latitude: " + str(r['coord']['lat'])
lon = "Longitude: " + str(r['coord']['lon'])
from app.routes import index
from base64 import b64decode
import redis
import manager
from app.config import REDIS_HOST, REDIS_PORT, REDIS_DB, SECRET_KEY, DEBUG
from flask import abort, jsonify
from flask.ext.restful import Api, Resource, reqparse, fields, marshal
from flask.ext.httpauth import HTTPBasicAuth
from flask_sslify import SSLify
from werkzeug.security import check_password_hash
from itsdangerous import TimedJSONWebSignatureSerializer as Serializer, BadSignature
# Restful api
api = Api(app)
# Redis
db = redis.StrictRedis(host=REDIS_HOST, port=REDIS_PORT, db=REDIS_DB)
# Authentication
auth = HTTPBasicAuth()
if not DEBUG:
# SSL
sslify = SSLify(app, subdomains=True)
if __name__ == '__main__':
# Populate database with test data
manager.populate_test2()
app.run(debug=True)
import os
from flask.ext.uuid import FlaskUUID
import config
import requests
from flask import Flask, render_template, redirect, request, url_for
from requests import ConnectionError
from wtforms import Form, BooleanField, TextField, PasswordField, validators
import logging
import json
from hello import ApiClient
from flask_sslify import SSLify
application = Flask(__name__)
FlaskUUID(application)
sslify = SSLify(application)
application.config.from_object(os.environ['APP_SETTINGS'])
logger = logging.getLogger(__name__)
apiClient = ApiClient(application.config['API_URL'],
application.config['OAUTH_TOKEN'])
@application.after_request
def sanitizing(response):
response.headers["X-Frame-Options"] = "SAMEORIGIN"
return response
from flask_bower import Bower
from flask_oauthlib.contrib.client import OAuth
import oauthlib
from .image_converter import download_and_convert_to_png64
from .pin_database import PinDatabase
TRAKTV_CLIENT_ID = os.environ["TRAKTV_CLIENT_ID"]
TRAKTV_CLIENT_SECRET = os.environ["TRAKTV_CLIENT_SECRET"]
PEBBLE_TIMELINE_API_KEY = os.environ["PEBBLE_TIMELINE_API_KEY"]
MONGODB_URL = os.environ["MONGODB_URL"]
app = Flask(__name__)
app.secret_key = os.environ["APP_SECRET"]
sslify = SSLify(app,
permanent=True,
skips=['api/getLaunchData/', 'convert2png64'])
Bower(app)
pin_db = PinDatabase(MONGODB_URL)
oauth = OAuth()
trakttv = oauth.remote_app(
'trakttv',
base_url='https://trakt.tv/',
access_token_url='https://trakt.tv/oauth/token',
authorization_url='https://trakt.tv/oauth/authorize',
client_id=TRAKTV_CLIENT_ID,
client_secret=TRAKTV_CLIENT_SECRET)
from flask_migrate import Migrate, MigrateCommand
from flask_login import LoginManager
from flask_cors import CORS
import os
def main():
port = int(os.environ.get("PORT", 5000))
app.run(host="0.0.0.0", port=port)
app = Flask(__name__,
instance_relative_config=True)
app.config.from_object("config")
db = SQLAlchemy(app)
migrate = Migrate(app, db)
cors = CORS(app, resource={r"/*": {"origins": "*"}})
manager = Manager(app)
manager.add_command("db", MigrateCommand)
lm = LoginManager()
lm.init_app(app)
from flask_sslify import SSLify
if 'DYNO' in os.environ:
sslfy = SSLify(app)
from app.models import tables, forms
from app.controllers import defalt
def create_app(config):
app = Flask(__name__)
config_name = config
if not isinstance(config, str):
config_name = os.getenv('FLASK_CONFIG', 'default')
app.config.from_object(Config[config_name])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# not using sqlalchemy event system, hence disabling it
Config[config_name].init_app(app)
# enable scheduler api
scheduler.api_enabled = True
db.app = app
# Set up extensions
mail.init_app(app)
db.init_app(app)
login_manager.init_app(app)
csrf.init_app(app)
compress.init_app(app)
scheduler.init_app(app)
scheduler.start()
RQ(app)
# Register Jinja template functions
from .utils import register_template_utils
register_template_utils(app)
# Set up asset pipeline
assets_env = Environment(app)
dirs = ['assets/styles', 'assets/scripts']
for path in dirs:
assets_env.append_path(os.path.join(basedir, path))
assets_env.url_expire = True
assets_env.register('app_css', app_css)
assets_env.register('app_js', app_js)
assets_env.register('vendor_css', vendor_css)
assets_env.register('vendor_js', vendor_js)
# Configure SSL if platform supports it
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask_sslify import SSLify
SSLify(app)
# Create app blueprints
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .account import account as account_blueprint
app.register_blueprint(account_blueprint, url_prefix='/account')
from .admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint, url_prefix='/admin')
@app.before_first_request
def load_tasks():
from app import tasks
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# not using sqlalchemy event system, hence disabling it
config[config_name].init_app(app)
# Set up extensions
mail.init_app(app)
db.init_app(app)
login_manager.init_app(app)
#csrf.init_app(app)
compress.init_app(app)
RQ(app)
jwt.init_app(app)
marshmallow.init_app(app)
api = Api(app)
# # Set up asset pipeline
# assets_env = Environment(app)
# dirs = ['assets/styles', 'assets/scripts']
# for path in dirs:
# assets_env.append_path(os.path.join(basedir, path))
# assets_env.url_expire = True
# assets_env.register('app_css', app_css)
# assets_env.register('app_js', app_js)
# assets_env.register('vendor_css', vendor_css)
# assets_env.register('vendor_js', vendor_js)
# Configure SSL if platform supports it
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask_sslify import SSLify
SSLify(app)
# Create app blueprints
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .account import account as account_blueprint
app.register_blueprint(account_blueprint, url_prefix='/account')
from .admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint, url_prefix='/admin')
from app.api.auth import AuthView
from app.api.v1.user import UserView
from app.api.v1.project import ProjectView, ProjectsView, TicketView, TicketsView, CommentView
api.add_resource(AuthView, '/api/auth')
api.add_resource(UserView, '/api/v1/users')
api.add_resource(ProjectsView, '/api/v1/projects')
api.add_resource(ProjectView, '/api/v1/project/<int:id>')
api.add_resource(TicketView, '/api/v1/project/<int:id>/tickets')
api.add_resource(TicketView,
'/api/v1/project/<int:id>/tickets/<int:tid>',
endpoint="ticket")
api.add_resource(TicketsView, '/api/v1/tickets')
api.add_resource(CommentView,
'/api/v1/project/<int:id>/tickets/<int:tid>/comment')
return app
def create_app(script_info):
# if evoked from "flask shell", get the env ourselves,
# since manage.py does this for us otherwise.
if type(script_info) is str:
config_name = script_info
else:
config_name = os.getenv('APP_CONFIG')
os.environ['FLASK_ENV'] = config_name
app = Flask(__name__)
app.config.from_object(config[config_name])
if not app.testing and not app.debug and not app.config['SSL_DISABLE']:
sslify = SSLify(app, permanent=True)
app.config['SESSION_COOKIE_SECURE'] = True
# Session TTL
app.config['SESSION_REFRESH_EACH_REQUEST'] = True
app.config['PERMANENT_SESSION_LIFETIME'] = timedelta(
minutes=int(app.config['SESSION_TTL']))
config[config_name].init_app(app)
db.init_app(app)
babel.init_app(app)
# logging config
app.logger.setLevel(os.getenv('LOG_LEVEL', default='WARN'))
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
default_handler.setFormatter(formatter)
@babel.localeselector
def get_locale():
from app.main.helpers import guess_locale
if g.locale:
return g.locale
return guess_locale()
@app.url_defaults
def set_language_code(endpoint, values):
if 'lang_code' in values or not g.get('lang_code', None):
return
if app.url_map.is_endpoint_expecting(endpoint, 'lang_code'):
values['lang_code'] = g.lang_code
@app.url_value_preprocessor
def get_lang_code(endpoint, values):
if values is not None:
g.lang_code = values.pop('lang_code', None)
@app.before_request
def ensure_lang_support():
lang_code = g.get('lang_code', None)
if lang_code and lang_code not in LANGUAGES.keys():
app.logger.info(
'ensure_lang_support failed to find %s in LANGUAGES' %
(lang_code))
return abort(404)
@app.context_processor
def inject_dict_for_all_templates():
return dict(registrant=g.get('registrant'),
browser_ua=request.user_agent.browser,
url_for=dated_url_for)
def dated_url_for(endpoint, **values):
if endpoint == 'static':
filename = values.get('filename', None)
if filename:
file_path = os.path.join(app.root_path, endpoint, filename)
values['_'] = int(os.stat(file_path).st_mtime)
return url_for(endpoint, **values)
@app.template_test('a_text_field')
def a_text_field(obj):
from wtforms import StringField, DateField
return isinstance(obj, StringField) or isinstance(obj, DateField)
from app.main import main as main_blueprint
app.register_blueprint(main_blueprint)
app.register_blueprint(main_blueprint, url_prefix='/<lang_code>')
return app
def create_app(_read_config=True, **config):
app = flask.Flask(__name__,
static_folder=None,
template_folder=os.path.join(PROJECT_ROOT, 'templates'))
# Utilized for sessions and other secrets
# NOTE: This key is insecure and you should override it on the server
app.config[
'SECRET_KEY'] = 't\xad\xe7\xff%\xd2.\xfe\x03\x02=\xec\xaf\\2+\xb8=\xf7\x8a\x9aLD\xb1'
if 'SECRET_KEY' in os.environ:
app.config['SECRET_KEY'] = os.environ['SECRET_KEY']
# The api key to authorize end users against this system.
# NOTE: This key is insecure and you should override it on the server
app.config[
'API_KEY'] = '3e84744ab2714151b1db789df82b41c0021958fe4d77406e9c0947c34f5c5a70'
if 'API_KEY' in os.environ:
app.config['API_KEY'] = os.environ['API_KEY']
# The private key to use when cloning repositories
# TODO(dcramer): this should support an on-disk option, as well as be
# possible to override per repo
app.config['SSH_PRIVATE_KEY'] = os.environ.get('SSH_PRIVATE_KEY',
'').replace("\\n", "\n")
app.config['FREIGHT_URL'] = os.environ.get('FREIGHT_URL', '').rstrip('/')
if 'REDISCLOUD_URL' in os.environ:
app.config['REDIS_URL'] = os.environ['REDISCLOUD_URL']
elif 'REDIS_URL' in os.environ:
app.config['REDIS_URL'] = os.environ['REDIS_URL']
app.config['WORKSPACE_ROOT'] = os.environ.get('WORKSPACE_ROOT', '/tmp')
app.config['DEFAULT_TIMEOUT'] = int(os.environ.get('DEFAULT_TIMEOUT',
3600))
app.config['DEFAULT_READ_TIMEOUT'] = int(
os.environ.get('DEFAULT_READ_TIMEOUT', 600))
app.config['LOG_LEVEL'] = os.environ.get(
'LOG_LEVEL', 'INFO' if config.get('DEBUG') else 'ERROR')
app.config['DEV'] = config.get('DEV', False)
# Currently authentication requires Google
app.config['GOOGLE_CLIENT_ID'] = os.environ.get('GOOGLE_CLIENT_ID')
app.config['GOOGLE_CLIENT_SECRET'] = os.environ.get('GOOGLE_CLIENT_SECRET')
app.config['GOOGLE_DOMAIN'] = os.environ.get('GOOGLE_DOMAIN')
# Generate a GitHub token via Curl:
# curlish https://api.github.com/authorizations \
# -u your-username \
# -X POST \
# -J scopes='repo' \
# -J note='freight'
app.config['GITHUB_TOKEN'] = os.environ.get('GITHUB_TOKEN')
app.config['GITHUB_API_ROOT'] = 'https://api.github.com'
app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True
app.config['SQLALCHEMY_POOL_SIZE'] = 5
app.config['SQLALCHEMY_MAX_OVERFLOW'] = 0
if 'SQLALCHEMY_DATABASE_URI' in os.environ:
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ[
'SQLALCHEMY_DATABASE_URI']
app.config['QUEUES'] = [
'freight.default',
'freight.tasks',
'freight.queue',
'freight.notifications',
]
app.config['QUEUE_DEFAULT'] = 'freight.default'
app.config['QUEUE_ROUTES'] = {
'freight.jobs.execute_task': 'freight.tasks',
'freight.jobs.check_queue': 'freight.queue',
'freight.jobs.send_pending_notifications': 'freight.notifications',
}
app.config['QUEUE_SCHEDULE'] = {
'freight.jobs.check_queue': {
'seconds': 1,
},
'freight.jobs.send_pending_notifications': {
'seconds': 1,
},
}
app.config['SENTRY_INCLUDE_PATHS'] = [
'freight',
]
# We don't support non-proxied installs
app.wsgi_app = ProxyFix(app.wsgi_app)
# Pull in Heroku configuration
heroku.init_app(app)
# Pull in environment variables from docker
docker_init_app(app)
if 'DYNO' in os.environ:
# XXX: the released version of flask-sslify does not support init_app
SSLify(app)
# Set any remaining defaults that might not be present yet
if not app.config.get('SQLALCHEMY_DATABASE_URI'):
app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql:///freight'
app.config.setdefault('REDIS_URL', 'redis://localhost:6379')
app.config.setdefault('REDIS_DB', 0)
app.config.update(config)
if _read_config:
if os.environ.get('FREIGHT_CONF'):
# FREIGHT_CONF=/etc/freight.conf.py
app.config.from_envvar('FREIGHT_CONF')
else:
# Look for ~/.freight/freight.conf.py
path = os.path.normpath(
os.path.expanduser('~/.freight/freight.conf.py'))
app.config.from_pyfile(path, silent=True)
configure_logging(app)
configure_sentry(app)
configure_api(app)
configure_redis(app)
configure_queue(app)
configure_sqlalchemy(app)
configure_web_routes(app)
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# not using sqlalchemy event system, hence disabling it
#'C:/Users/oem/Desktop/marketplace/marketplace/app/static/frontend/images/'
#'C:/Users/oem/Desktop/marketplace/marketplace/appstatic/docs/'
app.config['UPLOADED_IMAGES_DEST'] = basedir + 'static/frontend/images' if \
not os.environ.get('UPLOADED_IMAGES_DEST') else os.path.dirname(os.path.realpath(__file__)) + os.environ.get(
'UPLOADED_IMAGES_DEST')
app.config['UPLOADED_DOCS_DEST'] = basedir + 'static/docs' if \
not os.environ.get('UPLOADED_DOCS_DEST') else os.path.dirname(os.path.realpath(__file__)) + os.environ.get(
'UPLOADED_DOCS_DEST')
app.config['docs'] = app.config['UPLOADED_DOCS_DEST']
app.config['CKEDITOR_SERVE_LOCAL'] = True
app.config['CKEDITOR_HEIGHT'] = 400
app.config['CKEDITOR_FILE_UPLOADER'] = 'upload'
app.config['CKEDITOR_ENABLE_CSRF'] = True # if you want to enable CSRF protect, uncomment this line
app.config['UPLOADED_PATH'] = os.path.join(basedir, 'uploads')
#app.config['WHOOSH_BASE']='whoosh'
config[config_name].init_app(app)
# Set up extensions
mail.init_app(app)
db.init_app(app)
login_manager.init_app(app)
csrf.init_app(app)
compress.init_app(app)
RQ(app)
configure_uploads(app, (images))
configure_uploads(app, docs)
ckeditor = CKEditor(app)
share.init_app(app)
moment.init_app(app)
jwt.init_app(app)
sess.init_app(app)
whooshee.init_app(app)
# whooshee = Whooshee(app)
# Register Jinja template functions
from .utils import register_template_utils
register_template_utils(app)
# Set up asset pipeline
assets_env = Environment(app)
dirs = ['assets/styles', 'assets/scripts']
for path in dirs:
assets_env.append_path(os.path.join(basedir, path))
assets_env.url_expire = True
assets_env.register('app_css', app_css)
assets_env.register('app_js', app_js)
assets_env.register('vendor_css', vendor_css)
assets_env.register('vendor_js', vendor_js)
# Configure SSL if platform supports it
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask_sslify import SSLify
SSLify(app)
# Create app blueprints
from .blueprints.public import public as public_blueprint
app.register_blueprint(public_blueprint)
from .blueprints.seo_world import seo_world as seo_world_blueprint
app.register_blueprint(seo_world_blueprint)
from .blueprints.main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .blueprints.account import account as account_blueprint
app.register_blueprint(account_blueprint)
from .blueprints.admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint, url_prefix='/admin')
from .blueprints.marketplace import marketplace as marketplace_blueprint
app.register_blueprint(marketplace_blueprint)
from .blueprints.organisations import organisations as organisations_blueprint
app.register_blueprint(organisations_blueprint, url_prefix='/organisations')
from .blueprints.sitemaps import sitemaps as sitemaps_blueprint
app.register_blueprint(sitemaps_blueprint)
from .blueprints.api import api as apis_blueprint
app.register_blueprint(apis_blueprint, url_prefix='/api')
# main_api.init_app(app)
app.jinja_env.globals.update(json_load=json_load, image_size=image_size, get_cart=get_cart)
app.jinja_env.add_extension('jinja2.ext.do')
@app.before_request
def before_request():
try:
session['cart_id']
except:
u = uuid.uuid4()
user_agent = request.headers.get('User-Agent')
if user_agent is not None:
user_agent = user_agent.encode('utf-8')
base = 'cart: {0}|{1}|{2}'.format(_get_remote_addr(), user_agent, u)
if str is bytes:
base = text_type(base, 'utf-8', errors='replace') # pragma: no cover
h = sha512()
h.update(base.encode('utf8'))
session['cart_id'] = h.hexdigest()
@app.cli.command()
def reindex():
with app.app_context():
whooshee.reindex()
@app.cli.command()
def routes():
"""'Display registered routes"""
rules = []
for rule in app.url_map.iter_rules():
methods = ','.join(sorted(rule.methods))
rules.append((rule.endpoint, methods, str(rule)))
sort_by_rule = operator.itemgetter(2)
for endpoint, methods, rule in sorted(rules, key=sort_by_rule):
route = '{:50s} {:25s} {}'.format(endpoint, methods, rule)
print(route)
@app.template_filter('product')
def product(o):
"""check if object is user"""
from app.models import MProduct
return o.__class__ == MProduct
whooshee.init_app(app)
return app
def __init__(self):
Blueprint.__init__(self, 'provisional', __name__)
self.provisional = None
SSLify(self)
from moztelemetry.histogram import Histogram
from joblib import Parallel, delayed
from functools import wraps
from gevent.monkey import patch_all
from psycogreen.gevent import patch_psycopg
from psycopg2.pool import SimpleConnectionPool
from aggregator import simple_measures_labels, count_histogram_labels
from db import get_db_connection_string, histogram_revision_map
pool = None
app = Flask(__name__)
app.config.from_object('config')
CORS(app, resources=r'/*', allow_headers='Content-Type')
cache = Cache(app, config={'CACHE_TYPE': app.config["CACHETYPE"]})
sslify = SSLify(app, skips=['status'])
patch_all()
patch_psycopg()
cache.clear()
def cache_request(f):
@wraps(f)
def decorated_request(*args, **kwargs):
rv = cache.get(request.url)
if rv is None:
rv = f(*args, **kwargs)
cache.set(request.url, rv, timeout=app.config["TIMEOUT"])
return rv
else:
# ASIC bot
import config
import btc
import requests
import json
import telebot
from flask import Flask, request, jsonify
from flask_sslify import SSLify
#from telebot import apihelper
#apihelper.proxy = {'http':'http://10.10.1.10:3128'}
server = Flask(__name__)
ssl = SSLify(server)
URL = 'https://api.telegram.org/bot%s/' % config.token
bot = telebot.TeleBot(config.token)
def write_json(data, filename='answer.json'):
with open(filename, 'w') as f:
json.dump(data, f, indent=2, ensure_ascii=False)
#1 pulling
def get_updates():
r = requests.get(URL + 'getUpdates')
write_json(r.json())
return r.json()
from flask_login import current_user, login_user, logout_user, login_required
import flask_assets
from flask_analytics import Analytics
from flask_sslify import SSLify
from signal import signal, SIGPIPE, SIG_DFL
app = Flask(__name__)
app.config.from_object(os.environ['APP_SETTINGS'])
app.logger.addHandler(logging.StreamHandler(sys.stdout))
app.logger.setLevel(logging.DEBUG)
STREAMS_OUT = ["polyline", "time"]
STREAMS_TO_CACHE = ["polyline", "time"]
sslify = SSLify(app, skips=["webhook_callback"])
# models depend app so we import them afterwards
from models import (Users, Activities, EventLogger, Utility, Webhooks, Indexes,
db_sql, mongodb, redis)
# just do once
# if not redis.get("db-reset"):
# # Activities.init(clear_cache=True)
# Indexes.init(clear_cache=True)
# redis.set("db-reset", 1)
# redis.delete("db-reset")
Analytics(app)
def create_app(ENV_SETTING):
app = Flask(__name__, instance_relative_config=True)
#configuration
app.config.from_object(app_config[ENV_SETTING])
# Logging configuration
logging.config.dictConfig(yaml.load(open(app.config['LOGGING_FILEPATH'])))
# Yaml Loader to load css and js
assets = Environment(app)
loader = YAMLLoader(app.config['ASSETS_FILEPATH']).load_bundles()
load_assets(assets, loader)
#database init
db.init_app(app)
# with app.app_context():
# create_user(app,db)
#flask_admin
admin = Admin(app, index_view=AdminIndexCustomView(url=None,endpoint=None) , name='Admin Panel', base_template='admin/my_master.html', template_mode='bootstrap3')
# Mail
mail.init_app(app)
# csrf
csrf.init_app(app)
#SSL
sslify = SSLify(app)
#setting babelex
babel = Babel(app)
@babel.localeselector
def get_locale():
# if the user has set up the language manually it will be stored in the session,
# so we use the locale from the user settings
try:
language = session['language']
except KeyError:
language = None
if language is not None:
return language
return request.accept_languages.best_match(app.config['LANGUAGES'].keys())
# Inject to JINJA Template
app.context_processor(inject_current_language)
app.context_processor(inject_all_languages)
app.context_processor(inject_google_token)
app.context_processor(inject_total_notification)
app.context_processor(inject_tasks)
# Template Filter
app.jinja_env.globals['momentjs'] = momentjs
# Setup Flask-Security
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security = Security(app, user_datastore)
# Integrate Flask Security with Flask Admin
@security.context_processor
def security_context_processor():
return dict(
admin_base_template=admin.base_template,
admin_view=admin.index_view,
h=admin_helpers,
get_url=url_for
)
# Admin Views
load_admin_views(admin, db)
# Blueprint Views
load_blueprints(app)
# Register Error Handling
app.register_error_handler(400, bad_request)
app.register_error_handler(404, page_not_found)
app.register_error_handler(403, page_forbidden)
app.register_error_handler(500, page_server_error)
app.logger.info('app started')
return app
from werkzeug.wsgi import DispatcherMiddleware
from app import app as app_homepage
import fantasydrafts
import fantasypl
from flask import render_template
from flask_sslify import SSLify
sslify_fantasydrafts = SSLify(fantasydrafts.app)
sslify_fantasypl = SSLify(fantasypl.app)
sslify_homepage = SSLify(app_homepage)
app = DispatcherMiddleware(app_homepage, {'/drafts': fantasydrafts.app,
'/fantasypl': fantasypl.app})
@app_homepage.route('/')
def index():
return render_template('index.html',
url_draft = '/drafts/necessary-roughness-2014/',
url_fantasypl = '/fantasypl/')
if __name__ == '__main__':
app.run()
logger = get_logger("bot", True)
logger.info("Starting bot...")
try:
logger.info("Getting data and config vars...")
data = DataLoader()
logger.info("Creating TeleBot...")
bot = telebot.TeleBot(token=data.TOKEN)
logger.info("Creating Flask server...")
server = Flask(__name__)
if 'DYNO' in os.environ: # only trigger SSLify if the app is running on Heroku
sslify = SSLify(server)
except Exception as e:
logger.info("Error creating Bot. Shutting down...")
logger.error(e, exc_info=True)
exit()
def log_message(message):
logger.info("Received: \"" + message.text + "\" from " +
message.from_user.first_name + " (ID: " +
str(message.from_user.id) + ") " + "[Chat ID: " +
str(message.chat.id) + "].")
def log_api_error(response):
def create_app(config_name):
"""Initializes a modular flask application:
- Initializes all the Flask extensions
- Configures Celery Task queue
- Hooks up all the blueprints
"""
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
bootstrap.init_app(app)
moment.init_app(app)
db.init_app(app)
login_manager.init_app(app)
pagedown.init_app(app)
celery.conf.update(app.config)
env_file_path = os.path.join(app.root_path, '../', '.env')
if os.path.exists(env_file_path):
env = DotEnv()
env.init_app(app)
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask_sslify import SSLify
sslify = SSLify(app)
from .controllers.main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .controllers.auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/auth')
from .api import api as api_blueprint
app.register_blueprint(api_blueprint, url_prefix='/api')
from .controllers.onboarding import onboarding as onboarding_blueprint
app.register_blueprint(onboarding_blueprint, url_prefix='/onboarding')
from .controllers.repos import repo as repo_blueprint
app.register_blueprint(repo_blueprint, url_prefix='/repos')
from .controllers.issues import issue as issue_blueprint
app.register_blueprint(issue_blueprint, url_prefix='/repos/issues')
from .controllers.boards import board as board_blueprint
app.register_blueprint(board_blueprint, url_prefix='/boards')
from .controllers.pull_requests import pull_request as pr_blueprint
app.register_blueprint(pr_blueprint, url_prefix='/repos/pull_requests')
from .controllers.github_members import github_member as \
github_member_blueprint
app.register_blueprint(github_member_blueprint,
url_prefix='/github_members')
from .controllers.trello_members import trello_member as \
trello_member_blueprint
app.register_blueprint(trello_member_blueprint,
url_prefix='/trello_members')
from .controllers.trello_lists import trello_list as trello_list_blueprint
app.register_blueprint(trello_list_blueprint, url_prefix='/boards/lists')
from .controllers.subscribed_lists import subscribed_list as \
subscribed_list_blueprint
app.register_blueprint(subscribed_list_blueprint,
url_prefix='/subscriptions/lists')
from .controllers.subscriptions import subscription as subscription_blueprint
app.register_blueprint(subscription_blueprint, url_prefix='/subscriptions')
from .controllers.jira_subscriptions import jira_subscription as jira_subscription_blueprint
app.register_blueprint(jira_subscription_blueprint,
url_prefix='/jira/subscriptions')
from .controllers.subscribed_jira_items import subscribed_item as subscribed_item_blueprint
app.register_blueprint(subscribed_item_blueprint,
url_prefix='/jira/subscriptions/items')
from .controllers.jira_members import jira_member as jira_member_blueprint
app.register_blueprint(jira_member_blueprint, url_prefix='/jira/members')
from .controllers.projects import project as project_blueprint
app.register_blueprint(project_blueprint, url_prefix='/jira/projects')
from .controllers.jira_issues import jira_issue as jira_issue_blueprint
app.register_blueprint(jira_issue_blueprint, url_prefix='/jira/issues')
from .controllers.jira_issue_types import jira_issue_type as jira_issue_type_blueprint
app.register_blueprint(jira_issue_type_blueprint,
url_prefix='/jira/issue_types')
return app
def initialize(self, server):
""" Initialize the Server with the extension """
server.sslify = SSLify(server.app)
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
csrf.init_app(app)
bootstrap.init_app(app)
mail.init_app(app)
db.init_app(app)
migrate.init_app(app, db)
login_manager.init_app(app)
rq.init_app(app)
if app.config.get('SSLIFY_ENABLE'):
app.logger.info("Using SSLify")
from flask_sslify import SSLify
sslify = SSLify(app)
sentry = None
if app.config.get('SENTRY_ENABLE'):
app.logger.info("Using Sentry")
sentry = Sentry(app)
@app.errorhandler(500)
def internal_server_error(error):
return render_template('500.html',
event_id=g.sentry_event_id,
public_dsn=sentry.client.get_public_dsn('https')
if sentry else None)
@app.errorhandler(400)
def error_400(error):
return render_template('400.html')
@app.errorhandler(403)
def error_403(error):
return render_template('403.html')
@app.errorhandler(404)
def error_404(error):
return render_template('404.html')
@app.errorhandler(405)
def error_405(error):
return render_template('405.html')
@app.after_request
def frame_buster(response):
response.headers['X-Frame-Options'] = 'DENY'
return response
@app.after_request
def server_header(response):
response.headers['Server'] = 'Server'
return response
@app.template_filter('humanize')
def humanize(dt):
return dt.strftime(app.config.get('DATE_FORMAT'))
from .carpool import pool_bp
app.register_blueprint(pool_bp)
from .auth import auth_bp
app.register_blueprint(auth_bp)
from .admin import admin_bp
app.register_blueprint(admin_bp)
@app.before_request
def block_handling():
""" Log out a user that's blocked and send them to the index page. """
if not current_user.is_anonymous and current_user.has_roles('blocked'):
flash("There was a problem with your login.", 'error')
current_app.logger.warn("Logged out blocked user %s",
current_user.id)
logout_user()
return redirect(url_for('auth.login'))
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# not using sqlalchemy event system, hence disabling it
config[config_name].init_app(app)
# Set up extensions
mail.init_app(app)
db.init_app(app)
login_manager.init_app(app)
csrf.init_app(app)
compress.init_app(app)
RQ(app)
with app.app_context():
from .models import User, Role, Campus, Location, Department, Equipment_Type, Condition, Equipment, Equipment_Reservation, Space_Type, Space, Ammenity_Type, Space_Ammenity, Space_Reservation
flask_manager = APIManager(app, flask_sqlalchemy_db=db)
flask_manager.create_api(User, methods=[], results_per_page=0)
flask_manager.create_api(Ammenity_Type, methods=['GET'], results_per_page=0)
flask_manager.create_api(Campus, methods=['GET'], results_per_page=0)
location_blueprint = flask_manager.create_api_blueprint(Location, methods=['GET', 'POST'], results_per_page=0)
csrf.exempt(location_blueprint)
app.register_blueprint(location_blueprint)
flask_manager.create_api(Department, methods=['GET'], results_per_page=0)
equipment_blueprint = flask_manager.create_api_blueprint(Equipment, methods=['GET', 'POST'], results_per_page=0)
csrf.exempt(equipment_blueprint)
app.register_blueprint(equipment_blueprint)
flask_manager.create_api(Equipment_Reservation, methods=['GET'], results_per_page=0)
flask_manager.create_api(Equipment_Type, methods=['GET'], results_per_page=0)
flask_manager.create_api(Role, methods=['GET'], results_per_page=0)
flask_manager.create_api(Space_Ammenity, methods=['GET'], results_per_page=0)
flask_manager.create_api(Space_Reservation, methods=['GET'], results_per_page=0)
flask_manager.create_api(Space_Type, methods=['GET'], results_per_page=0)
space_blueprint = flask_manager.create_api_blueprint(Space, methods=['GET', 'POST'], results_per_page=0)
csrf.exempt(space_blueprint)
app.register_blueprint(space_blueprint)
# Register Jinja template functions
from .utils import register_template_utils
register_template_utils(app)
# Set up asset pipeline
assets_env = Environment(app)
dirs = ['assets/styles', 'assets/scripts']
for path in dirs:
assets_env.append_path(os.path.join(basedir, path))
assets_env.url_expire = True
assets_env.register('app_css', app_css)
assets_env.register('app_js', app_js)
assets_env.register('vendor_css', vendor_css)
assets_env.register('vendor_js', vendor_js)
# Configure SSL if platform supports it
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask_sslify import SSLify
SSLify(app)
# Create app blueprints
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .account import account as account_blueprint
app.register_blueprint(account_blueprint, url_prefix='/account')
from .admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint, url_prefix='/admin')
from .reserve import reserve as reserve_blueprint
app.register_blueprint(reserve_blueprint, url_prefix='/reserve')
from .api import api as api_blueprint
print("api should be exempt")
app.register_blueprint(api_blueprint, url_prefix='/api')
csrf.exempt(api_blueprint)
return app
# -*- coding: utf-8 -*-
from flask import Flask, g, send_from_directory, request
from flask_sslify import SSLify
from safeChat import SafeChat
from json import dumps
# VARIABILI GLOBALI
app = Flask(__name__)
ssLify = SSLify(app)
safeChat = SafeChat(g, 'database.db', 'piper_nigrum')
# OPERAZIONI DI SESSIONE
@app.before_request
def apri_connessione():
safeChat.safeBase.apri_connessione()
@app.teardown_request
def chiudi_connessione(exception):
safeChat.safeBase.chiudi_connessione()
# INVIO FILES
@app.route('/')
@app.route('/accedi')
import logging
import sys
import flask
from flask import render_template, request, abort
from flask.ext import assets
from flask.ext.cors import CORS
from flask.ext.sqlalchemy import SQLAlchemy
from flask_httpauth import HTTPBasicAuth
from werkzeug.security import generate_password_hash, check_password_hash
from flask_sslify import SSLify
from dashboardsly import app
SSLify(app, permanent=True)
db = SQLAlchemy(app)
app.logger.addHandler(logging.StreamHandler(sys.stdout))
app.logger.setLevel(logging.ERROR)
env = assets.Environment(app)
env.load_path = [os.path.join(os.path.dirname(__file__), 'sass')]
env.register(
'css_all',
assets.Bundle('skeleton.scss', filters='scss', output='css_all.css'))
CORS(app)
auth = HTTPBasicAuth()
from flask import Flask, jsonify, request, session
import MySQLdb as mysql
import MySQLdb.cursors
from flask.json import JSONEncoder
from datetime import date
from flask_sslify import SSLify
import config
app = Flask(__name__)
sslify = SSLify(app) # always HTTPS
app.secret_key = config.SECRET_KEY # for sessions
app.config['SESSION_COOKIE_HTTPONLY'] = False
con = mysql.connect(config.DB_SERVER, config.DB_USER, config.DB_PASS, config.DB_NAME,
cursorclass=MySQLdb.cursors.DictCursor)
con.autocommit(True)
con.ping(True)
db = con.cursor()
# format dates
class CustomJSONEncoder(JSONEncoder):
def default(self, obj):
try:
if isinstance(obj, date):
return obj.isoformat()
iterable = iter(obj)
except TypeError:
pass
else:
from src.helpers.env import is_prod
# Create and configure the Flask app
app = Flask(__name__)
app.config.from_object(get_config())
# Set up logging
if is_prod():
app.logger.addHandler(StreamHandler(sys.stdout))
else:
app.logger.addHandler(FileHandler('main.log'))
app.logger.setLevel(INFO)
logger = app.logger
# Create and start our delayed job scheduler
from src.scheduler import delayed
delayed.start()
# Set up Postgres DB
db = SQLAlchemy(app)
# Set up API routes
from src.routes import api
api.init_app(app)
# Require https if on prod
if is_prod() and os.environ.get('REQUIRE_SSL') == 'true':
from flask_sslify import SSLify
SSLify(app)
def create_app(config):
app = Flask(__name__)
config_name = config
if not isinstance(config, str):
config_name = os.getenv('FLASK_CONFIG', 'default')
app.config.from_object(Config[config_name])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['MAX_CONTENT_LENGTH'] = 10 * 1024 * 1024
app.config['UPLOAD_FOLDER'] = 'uploads/'
# not using sqlalchemy event system, hence disabling it
Config[config_name].init_app(app)
# Set up extensions
mail.init_app(app)
db.init_app(app)
login_manager.init_app(app)
csrf.init_app(app)
compress.init_app(app)
babel.init_app(app)
RQ(app)
# Register Jinja template functions
from .utils import register_template_utils
register_template_utils(app)
# Set up asset pipeline
assets_env = Environment(app)
dirs = ['assets/styles', 'assets/scripts']
for path in dirs:
assets_env.append_path(os.path.join(basedir, path))
assets_env.url_expire = True
assets_env.register('app_css', app_css)
assets_env.register('default_theme_css', default_theme_css)
assets_env.register('dark_theme_css', dark_theme_css)
assets_env.register('red_theme_css', red_theme_css)
assets_env.register('app_js', app_js)
assets_env.register('vendor_css', vendor_css)
assets_env.register('vendor_js', vendor_js)
# Configure SSL if platform supports it
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask_sslify import SSLify
SSLify(app)
# Create app blueprints
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .main.catalogue import main_constellation as main_constellation
app.register_blueprint(main_constellation)
from .main.catalogue import main_deepskyobject as main_deepskyobject
app.register_blueprint(main_deepskyobject)
from .main.catalogue import main_dso_list as main_dso_list
app.register_blueprint(main_dso_list)
from .main.catalogue import main_star_list as main_star_list
app.register_blueprint(main_star_list)
from .main.catalogue import main_double_star as main_double_star
app.register_blueprint(main_double_star)
from .main.location import main_location as main_location
app.register_blueprint(main_location)
from .main.observation import main_observation as main_observation
app.register_blueprint(main_observation)
from .main.observation import main_standalone_observation as main_standalone_observation
app.register_blueprint(main_standalone_observation)
from .main.observation import main_observing_session as main_observing_session
app.register_blueprint(main_observing_session)
from .main.observation import main_observed as main_observed
app.register_blueprint(main_observed)
from .main.skyquality import main_sqm as main_sqm
app.register_blueprint(main_sqm)
from .main.skyquality import main_skyquality as main_skyquality
app.register_blueprint(main_skyquality)
from .main.userdata import main_userdata as main_userdata
app.register_blueprint(main_userdata)
from .main.catalogue import main_star as main_star
app.register_blueprint(main_star)
from .main.usersettings import main_usersettings as main_usersettings
app.register_blueprint(main_usersettings)
from .main.planner import main_planner as main_planner
app.register_blueprint(main_planner)
from .main.planner import main_sessionplan as main_sessionplan
app.register_blueprint(main_sessionplan)
from .main.planner import main_wishlist as main_wishlist
app.register_blueprint(main_wishlist)
from .main.solarsystem import main_solarsystem as main_solarsystem
app.register_blueprint(main_solarsystem)
from .main.solarsystem import main_comet as main_comet
app.register_blueprint(main_comet)
from .main.solarsystem import main_minor_planet as main_minor_panet
app.register_blueprint(main_minor_panet)
from .main.solarsystem import main_planet as main_planet
app.register_blueprint(main_planet)
from .main.chart import main_chart as main_chart
app.register_blueprint(main_chart)
from .main.news import main_news as main_news
app.register_blueprint(main_news)
from .main.equipment import main_equipment as main_equipment
app.register_blueprint(main_equipment)
from .main.import_history import main_import_history as main_import_history
app.register_blueprint(main_import_history)
from .account import account as account_blueprint
app.register_blueprint(account_blueprint, url_prefix='/account')
from .admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint, url_prefix='/admin')
from flask_commonmark import Commonmark
cm = Commonmark(app)
return app
from flask import Flask, request, render_template, redirect
from flask_sslify import SSLify
from tinydb import TinyDB, Query
from tinydb.storages import MemoryStorage
from uuid import uuid4
from werkzeug.contrib.fixers import ProxyFix
from os import getenv
db = TinyDB(storage=MemoryStorage)
app = Flask(__name__)
app.wsgi_app = ProxyFix(app.wsgi_app)
sslify = SSLify(app, skips=['health'], age=300, permanent=True)
app.debug = getenv('DEBUG', False)
app.config['theme'] = getenv('THEME', 'light')
@app.route('/', methods=['GET', 'POST'])
def default():
if request.method == 'POST':
return render_template('index.html', error=True)
else:
return render_template('index.html')
@app.route('/create/', methods=['POST'])
def create():
key = uuid4().hex
secret = request.form['secret'].encode('utf-8')
if not secret:
return redirect('/', 307)
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import calendar
from bootstrap import conf, application, populate_g
from flask_babel import Babel, format_datetime
if conf.ON_HEROKU:
from flask_sslify import SSLify
SSLify(application, subdomains=True)
babel = Babel(application)
# Jinja filters
def month_name(month_number):
return calendar.month_name[month_number]
application.jinja_env.filters['month_name'] = month_name
application.jinja_env.filters['datetime'] = format_datetime
application.jinja_env.globals['conf'] = conf
# Views
from flask_restful import Api
from datetime import datetime
from models import User, Lead, AppendedVisitor, GlobalDashboard
from twilio.rest import Client
import config
import json
import random
import hashlib
import hmac
import time
# debug
debug = config.DEBUG
# app config
app = Flask(__name__)
sslify = SSLify(app)
app.config['SECRET_KEY'] = config.SECRET_KEY
# Flask-Mail configuration
app.config['MAIL_SERVER'] = 'smtp.mailgun.org'
app.config['MAIL_PORT'] = 587
app.config['MAIL_USE_TLS'] = True
app.config['MAIL_USERNAME'] = config.MAIL_USERNAME
app.config['MAIL_PASSWORD'] = config.MAIL_PASSWORD
app.config['MAIL_DEFAULT_SENDER'] = config.MAIL_DEFAULT_SENDER
# SQLAlchemy
app.config['SQLALCHEMY_DATABASE_URI'] = config.SQLALCHEMY_DATABASE_URI
app.config[
'SQLALCHEMY_TRACK_MODIFICATIONS'] = config.SQLALCHEMY_TRACK_MODIFICATIONS
db = SQLAlchemy(app)
"""Start program."""
import json
from app.currency import (
URL_CENTRAL_BANK,
currency_name_list,
get_currency_value,
get_json,
list_currencies_to_print,
)
from flask import Flask, request
from flask_sslify import SSLify
from requests import post
app = Flask('__name__')
ssl_certificate = SSLify(app)
TELEGRAM_URL = 'https://api.telegram.org/'
TELEGRAM_TKN = '2dea6508795e78bf1d75f4080a6ad5f685acc48afe0edb8199df3ad06cca3'
SEND_MESSAGE = 'sendMessage'
help_message = "Этот бот выводит актуальный курс валют по ЦБ относительно рубля.\n" \
"Посмотреть список доступной валюты, можно спомощью команды /list.\n"\
"Чтобы узнать курс доллара, нужно ввести стандартное обозначение этой единицы валюты: USD"
currency_list = list_currencies_to_print(get_json(URL_CENTRAL_BANK))
currency_name = currency_name_list(get_json(URL_CENTRAL_BANK))
def send_message(chat_id: str, text='Hola') -> json:
"""Use to send message to chat.
The function accepts the chat identifier and the text entered by the user.
