def home(version):

    class F(Form):
        pass

    wtforms_json.init()
    v_version = int(version[1])

    for name, validtrs in API_validators[v_version-1].items():
        setattr(F, name, StringField(label=name, validators=validtrs))

    jsondata = request.get_json()
    flatten_json=flatten_dict(jsondata)

    form = F.from_json(flatten_json)

    res = form.validate()
    for field, errors in form.errors.items():
        for error in errors:
            print(u"Error in the %s field - %s" % (
                getattr(form, field).label.text,
                error
            ))
    if res:
        persons_file = os.path.join('files', 'objects.json')

        with open(persons_file,'a') as _file:
            _file.write(request.data)
        if v_version == 2:
            print("Request Saved!")

    return ('valid', 200) if res else ('invalid', 400)

def validate_rsvp_field(form):
    wtforms_json.init()

    form = RsvpForm.from_json(json.loads(form))
    if form.validate():
        return form
    else:
        print 'validation errors:'
        print form.errors

def init_for(env):
    coaster.app.init_app(app, env)
    db.init_app(app)
    db.app = app

    lastuser.init_app(app)
    lastuser.init_usermanager(UserManager(db, User))
    app.config['tz'] = timezone(app.config['TIMEZONE'])

    baseframe.init_app(app, requires=['boxoffice'], ext_requires=['baseframe-bs3', 'fontawesome>=4.0.0', 'ractive', 'ractive-transitions-fly', 'validate'])

    mail.init_app(app)
    wtforms_json.init()

def create_application():
    wtforms_json.init()

    static_path = os.path.join(os.path.dirname(__file__), "static")
    application = tornado.web.Application(
        api_handlers + frontend_handlers,
        debug=options.debug,
        cookie_secret=options.cookie_secret,
        static_path=static_path,
    )

    # config database
    src_dir = os.path.dirname(os.path.dirname(__file__))
    database = SqliteExtDatabase(os.path.join(src_dir, "database.db"), threadlocals=True)
    database_proxy.initialize(database)
    # database.connect()

    return application

def ficha_registro():
    import wtforms_json
    wtforms_json.init()
    "carga de registros de produccion"
    form = formProduccionCarga(request.form)
    if request.method == 'GET':
        return render_template('produccion_ficha.html', form=form)
    elif request.method == 'POST':
        # print ">>", form.patch_data

        o = data_produccion()
        o.setProduccion(form.patch_data)
        data = o.getProduccion(form.codpro.data, form.legajo.data, form.lote.data)
        return render_template('produccion_ficha.html', form=form, data=data)

    form.legajo.data = ''
    form.horas_trabajadas.data = ''
    form.horas.data = 'P'
    return render_template('produccion_ficha.html', form=form)

def create_app(package_name, package_path, settings_override=None):
    """Returns a :class:`Flask` application instance configured with common
    functionality for the IEEE platform.

    :param package_name: application package name
    :param package_path: application package path
    :param settings_override: a dictionary of setings to override
    """
    app = Flask(package_name, instance_relative_config=True)
    app.config.from_object(config)

    # Initialize extensions.
    db.init_app(app)
    mail.init_app(app)
    login_manager.init_app(app)
    gravatar.init_app(app)
    compress.init_app(app)
    # I may need to put this in core.py later on.
    wtforms_json.init()

    register_blueprints(app, package_name, package_path)

    return app

