def main(argv):
cfg = config.Config(FLAGS.config, env_path=FLAGS.dotenv_path)
factory = store.create_store_factory_for_sqlite_db(cfg)
db = factory.create()
password_hash = db.get_password_hash(FLAGS.password)
if FLAGS['create-admin']:
user = store.User(
name=FLAGS.email,
email=FLAGS.email,
password_hash=password_hash,
is_admin=True
)
db.add_user(user)
else:
user_id = db.get_user_by_email(FLAGS.email)
if user_id is None:
logging.error(f"No user for email {FLAGS.email}")
return
admins = db.get_admins()
if not admins:
admin_id = db.add_default_admin()
else:
admin_id = admins[0].user_id
db.update_user(admin_id, user_id, dict(password_hash=password_hash))
def main(unused_argv):
cfg = config.Config(FLAGS.config,
mode=FLAGS.mode,
env_path=FLAGS.dotenv_path)
store_factory = db_store.create_store_factory_for_sqlite_db(cfg)
store = store_factory.create()
populate_store_fake(store)
def main(args=None):
cfg = config.Config(FLAGS.config,
mode=FLAGS.mode,
env_path=FLAGS.dotenv_path)
store_factory = db_store.create_store_factory_for_sqlite_db(cfg)
store = store_factory.create()
csv_synchronizer = synchronizer.CSVSynchronizer(store)
add_pre_icubam_bed_counts(FLAGS.pre_icubam_data_path, csv_synchronizer)
def main(argv):
cfg = config.Config(FLAGS.config, env_path=FLAGS.dotenv_path)
sqldb_factory = store.create_store_factory_for_sqlite_db(cfg)
sqldb = sqldb_factory.create()
encoder = token.TokenEncoder(cfg)
for user in sqldb.get_users():
for icu in user.icus:
print(encoder.encode_data(user, icu))
if not FLAGS.all:
exit()
def __init__(self, config, old_path):
self.config = config
self.old_db = sqlite.SQLiteDB(old_path)
self.new_db_factory = store.create_store_factory_for_sqlite_db(config)
self.new_db = self.new_db_factory.create()
admins = self.new_db.get_admins()
if admins:
self.admin_id = admins[0].user_id
else:
self.admin_id = self.new_db.add_default_admin()
def __init__(self, config, port, root=''):
self.config = config
self.port = port
self.root = root
self.routes = []
self.db_factory = store.create_store_factory_for_sqlite_db(self.config)
self.routes = []
self.start_time = datetime.datetime.utcnow()
self.add_handler(HealthHandler, start_time=self.start_time)
self.callbacks = []
def setUp(self):
super().setUp()
self.config = config.Config('resources/test.toml')
factory = store.create_store_factory_for_sqlite_db(self.config)
self.db = factory.create()
self.queue = tornado.queues.Queue()
self.processor = updater.UpdateProcessor(
self.config, self.db, self.queue, None,
mock_bot.MockTelegramBot(self.config)
)
def setUp(self):
super().setUp()
self.config = config.Config('resources/test.toml')
tg_bot = mock_bot.MockTelegramBot(self.config)
factory = store.create_store_factory_for_sqlite_db(self.config)
self.db = factory.create()
self.queue = tornado.queues.Queue()
self.integrator = integrator.TelegramSetup(self.config,
self.db,
scheduler=None,
tg_bot=tg_bot)
def test_integration_generate_plots(name, integration_config, tmpdir):
store = db_store.create_store_factory_for_sqlite_db(
integration_config).create()
cached_data = load_test_data()
cached_data['bedcounts'] = to_pandas(store.get_bed_counts())
output_dir = str(tmpdir.mkdir("sub"))
generate_plots(plots=[name],
output_dir=output_dir,
cached_data=cached_data)
assert (Path(output_dir) / (name + ".png")).exists()
def setUp(self):
super().setUp()
self.config = config.Config('resources/test.toml')
self.db = store.create_store_factory_for_sqlite_db(self.config).create()
self.queue = tornado.queues.Queue()
self.admin = self.db.add_default_admin()
icu_id = self.db.add_icu(self.admin, store.ICU(name='icu1'))
self.icu = self.db.get_icu(icu_id)
self.bot = mock_bot.MockTelegramBot(self.config)
self.sender = sender.Sender(
self.config, self.db, self.queue, tg_bot=self.bot
)
def setUp(self):
super().setUp()
self.config = config.Config('resources/test.toml')
self.db = store.create_store_factory_for_sqlite_db(
self.config).create()
self.formatter = message_formatter.MessageFormatter()
self.admin_id = self.db.add_default_admin()
self.icu_id = self.db.add_icu(self.admin_id, store.ICU(name='rea'))
self.icu = self.db.get_icu(self.icu_id)
self.user_id = self.db.add_user_to_icu(self.admin_id, self.icu_id,
store.User(name='user'))
self.user = self.db.get_user(self.user_id)
def setUp(self):
self.config = config.Config(self.TEST_CONFIG)
self.config.server.base_url = self.BASE_URL
tg_bot = mock_bot.MockTelegramBot(self.config)
self.db = store.create_store_factory_for_sqlite_db(self.config).create()
self.tg_setup = integrator.TelegramSetup(
self.config, self.db, scheduler=None, tg_bot=tg_bot
)
self.tg_setup._start_periodic_fetching = mock.MagicMock(return_value=None)
with open(self.UPDATES_FILE, 'r') as fp:
self.update = json.load(fp)['result'][0]
super().setUp()
def main(args=None):
cfg = config.Config(FLAGS.config, env_path=FLAGS.dotenv_path)
store_factory = db_store.create_store_factory_for_sqlite_db(cfg)
db = store_factory.create()
csv = synchronizer.CSVSynchronizer(db)
out_buf = csv.export_icus()
if FLAGS.output:
with open(FLAGS.output, 'w') as f_out:
f_out.write(out_buf)
else:
print(out_buf)
def setUp(self):
super().setUp()
self.config = config.Config('resources/test.toml')
factory = store.create_store_factory_for_sqlite_db(self.config)
self.db = factory.create()
self.admin_id = self.db.add_default_admin()
self.icu_id = self.db.add_icu(self.admin_id,
store.ICU(name='hospital'))
self.icu = self.db.get_icu(self.icu_id)
self.user_id = self.db.add_user_to_icu(self.admin_id, self.icu_id,
store.User(name='michel'))
self.user = self.db.get_user(self.user_id)
self.authenticator = authenticator.Authenticator(self.config, self.db)
def setUp(self):
super().setUp()
self.config = config.Config('resources/test.toml')
self.db_factory = store.create_store_factory_for_sqlite_db(self.config)
self.db = self.db_factory.create()
self.queue = MockQueue()
self.scheduler = scheduler.MessageScheduler(self.config, self.db,
self.queue)
self.admin = self.db.add_default_admin()
self.icu_id = self.db.add_icu(self.admin, store.ICU(name='my_icu'))
self.icu = self.db.get_icu(self.icu_id)
user = store.User(name='michel', telephone='1234')
self.user_id = self.db.add_user_to_icu(self.admin, self.icu_id, user)
self.user = self.db.get_user(self.user_id)
def main(argv):
cfg = config.Config(FLAGS.config, mode=FLAGS.mode, env_path=FLAGS.dotenv_path)
factory = store.create_store_factory_for_sqlite_db(cfg)
db = factory.create()
user_id = db.get_user_by_email(FLAGS.email)
if user_id is None:
logging.error(f"No user for email {FLAGS.email}")
return
admins = db.get_admins()
if not admins:
admin_id = db.add_default_admin()
else:
admin_id = admins[0].user_id
hash = db.get_password_hash(FLAGS.password)
db.update_user(admin_id, user_id, dict(password_hash=hash))
def main(args=None):
cfg = config.Config(FLAGS.config,
mode=FLAGS.mode,
env_path=FLAGS.dotenv_path)
store_factory = db_store.create_store_factory_for_sqlite_db(cfg)
store = store_factory.create()
csv = synchronizer.CSVSynchcronizer(store)
if FLAGS.icus_csv:
print(f"Loading ICU CSV from: {FLAGS.icus_csv}")
with open(FLAGS.icus_csv) as icus_f:
csv.sync_icus_from_csv(icus_f, FLAGS.force_update)
if FLAGS.users_csv:
print(f"Loading user CSV from: {FLAGS.users_csv}")
with open(FLAGS.users_csv) as users_f:
csv.sync_users_from_csv(users_f, FLAGS.force_update)
def main(unused_argv):
cfg = config.Config(FLAGS.config,
mode=FLAGS.mode,
env_path=FLAGS.dotenv_path)
shdb = gsheets.SheetsDB(cfg.TOKEN_LOC, cfg.SHEET_ID)
if FLAGS.newdb:
sqldb_factory = store.create_store_factory_for_sqlite_db(cfg)
sqldb = sqldb_factory.create()
sync = synchronizer.StoreSynchronizer(shdb, sqldb)
else:
sqldb = sqlite.SQLiteDB(cfg.db.sqlite_path)
sync = synchronizer.Synchronizer(shdb, sqldb)
reply = (str(
input(
"!!Are you sure you want to sync, this will drop all users!! (duh/nay)"
)).lower().strip())
if reply == "duh":
sync.sync_icus()
sync.sync_users()
def main(argv):
cfg = config.Config(FLAGS.config)
# Make sure DB path exists, to avoid creating an empty one
if not Path(cfg.db.sqlite_path).exists():
logging.error(f"Could not find DB at {cfg.db.sqlite_path}")
return
if FLAGS.output_dir is not None:
cfg.analytics.extra_plots_dir = FLAGS.output_dir
db = store.create_store_factory_for_sqlite_db(cfg).create()
plot_generator = generator.PlotGenerator(cfg, db, dataset.Dataset(db))
eventloop = asyncio.new_event_loop()
if FLAGS.plot_name is not None:
plots = [FLAGS.plot_name]
else:
plots = None
eventloop.run_until_complete(plot_generator.run(plots))
def main(argv):
fields = ['name', 'telephone', 'email']
values = {k: FLAGS[k].value for k in fields if FLAGS[k].value is not None}
cfg = config.Config(FLAGS.config, mode=FLAGS.mode, env_path=FLAGS.dotenv_path)
db_factory = store.create_store_factory_for_sqlite_db(cfg)
db = db_factory.create()
users = db.get_admins()
if users:
admin_id = users[0].user_id
else:
admin_id = db.add_default_admin()
user_query = store.ExternalClient(**values)
user = db.get_external_client_by_email(user_query.email)
if user is None:
logging.info("New access token: {}".format(
db.add_external_client(admin_id, user_query)))
else:
c_id = user.external_client_id
db.update_external_client(admin_id, c_id, values)
logging.info(f"Updated client {c_id} with values: {values}")
def test_integration_generate_plots(name, integration_config, tmpdir):
store = db_store.create_store_factory_for_sqlite_db(
integration_config).create()
output_dir = str(tmpdir.mkdir("out"))
check_generate_plots(name, store, output_dir)
def main(unused_argv):
cfg = config.Config(FLAGS.config,
mode=FLAGS.mode,
env_path=FLAGS.dotenv_path)
store_factory = db_store.create_store_factory_for_sqlite_db(cfg)
store = store_factory.create()
admin_user_id = store.add_user(
User(name='admin',
telephone='+33111111111',
email='*****@*****.**',
is_admin=True,
password_hash=store.get_password_hash('password')))
manager_user_id = store.add_user(
User(name='manager',
telephone='+33222222222',
email='*****@*****.**',
password_hash=store.get_password_hash('manager')))
region_id = store.add_region(admin_user_id, Region(name='Paris'))
def add_icu(name, dept, city, lat, long, telephone, n_covid_occ,
n_covid_free, n_ncovid_free, n_covid_deaths, n_covid_healed,
n_covid_refused, n_covid_transfered):
icu_id = store.add_icu(
admin_user_id,
ICU(name=name,
region_id=region_id,
dept=dept,
city=city,
lat=lat,
long=long,
telephone=telephone))
store.update_bed_count_for_icu(
admin_user_id,
BedCount(icu_id=icu_id,
n_covid_occ=n_covid_occ,
n_covid_free=n_covid_free,
n_ncovid_free=n_ncovid_free,
n_covid_deaths=n_covid_deaths,
n_covid_healed=n_covid_healed,
n_covid_refused=n_covid_refused,
n_covid_transfered=n_covid_transfered))
return icu_id
add_icu('A. Beclere', '92', 'Clamart', 48.788055555555545,
2.2547222222222216, 'test_tel', 23, 4, 12, 200, 34, 7, 1)
add_icu('A. Pare', '93', 'Unknown', 48.84916666666667, 2.2355555555555555,
'test_tel', 3, 14, 12, 200, 3, 7, 1)
icu_id = add_icu('Avicenne', '93', 'Bobigny', 48.914722222222224,
2.4241666666666664, 'test_tel', 12, 23, 12, 200, 34, 12,
1)
store.add_user_to_icu(
admin_user_id, icu_id,
User(name='user2', telephone='+336699999', description='desc2'))
store.assign_user_as_icu_manager(admin_user_id, manager_user_id, icu_id)
add_icu('Beaujon', '93', 'Bobigny', 48.90833333333333, 2.310277777777777,
'test_tel', 5, 6, 12, 200, 34, 7, 1)
icu_id = add_icu('Bicetre', '93', 'Kremelin-Bicetre', 48.81,
2.353888888888889, 'test_tel', 9, 2, 12, 200, 34, 44, 1)
store.add_user_to_icu(
admin_user_id, icu_id,
User(name='user1', telephone='+336666666', description='desc1'))
def test_create_store_factory_for_sqlite_db(self):
cfg = config.Config(
os.path.join(os.path.dirname(os.path.abspath(__file__)),
"../../resources/test.toml"))
store_factory = db_store.create_store_factory_for_sqlite_db(cfg)
store_factory.create()
def setUp(self):
super().setUp()
self.config = config.Config('resources/test.toml')
self.factory = store.create_store_factory_for_sqlite_db(self.config)
self.db = self.factory.create()
self.populate_db()
def __init__(self, config):
self.config = config
db_factory = store.create_store_factory_for_sqlite_db(config)
self.store = db_factory.create()
self.db = sqlite3.connect(self.config.db.sqlite_path)
