os.path.realpath(os.path.dirname(__file__) + '/../../../local'),
"application.cfg")
if os.path.isfile(app_config_file):
app.config.from_pyfile(app_config_file, silent=True)
elif platform == "linux2" and os.path.isfile('/etc/astrobox/application.cfg'):
app.config.from_pyfile('/etc/astrobox/application.cfg', silent=True)
assets = Environment(app)
Compress(app)
userManager = None
eventManager = None
loginManager = None
softwareManager = None
principals = Principal(app)
admin_permission = Permission(RoleNeed("admin"))
user_permission = Permission(RoleNeed("user"))
# only import the octoprint stuff down here, as it might depend on things defined above to be initialized already
from octoprint.server.util import LargeResponseHandler, ReverseProxied, restricted_access, PrinterStateConnection, admin_validator, \
UrlForwardHandler, user_validator
from astroprint.printer.manager import printerManager
from octoprint.settings import settings
import octoprint.util as util
import octoprint.events as events
#import octoprint.timelapse
import astroprint.users as users
from astroprint.software import softwareManager as swManager
##############################################################################
# Settings
##############################################################################
DEBUG = False #True
##############################################################################
app = Flask(__name__)
app.config.from_object(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///matedealer.db'
app.config['SECRET_KEY'] = "thats-my-secret"
db = SQLAlchemy(app)
lm = LoginManager()
lm.setup_app(app)
principal = Principal(app)
permission_admin = Permission(RoleNeed(u'admin'))
permission_treasurer = Permission(RoleNeed(u'treasurer'))
permission_user = Permission(RoleNeed(u'user'))
##############################################################################
# Database Models
##############################################################################
# Helper table for many-to-many realtionship of users <> roles
roles = db.Table('roles',
db.Column('role_id', db.Integer, db.ForeignKey('role.id')),
db.Column('user_id', db.Integer, db.ForeignKey('user.id')))
def _get_principal(app):
p = Principal(app, use_sessions=False)
p.identity_loader(_identity_loader)
return p
from flask import flash, redirect, url_for, session
from flask.ext.bcrypt import Bcrypt
from flask.ext.openid import OpenID
from flask.ext.login import LoginManager
from flask.ext.principal import Principal, Permission, RoleNeed
from flask.ext.restful import Api
bcrypt = Bcrypt()
oid = OpenID()
principals = Principal()
admin_permission = Permission(RoleNeed('admin'))
poster_permission = Permission(RoleNeed('poster'))
default_permission = Permission(RoleNeed('default'))
class Config(object):
SECRET_KEY = '736670cb10a600b695a55839ca3a5aa54a7d7356cdef815d2ad6e19a2031182b'
RECAPTCHA_PUBLIC_KEY = "6LdKkQQTAAAAAEH0GFj7NLg5tGicaoOus7G9Q5Uw"
RECAPTCHA_PRIVATE_KEY = '6LdKkQQTAAAAAMYroksPTJ7pWhobYb88fTAcxcYn'
class ProdConfig(Config):
#SQLALCHEMY_DATABASE_URI = 'postgresql://*****:*****@localhost/elogstation1'
#SQLALCHEMY_DATABASE_URI = 'postgresql://*****:*****@localhost/elogstation'
SQLALCHEMY_DATABASE_URI = 'postgresql://*****:*****@localhost/elogstation10'
SQLALCHEMY_DATABASE_URI = 'sqlite:///../database3.db'
#SQLALCHEMY_DATABASE_URI = 'sqlite:///../database9.db'
CELERY_BROKER_URL = 'redis://127.0.0.1:6379/0'
CELERY_BACKEND_URL = 'redis://127.0.0.1:6379/0'
# -*- coding: utf-8 -*-
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.admin import Admin
from flask.ext.login import LoginManager
from flask.ext.principal import Principal
from config import config
from permission import config_identity
app = None
db = SQLAlchemy()
admin_app = Admin()
login_manager = LoginManager()
principal = Principal()
def create_app(config_name):
global app
app = Flask(__name__, static_folder='static', template_folder='templates')
app.config.from_object(config[config_name])
admin_app.init_app(app)
db.init_app(app)
login_manager.init_app(app)
principal.init_app(app)
config_identity(app)
from .api_1_0 import api as api_1_0_blueprint
app.register_blueprint(api_1_0_blueprint, url_prefix='/api/v1.0')
from .admin import admin as admin_blueprint
from flask import Flask, request, redirect, session, jsonify, url_for
import sqlite3
from flask_oauthlib.client import OAuth, OAuthException
from flask.ext.principal import Principal, Permission, identity_changed, Identity, identity_loaded
app = Flask(__name__)
Principal(app)
oauth = OAuth(app)
app.debug = True # TODO: in production, change this to 'False'
app.secret_key = 'super secret key' # TODO: change this!!!
# TODO: Define Permission tags here.
logged_in_permission = Permission(('logged in'))
role_admin_permission = Permission(('role', 'admin'))
# TODO: change this
consumer_key = ''
consumer_secret = ''
google = oauth.remote_app(
'google',
consumer_key=consumer_key,
consumer_secret=consumer_secret,
request_token_params={
'scope': 'https://www.googleapis.com/auth/userinfo.email'
},
base_url='https://www.googleapis.com/oauth2/v1/',
request_token_url=None,
access_token_method='POST',
access_token_url='https://accounts.google.com/o/oauth2/token',
import logging
import flask
from flask.ext.principal import (Principal, Permission, Identity, RoleNeed,
UserNeed, PermissionDenied)
from werkzeug.urls import url_encode
from art17.ldap_access import open_ldap_server
auth = flask.Blueprint('auth', __name__)
principals = Principal(use_sessions=False)
class need(object):
""" A list of needs defined by our application. """
everybody = RoleNeed('everybody')
admin = RoleNeed('admin')
authenticated = RoleNeed('authenticated')
impossible = RoleNeed('impossible')
expert = RoleNeed('expert')
reviewer = RoleNeed('reviewer')
reporter = RoleNeed('reporter')
validator = RoleNeed('validator')
@staticmethod
def user_id(user_id):
return UserNeed(user_id)
@staticmethod
def role(role):
def configure_identity(app):
principal = Principal(app)
@identity_loaded.connect_via(app)
def on_identity_loaded(sender, identity):
g.user = User.query.from_identity(identity)
#OpenID
from flask.ext.openid import OpenID
from bluemonk.libs.openid_store import DatabaseOpenIDStore
oid = OpenID(app, store_factory=DatabaseOpenIDStore)
# Asynchronous processing
from bluemonk.celery import celery
#Mails
from bluemonk.libs.mailer import Mailer
mailer = Mailer(app)
#Identity
from flask.ext.principal import Principal, PermissionDenied
principals = Principal(app, skip_static=True)
#cups error
from bluemonk.proxies.printers_proxy import CupsError
@app.errorhandler(CupsError)
def handle_cups_error(error):
referrer = request.referrer
return render_template('cups_error.html', error=error,
referrer=referrer), 500
@app.errorhandler(PermissionDenied)
def handle_permission_error(error):
#TODO Log permission error
from libraries.graphLib.graphe_tbc import GraphTBC
#Create Flask app
server = Flask(__name__)
# Import Config
server.config.from_pyfile('../server.config')
# SQLAlchemy
db = SQLAlchemy(server)
# Celery
celery = make_celery(server)
# Graphe
G = GraphTBC()
from project.libraries.celeryLib.tasks import *
# FlaskLogin
login_manager = LoginManager(server)
# FlaskPrincipal
Principal(server)
# FlaskGCM
clientGCM = FlaskGCM(server)
# FlaskAPNS
clientAPNS = FlaskAPNS(server)
