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)