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)