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()
