def main(argv):
servers = {
'www': www_server.WWWServer,
'message': msg_server.MessageServer,
'backoffice': backoffice_server.BackOfficeServer,
}
service = servers.get(FLAGS.server, None)
cfg = config.Config(FLAGS.config,
mode=FLAGS.mode,
env_path=FLAGS.dotenv_path)
if service is not None:
service(cfg, FLAGS.port).run()
elif FLAGS.server == 'all':
# For some reason the cfg object won't pickle, so we pass in the
# necessary values to rebuild it in the child process:
processes = [
mp.Process(target=functools.partial(utils.run_server,
cls,
config_path=FLAGS.config,
mode=FLAGS.mode,
env_path=FLAGS.dotenv_path))
for cls in servers.values()
]
for p in processes:
p.start()
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)
sqldb = sqlite.SQLiteDB(cfg.db.sqlite_path)
import_sheet = shdb.get_sheet_as_pd("Import")
sync = synchronizer.Synchronizer(shdb, sqldb)
sync.sync_icus()
sync.sync_users()
sqldb.execute("DELETE FROM bed_updates")
for row in import_sheet.iterrows():
row_info = {
"icu_name": row[1]["Hopital"],
"n_covid_occ": row[1]["NbCOVID"],
"n_covid_free": row[1]["NbLitDispo"],
"n_ncovid_free": 0,
"n_covid_deaths": row[1]["NbDeces"],
"n_covid_healed": row[1]["NbSortieVivant"],
"n_covid_refused": 0,
"n_covid_transfered": 0,
}
icu_id = sqldb.get_icu_id_from_name(row_info["icu_name"])
row_info["icu_id"] = icu_id
print(row_info)
sqldb.update_bedcount(**row_info)
def setUp(self):
super().setUp()
os.environ['SMTP_HOST'] = SMTP_HOST
os.environ['SMTP_USER'] = SMTP_USER
os.environ['SMTP_PASSWORD'] = SMTP_PASSWORD
os.environ['EMAIL_FROM'] = EMAIL_FROM
self.config = config.Config('resources/test.toml', mode='dev')
def setUp(self):
super().setUp()
self.config = config.Config('resources/test.toml')
self.queue = tornado.queues.Queue()
self.fetcher = updater.UpdateFetcher(
self.config, self.queue, mock_bot.MockTelegramBot(self.config)
)
def test_encode(self):
cfg = config.Config('resources/test.toml')
tkn = token.TokenEncoder(cfg)
userid = 1234
encoded = tkn.encode(userid)
self.assertIsInstance(encoded, str)
self.assertEqual(tkn.decode(encoded), userid)
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(argv):
cfg = config.Config(FLAGS.config, mode=FLAGS.mode, env_path=FLAGS.dotenv_path)
ms = sms_sender.get_sender(cfg, sms_carrier='TW')
ms.send_message("33698158092", "Test from TW")
ms = sms_sender.get_sender(cfg, sms_carrier='NX')
ms.send_message("33698158092", "Test from NX")
ms = sms_sender.get_sender(cfg, sms_carrier='MB')
ms.send_message("33698158092", "Test from MB")
def setUp(self):
self.config = config.Config(self.TEST_CONFIG, mode='dev')
self.server = server.BackOfficeServer(self.config, port=8889)
self.db = self.server.db_factory.create()
userid = self.db.add_default_admin()
self.user = self.db.get_user(userid)
self.app = self.get_app()
super().setUp()
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, mode=FLAGS.mode, env_path=FLAGS.dotenv_path)
if FLAGS.phone is not None:
for sms_carrier in ['TW', 'NX', 'MB']:
ms = sms_sender.get(cfg, sms_carrier=sms_carrier)
ms.send(FLAGS.phone, f"Test from {sms_carrier}")
else:
logging.error('Specify a phone number.')
def main(unused_argv):
cfg = config.Config(FLAGS.config, env_path=FLAGS.dotenv_path)
mgt = migrator.Migrator(cfg)
if not click.confirm(
"WARNING: THIS WILL UPDATE THE DATABASE IN-PLACE. CONTINUE?", err=True
):
return
else:
mgt.run()
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 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 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 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(unused_argv):
cfg = config.Config(FLAGS.config,
mode=FLAGS.mode,
env_path=FLAGS.dotenv_path)
# First we migrate
mgt = migrator.Migrator(cfg, FLAGS.old_db_path)
mgt.run()
# Now we add the region that was not in the old one.
sheets = gsheets.SheetsDB(cfg.TOKEN_LOC, cfg.SHEET_ID)
sync = synchronizer.StoreSynchronizer(sheets, mgt.new_db)
sync.sync_icus()
def main(argv):
servers = {
'www': www_server.WWWServer,
'message': msg_server.MessageServer,
'backoffice': backoffice_server.BackOfficeServer,
}
service = servers.get(FLAGS.server, None)
cfg = config.Config(FLAGS.config,
mode=FLAGS.mode,
env_path=FLAGS.dotenv_path)
if service is not None:
service(cfg, FLAGS.port).run()
def setUp(self):
self.config = config.Config(self.TEST_CONFIG)
self.server = server.AnalyticsServer(self.config, port=8866)
self.db = self.server.db_factory.create()
self.admin_id = self.db.add_default_admin()
self.icu_id = self.db.add_icu(self.admin_id, store.ICU(name='icu'))
self.user_id = self.db.add_user_to_icu(
self.admin_id, self.icu_id,
store.User(name='user', consent=True, is_active=True))
self.user = self.db.get_user(self.user_id)
self.icu = self.db.get_icu(self.icu_id)
super().setUp()
def main(unused_argv):
cfg = config.Config(FLAGS.config, mode=FLAGS.mode)
sdb = gsheets.SheetsDB(cfg.TOKEN_LOC, cfg.SHEET_ID)
sender = mb_sender.MBSender(api_key=config.SMS_KEY,
originator=cfg.sms.origin)
users = sdb.get_users()
print(users)
for row in users.iterrows():
print(row)
tel = row[1]["tel"]
print(tel)
sender.send_message(tel, "Test")
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 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)
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 test_members(self):
# Fresh config without API_KEY: nothing is set.
cfg = config.Config('resources/test.toml')
cfg.env.pop('TELEGRAM_API_KEY', None)
setupper = integrator.TelegramSetup(cfg, self.db)
self.assertIsNone(setupper.bot)
self.assertIsNone(setupper.processor)
self.assertIsNone(setupper.fetcher)
# Fresh config with API_KEY (mock bot sets it): everything is set.
setupper = integrator.TelegramSetup(self.config, self.db)
self.assertIsNotNone(setupper.bot)
self.assertIsNotNone(setupper.processor)
self.assertIsNotNone(setupper.fetcher)
def main(argv):
servers = {
'www': www_server.WWWServer,
'message': msg_server.MessageServer,
'backoffice': backoffice_server.BackOfficeServer,
}
service = servers.get(FLAGS.server, None)
cfg = config.Config(FLAGS.config, mode=FLAGS.mode, env_path=FLAGS.dotenv_path)
if service is not None:
service(cfg, FLAGS.port).run()
elif FLAGS.server == 'all':
processes = [mp.Process(target=cls(cfg, None).run) for cls in servers.values()]
for p in processes:
p.start()
def setUp(self):
super().setUp()
self.config = config.Config('resources/test.toml')
self.db = store.create_store_for_sqlite_db(self.config)
self.queue = MockQueue()
self.scheduler = scheduler.MessageScheduler(self.config, self.db,
self.queue)
self.admin = self.db.add_default_admin()
icuid = self.db.add_icu(self.admin, store.ICU(name='my_icu'))
self.icu = self.db.get_icu(icuid)
user = store.User(name='michel', telephone='1234')
userid = self.db.add_user_to_icu(self.admin, icuid, user)
self.user = self.db.get_user(userid)
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)