def launch(_ike_instance):
    global ike_instance
    ike_instance = _ike_instance
    wtforms_json.init()
    
    api_url_prefix = '/api/v1'

    app = flask.Flask('ike', static_folder=config.STATIC_FILES)

    # beer
    register_api(app, BeerApi, 'beers', api_url_prefix + '/beers/', pk='id')
    
    # users
    register_api(app, UserApi, 'users', api_url_prefix + '/users/', pk='id')

    # kegs
    view_func = KegApi.as_view('kegs')
    app.add_url_rule(api_url_prefix + '/kegs/', defaults={'id': None}, view_func=view_func, methods=['GET',])
    app.add_url_rule(api_url_prefix + '%s<%s:%s>' % ('/kegs/', 'int', 'id'), view_func=view_func, methods=['GET', 'PUT'])
    
    # sensors
    app.add_url_rule(api_url_prefix + '/thermostat/', view_func=ThermostatApi.as_view('thermostat'), methods=['GET', 'PUT'])
    app.add_url_rule(api_url_prefix + '/carbonation/', view_func=CarbonationApi.as_view('carbonation'), methods=['GET'])
    app.add_url_rule(api_url_prefix + '/adc/', view_func=AdcApi.as_view('adc'), methods=['GET'])
    app.add_url_rule(api_url_prefix + '/flow/', view_func=FlowApi.as_view('flow'), methods=['GET'])

    # kegerator settings
    app.add_url_rule(api_url_prefix + '/kegerator/', view_func=KegeratorSettingsApi.as_view('kegerator'), methods=['GET','PUT'])

    # logs
    app.add_url_rule(api_url_prefix + '/events/', view_func=EventApi.as_view('events'), methods=['GET'])
    
    # serve the frontend
    app.add_url_rule('/', 'root', lambda: app.send_static_file('index.html'))
    app.add_url_rule('/<path:path>', 'send_static', lambda path: app.send_static_file(path))

    app.run(host='0.0.0.0', debug=config.FLASK_DEBUG)

 def post(self):
     """
     规则增加功能
     """
     argument = json.loads(self.request.body)
     wtforms_json.init()
     try:
         if argument["rule_complexity"] == "simple":
             form = SimpleForm.from_json(argument, skip_unknown_keys=False)
         elif argument["rule_complexity"] == "complex":
             form = ComplexForm.from_json(argument, skip_unknown_keys=False)
         if not form.validate():
             message = form.errors.values()[0][0]
             return {"errcode": 30061, "message": message}
         if argument["rule_complexity"] == "complex":
             filename = argument["rule_name"].lower() + ".py"
             if not os.path.exists(
                 "../rule_analysis/rule/extend/" + filename):
                 return {"errcode":30063, "message": u"需要先上传脚本"}
         record = self.mongo_client.get_collection("rule").find_one({
             "rule_name": argument["rule_name"].upper(),
             "db_type": argument["db_type"]})
         if record:
             return {"errcode": 30062, "message": u"规则已经存在"}
         argument["rule_name"] = argument["rule_name"].upper()
         argument["rule_solution"] = argument["rule_solution"].split("\n")
         argument["max_score"] = float(argument["max_score"])
         argument["weight"] = float(argument["weight"])
         if argument["input_parms"]:
             for index, value in enumerate(argument["input_parms"]):
                 argument["input_parms"][index]["parm_value"] = \
                     float(value["parm_value"])
         self.mongo_client.get_collection("rule").insert_one(argument)
         return {"errcode": 80061, "message": u"增加规则成功"}
     except wtforms_json.InvalidData as e:
         return {"errcode": 30060, "message": str(e)}

from __future__ import unicode_literals
import decimal
import datetime
import logging
from importlib import import_module
import pkg_resources

import six
from pyramid.authorization import ACLAuthorizationPolicy
from pyramid.config import Configurator
from pyramid.i18n import TranslationStringFactory
from pyramid.renderers import JSON
from pyramid.settings import aslist
from pyramid_who.whov2 import WhoV2AuthenticationPolicy
from pyramid.settings import asbool
import wtforms_json; wtforms_json.init()

__version__ = pkg_resources.require(__name__)[0].version

_ = TranslationStringFactory(__name__)

log = logging.getLogger(__name__)

from .settings import piwik_from_config
from .security import RootFactory, groupfinder  # NOQA


