def create_app(): """Construct the core application.""" app = Flask( __name__, instance_relative_config=False, ) p_flask_config = Path('/etc/indi-allsky/flask.json') app.config.from_file(p_flask_config, load=json.load) csrf.init_app(app) app.register_blueprint(bp) db.init_app(app) migrate.init_app(app, db) with app.app_context(): from flask_sqlalchemy import event event.listen(db.engine, 'connect', _sqlite_pragma_on_connect) from . import views # noqa: F401 db.create_all() # Create sql tables for our data models return app
def init_app(app): """ initialise l'app avec le model """ app.app_context().push() db.init_app(app) event.listen(db.engine, 'connect', lambda con, _: con.execute('pragma foreign_keys=ON')) db.create_all() db.session.commit()
def register_listeners(cls): """ If the inherited class manages files (controls their names and deletions), listen for record deletion and id change and rename or delete the file when necessary. :return: """ event.listen(cls, 'after_delete', cls.delete_file) event.listen(cls.id, 'set', cls.synchronize_filename)
def init_app(app): db.init_app(app) cache.init_app(app) app.json_encoder = NewJSONEncoder event.listen(db.session, 'before_flush', clear_cache_dirty) with app.app_context(): register_blueprints(app) register_error_handlers(app)
def initialize_database(self, db): logger.info('initialize database...') self.db = db self.db.init_app(self.app) default_database_parameter_values = {'max_rows': 100000, 'max_flush_cache': 1000} for parameter, default_value in default_database_parameter_values.items(): if not self.config.has_option('database', parameter): logger.warn("do not find '{parameter}' in database section, use default value: '{default_value}'" .format(parameter=parameter, default_value=default_value)) value = default_value else: value = self.config.getint('database', parameter) globals()[parameter] = value Base.max_rows = globals()['max_rows'] Base.max_flush_cache = globals()['max_flush_cache'] metric_names = [func_name for func_name, _, in get_funcs(metric_task)] for metric_name in metric_names: table = type(metric_name.upper(), (Base, self.db.Model), {'__tablename__': metric_name, 'rows': 0}) event.listen(table, 'after_insert', table.on_insert) self.table_class_relation[metric_name] = table with self.app.app_context(): self.db.create_all()
''' Created on 05-Jul-2015 @author: nilesh ''' from manage import db from flask_sqlalchemy import event def _fk_pragma_on_connect(dbapi_con, con_record): dbapi_con.execute('pragma foreign_keys=ON') # sqlite3 does not enforce foreign key constraints by default # this line makes all connections auto enforce event.listen(db.engine, 'connect', _fk_pragma_on_connect)
"handle an on checkout event" # print('check out event') # print(dbapi_conn) # print(connection_rec) # print(connection_proxy) def receive_checkin(dbapi_connection, connection_record): # print('check in event') # print(dbapi_connection) # print(connection_record) "listen for the 'checkin' event" def receive_close(dbapi_connection, connection_record): # print('close event') # print(dbapi_connection) # print(connection_record) "listen for the 'close' event" def receive_connect(dbapi_connection, connection_record): # print('connect event') # print(dbapi_connection) # print(connection_record) "listen for the 'connect' event" event.listen(db.engine, 'checkout', my_on_checkout) event.listen(db.engine, 'checkin', receive_checkin) event.listen(db.engine, 'close', receive_close) event.listen(db.engine, 'connect', receive_connect)
diaAtual = date.today() diaAtual = diaAtual.strftime("%d/%m/%Y") #converter o objeto em datetime diaAtual = datetime.strptime(diaAtual, '%d/%m/%Y') #FIXME:Validação de FK no sqlite3 não esta funcionando, post no stackoverflow #Ativar validação FK para o sqlite3 engine = create_engine(r'sqlite:///../Controller/BD/RegistroChamado.db') def _fk_pragma_on_connect(con=getConnect(database_url)): con.execute('pragma foreign_keys=ON') event.listen(engine, 'connect', _fk_pragma_on_connect) #Cria o banco sqlite caso nao exista e cria as tabelas caso não existam @app.before_first_request def initialize(): #realiza a criação do banco de dados sqlLite3_creat.main(database_url) #Realiza a criação das tabelas sqla.create_all() #Pagina inicial, onde sao exibidas notificacoes em aberto @app.route("/")
def get_full_name(self): return str(self.full_name) def get_msk_group(self): return str(self.msk_group) def get_role(self): return str(self.role) @property def serialize(self): """Return object data in easily serializable format""" return { 'id': self.id, 'username': self.username, 'msk_group': self.msk_group, 'role': self.role, } def insert_initial_values(*args, **kwargs): for user in supers: db.session.add(User(username=user, role='super')) for user in members: db.session.add(User(username=user, role='member')) db.session.commit() event.listen(User.__table__, 'after_create', insert_initial_values)
def listener_reset_field_updated_in_actual_time(thing_obj): """ This function launch a event than listen like a signal when some object is saved """ event.listen(thing_obj, 'before_update', update_object_timestamp, propagate=True)
None, [email], format='html', text_body=TEXT_BODY, html_body=HTML_BODY) def to_json(self, options={}): include_domain = options.get('domain', True) url = self.url if include_domain else os.path.basename(self.url) return { 'url': url, 'gender': self.gender, } event.listen(Image, 'after_update', Image.after_update) basic_auth = BasicAuth(app) class BasicAuthModelView(ModelView): def is_accessible(self): return basic_auth.authenticate() def inaccessible_callback(self, name, **kwargs): return basic_auth.challenge() class BasicAuthAdminView(AdminIndexView): def is_accessible(self): return basic_auth.authenticate()
def __declare_last__(cls): event.listen(cls, 'before_insert', cls.create_time) event.listen(cls, 'before_update', cls.update_time)
elif days >= 28: updated = f"{days//7} Weeks Ago" elif days >= 1: updated = f"{days} Days Ago" else: updated = "Today" return updated @property def serialize(self): return { "id": self.id_, "type": self.type, "published": json.dumps(self.published), "title": self.title, "slug": "-".join(self.title.lower().split()), "description": self.description, "link": json.dumps(self.link), "content": self.content, "feature_image": self.feature_image, "anchor_pairs": self.anchor_pairs, "tags": json.dumps([f"{tag.name}" for tag in self.tags]), "created_at": self.created_at.strftime("%b %d %Y"), "updated_at": self.formatUpdatedAt(), } event.listen(Article.type, "set", Article.before_set_type)
'recipient_id': self.recipient_id, 'created_on': self.created_on.isoformat(), 'updated_on': self.updated_on.isoformat(), 'contents': self.contents } def mark_read(self): self.read = True return self # Do not register ExternalFile because we don't manage their filenames! Workflow.register_listeners() Sample.register_listeners() Collection.register_listeners() event.listen(User.id, 'set', User.reset_redis_hashes) event.listen(User, 'after_delete', User.reset_redis_hash) def validate_update_dict(record: db.Model, user: User, new_data: Dict[str, Any]): protected_keys = { 'created_on', 'updated_on', } admin_keys = { 'owner_id', 'creator_id' } def invalid(key): return key in protected_keys if user.admin else (key in protected_keys | admin_keys)
def register_loader(cls): # noinspection PyUnresolvedReferences event.listen(cls.__table__, "after_create", cls.load_values)
def __declare_last__(cls): event.listen(cls, 'before_update', cls._set_updated_at)
pass @staticmethod def synchronize_filename(target, value, oldvalue, initiator): if value != oldvalue and target.file_exists: shutil.move(str(config.WORKFLOW_DEFINITION_DIR.joinpath(oldvalue)), str(config.WORKFLOW_DEFINITION_DIR.joinpath(value))) def to_dict(self): return { 'relative_filename': self.relative_filename, 'name': self.name, 'description': self.description, 'owner_id': self.owner_id } def update(self, data, current_user: User): for key in ['name', 'description', 'relative_filename', 'owner_id']: if self.owner is current_user or current_user.admin: setattr(self, key, data['key']) else: raise AuthException( f'User {current_user.username} cannot update workflow definition {self.relative_filename}' ) event.listen(WorkflowDefinition, 'after_delete', WorkflowDefinition.delete_file) event.listen(WorkflowDefinition.relative_filename, 'set', WorkflowDefinition.synchronize_filename)
def after_photo_delete_listener(mapper, connection, target): if os.path.exists(target.full_filename): os.remove(target.full_filename) app = create_app(os.getenv('FLASK_CONFIG') or 'default') migrate = Migrate(app, db, directory=os.path.join(os.path.dirname(__file__), 'migrations')) manager = Manager(app) manager.add_command('db', MigrateCommand) event.listen(MuralPhoto, 'after_delete', after_photo_delete_listener) @manager.option('-n', '--name', dest='admin_username') @manager.option('-p', '--pass', dest='admin_password') def set_defaults(admin_username, admin_password): """ Adds default values to the database: * creates an admin user * adds languages: English and Ukrainian :param admin_username: admin user name :param admin_password: admin user password :return: nothing """ from app.models import Language, User Language.insert_languages()