settings_defaults = {
    'piwik.enabled': False,

    # Ignored unless static_view is set to true

filename = os.path.join(os.path.dirname(__file__), '..', '..', 'conf')
with open(filename) as conf:
    for line in conf:
        line_array = line.split('=')
        if line_array[0] == "DATABASE_NAME":
            DATABASE_NAME = line_array[1].strip()
        if line_array[0] == "DATABASE_USER":
            DATABASE_USER = line_array[1].strip()
        if line_array[0] == "DATABASE_PASSWORD":
            DATABASE_PASSWORD = line_array[1].strip()

app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://{}:{}@localhost:5432/{}'.format(DATABASE_USER, DATABASE_PASSWORD, DATABASE_NAME)

db = SQLAlchemy(app)

wtforms_json.init()


class ModelObject(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    date_updated = db.Column(db.TIMESTAMP, server_default=db.func.now(), onupdate=db.func.current_timestamp())

    # Added methods
    def save(self):
        db.session.add(self)
        db.session.commit()

    def update(self, json):
        self.set_columns(**json)
        db.session.commit()

def create_app(package_name, static_url_path=None, settings_override=None):
    """Creates a configured Flask instance.

    :param package_name: application package name
    :param package_path: application package path
    :param settings_override: a dictionary of settings to override
    """


    app = SilentlyFlask(package_name, instance_relative_config=True,
                static_url_path=static_url_path)

    # Load the config file.
    # TODO: This could be refactored to be more dynamic.
    app.config.from_object('silently.config')

    # Override config where specified.
    if settings_override:
        app.config.update(**settings_override)

    # Let's use a regex converter for more power.
    app.url_map.converters['regex'] = RegexConverter

    loader = jinja2.ChoiceLoader([
        app.jinja_loader,
        jinja2.FileSystemLoader(path.join(path.dirname(__file__), 'templates'))
    ])
    app.jinja_loader = loader

    # TODO: These error handler inits must be refactored.
    security.init_app(app, MongoEngineUserDatastore(None, User, Role),
                      register_blueprint=False)

    # Initialize flask_redis.
    redis.init_app(app)

    # Initialize flask_cache for memoize functionality.
    cache.init_app(app)

    # Initialize mongo_engine for MongoDB ORM like features.
    mongo_engine.init_app(app)

    # Use Redis as the simple key value store for sessions.
    store = RedisStore(redis)
    KVSessionExtension().init_app(app, session_kvstore=store)

    # Initialize flask_login manager.
    login_manager.init_app(app)

    # Set a custom anonymous object.
    login_manager.anonymous_user = AnonymousUser

    # Initialize flask_principal for resource access control.
    principals.init_app(app)

    # There are lots of legacy proxy servers in the wild that do not allow
    # certain methods like PATCH. To overcome this it is necessary to specify
    # the method in a header, and use middleware to transform the request
    # before it is routed.
    app.wsgi_app = ProxyFix(HTTPMethodOverrideMiddleware(app.wsgi_app))

    # Send emails in case of server errors. This handler is used with calls
    # to flask.log_exception.
    if app.config['ENABLE_ERROR_EMAIL']:
        email_errors.init_app(app)

    # Allow CSRF tokens to be transmitted in JSON data.
    wtforms_json.init()

    # Init CSRF helper.
    csrf.init_app(app)

    # Initialize signal handlers.
    signals.init_app(app)

    # Initialize Error Handler
    error_handler.init_app(app)

    # Initialize the ordrin API.
    ordrin_api.init_app(app)

    return app

from wtforms_json import init

init()

import logging
import pkg_resources

from pyramid.i18n import TranslationStringFactory
import wtforms_json; wtforms_json.init()  # monkey-patch wtforms to accept JSON data

log = logging.getLogger('occams').getChild(__name__)

_ = TranslationStringFactory(__name__)

__prefix__ = '/forms'
__title__ = _(u'Forms')
__version__ = pkg_resources.require(__name__)[0].version


def includeme(config):

    config.registry.settings['occams.apps']['occams_forms'] = {
        'name': 'forms',
        'title': _(u'Forms'),
        'package': 'occams_forms',
        'route': 'forms.index',
        'version': __version__
    }

    config.include('.assets')
    config.include('.routes')
    config.scan()

from __future__ import unicode_literals
import logging
import pkg_resources

from pyramid.i18n import TranslationStringFactory
import wtforms_json; wtforms_json.init()  # flake8: noqa

from . import models


log = logging.getLogger('occams').getChild(__name__)

_ = TranslationStringFactory(__name__)

__prefix__ = '/imports'
__title__ = _(u'Imports')
__version__ = pkg_resources.require(__name__)[0].version


def initdb(connectable): # pragma: no cover
    models.ImportsModel.metadata.create_all(connectable)


def includeme(config):

    config.registry.settings['occams.apps']['occams_imports'] = {
        'name': 'imports',
        'title': _(u'Imports'),
        'package': 'occams_imports',
        'route': 'imports.index',
        'version': __version__

def validate_registration_field(attendee):
    wtforms_json.init()
    form = RegistrationForm.from_json(json.loads(attendee))
    
    # if form.validate():
    return form

def configure_extentions(app):
    from app.extensions import db
    import wtforms_json
    db.init_app(app)
    wtforms_json.init()