def test_newest_returns_newest_record_by_id_desc(self): user1 = User(id=1) user2 = User(id=2) with transaction.manager: DBSession.add_all([user1, user2]) user = User.newest() self.assertEqual(user.id, 2)
def setUp(self): super(TestMunicipalityViews, self).setUp() self.request = testing.DummyRequest() self._create_user('municipality-manager') with transaction.manager: reporting_period = ReportingPeriod( title='Period 1', start_date=datetime.datetime(2015, 5, 1), end_date=datetime.datetime(2015, 7, 31)) reporting_period.save() municipality = Municipality(name="Brasillia") DBSession.add(municipality) for i in range(5): clinic = Clinic(name="Clinic {}".format(i), code="{}BCDE".format(i), municipality=municipality) DBSession.add(clinic) self.request.user = OnaUser.get( OnaUser.username == 'municipality-manager').user self.view = MunicipalityViews(self.request)
def setUp(self): super(TestStateViews, self).setUp() self.request = testing.DummyRequest() self._create_user('state-official') with transaction.manager: reporting_period = ReportingPeriod( title='Period 1', start_date=datetime.datetime(2015, 5, 1), end_date=datetime.datetime(2015, 7, 31)) reporting_period.save() state = State(name="Sao Paolo") municipality1 = Municipality(name="Brasillia", parent=state) municipality2 = Municipality(name="Brasil", parent=state) DBSession.add_all([state, municipality1, municipality2]) for i in range(5): clinic = Clinic(name="Clinic {}".format(i), code="{}BCDE".format(i), municipality=municipality1) DBSession.add(clinic) self.request.user = OnaUser.get( OnaUser.username == 'state-official').user self.view = StateViews(self.request)
def reset_all_clinics(): # delete all Clinics user_clinics.delete().where( user_clinics.columns.clinic_id.in_(Clinic.all())) with transaction.manager: for cs in Clinic.all(): DBSession.delete(cs)
def setUp(self): super(TestStateViewsFunctional, self).setUp() with transaction.manager: state = State(name="Sao Paolo") municipality1 = Municipality(name="Brasillia", parent=state) municipality2 = Municipality(name="Brasil", parent=state) user_group = Group(name="state_official") user = User() user.group = user_group user.location = state ona_user = OnaUser(username="******", user=user, refresh_token="1239khyackas") ona_user.save() reporting_period = ReportingPeriod( title='Period 1', start_date=datetime.datetime(2015, 5, 1), end_date=datetime.datetime(2015, 7, 31)) reporting_period.save() DBSession.add_all([state, municipality1, municipality2])
def parse_municipalities_from_submissions(): submissions = Submission.all() for submission in submissions: try: with transaction.manager: clinic_code = submission.raw_data[constants.CLINIC_IDENTIFIER] clinic = Clinic.get(Clinic.code == clinic_code) state_name = submission.raw_data[constants.STATE_IDENTIFIER] municipality_name = submission.raw_data[ constants.MUNICIPALITY_IDENTIFIER] state_params = {'name': state_name} state = State.get_or_create(State.name == state_name, **state_params) municipality_params = {'name': municipality_name} municipality = Municipality.get_or_create( Municipality.name == municipality_name, **municipality_params) municipality.state = state if clinic.municipality is None: clinic.municipality = municipality DBSession.add_all([municipality, clinic]) except (NoResultFound, KeyError): pass
def main(argv=sys.argv): if len(argv) != 5: usage(argv) config_uri = argv[1] setup_logging(config_uri) pwd_context.load_path(config_uri) settings = get_appsettings(config_uri) engine = engine_from_config(settings, 'sqlalchemy.') DBSession.configure(bind=engine) Base.metadata.create_all(engine) username = argv[2] password = argv[3] group = argv[4] with transaction.manager: group_criteria = Group.name == group group_params = {'name': group} group = Group.get_or_create( group_criteria, **group_params) user = User() user.group = group profile = UserProfile( user=user, username=username, password=password) ona_user_params = { 'user': user, 'username': username, 'refresh_token': 'test'} ona_user = OnaUser.get_or_create( OnaUser.username == username, **ona_user_params) DBSession.add_all([user, profile, ona_user])
def setup_reporting_periods(self): self.reporting_period1 = ReportingPeriod( title="test 1", form_xpath="jan_2015feb_2015", start_date=datetime.date(2015, 1, 1), end_date=datetime.date(2015, 2, 1)) self.reporting_period2 = ReportingPeriod( title="test 2", form_xpath="feb_2015mar_2015", start_date=datetime.date(2015, 2, 1), end_date=datetime.date(2015, 3, 1)) self.reporting_period3 = ReportingPeriod( title="test 3", form_xpath="apr_2015may_2015", start_date=datetime.date(2015, 4, 1), end_date=datetime.date(2015, 5, 1)) self.reporting_period_v3 = ReportingPeriod( title="test 4", form_xpath="2017", start_date=datetime.date(2017, 1, 1), end_date=datetime.date(2017, 12, 31)) DBSession.add_all([self.reporting_period1, self.reporting_period2, self.reporting_period3, self.reporting_period_v3])
def delete(self): clinic = self.request.context DBSession.delete(clinic) self.request.session.flash(_(u"Clinic successfully deleted"), "success") return HTTPFound( location=self.request.route_url('clinics', traverse=('manage')))
def test_json_post_with_valid_clinic_id(self): clinic = Clinic(code='1A2B', name="Clinic A") DBSession.add(clinic) response = self.post_json(self.submissions[0]) # should return a 201 response code self.assertEqual(response.status_code, 201) self.assertEqual(response.body, 'Saved')
def test_assign_to_user(self): self.setup_test_data() user = OnaUser.get(OnaUser.username == 'manager_a').user clinic = Clinic.get(Clinic.name == "Clinic B") clinic.assign_to(user) user = DBSession.merge(user) clinic = DBSession.merge(clinic) self.assertEqual(clinic.user, user)
def test_password_login_with_bad_password(self): profile = UserProfile(user=User(), username="******", password="******") DBSession.add(profile) payload = MultiDict([('username', 'admin'), ('password', 'adminn0t')]) request = testing.DummyRequest(post=payload) response = password_login(None, request) self.assertIsInstance(response, dict) self.assertTrue(len(request.session.peek_flash('error')) > 0)
def test_json_post_with_invalid_clinic_id(self): clinic = Clinic(code='1A2B', name="Clinic A") DBSession.add(clinic) response = self.post_json(self.submissions[5]) # should return a 202 response code self.assertEqual(response.status_code, 202) self.assertEqual(response.body, 'Accepted pending manual matching process')
def test_password_login(self): # create the user profile profile = UserProfile(user=User(), username="******", password="******") DBSession.add(profile) payload = MultiDict([('username', 'admin'), ('password', 'admin')]) request = testing.DummyRequest(post=payload) response = password_login(None, request) self.assertEqual(response.status_code, 302) self.assertEqual(response.location, request.route_url('default'))
def delete(self): period = self.request.context if not period.reports: DBSession.delete(period) self.request.session.flash( _(u"Reporting period successfully deleted"), "success") else: self.request.session.flash( _(u"Cannot delete reporting period with data"), "error") return HTTPFound(self.request.route_url('periods', traverse=('list')))
def oauth_callback(request): # check if we have `error` in our params, meaning user canceled if 'error' in request.GET: # redirect to login page with an alert request.session.flash(u"You must select authorize to continue", 'error') return HTTPFound(request.route_url('auth', action='login')) # TODO: validate the `oauth_state` session base_url = request.registry.settings['oauth_base_url'] state = request.GET.get('state') client_id = request.registry.settings['oauth_client_id'] client_secret = request.registry.settings['oauth_secret'] token_url = "{base_url}{path}".format( base_url=base_url, path=request.registry.settings['oauth_token_path']) redirect_uri = request.route_url('auth', action='callback') session = OAuth2Session(client_id, state=state, redirect_uri=redirect_uri) code = request.GET.get('code') token = session.fetch_token(token_url, client_secret=client_secret, code=code) # retrieve username and store in db if it doesnt exist yet user_api_url = "{base_url}{path}".format( base_url=base_url, path=request.registry.settings['oauth_user_api_path']) response = session.request('GET', user_api_url) try: user_data = json.loads(response.text) except ValueError: # couldn't decode json pass else: refresh_token = token['refresh_token'] try: ona_user = OnaUser.get_or_create_from_api_data( user_data, refresh_token) except ValueError: pass else: request.session['oauth_token'] = json.dumps(token) # flash to get the auto-inc id DBSession.flush() user_id = ona_user.user.id # login user headers = remember(request, user_id) # TODO: redirect to `came_from` url return HTTPFound(request.route_url('default'), headers=headers) request.session.flash(u"Failed to login, please try again", 'error') return HTTPFound(request.route_url('auth', action='login'))
def main(argv=sys.argv): if len(argv) != 2: usage(argv) config_uri = argv[1] setup_logging(config_uri) settings = get_appsettings(config_uri) engine = engine_from_config(settings, 'sqlalchemy.') DBSession.configure(bind=engine) Base.metadata.create_all(engine) import_health_data()
def main(argv=sys.argv): if len(argv) != 2: usage(argv) config_uri = argv[1] setup_logging(config_uri) settings = get_appsettings(config_uri) engine = engine_from_config(settings, 'sqlalchemy.') DBSession.configure(bind=engine) Base.metadata.create_all(engine) parse_municipalities_from_submissions()
def main(argv=sys.argv): if len(argv) != 2: usage(argv) config_uri = argv[1] setup_logging(config_uri) settings = get_appsettings(config_uri) engine = engine_from_config(settings, 'sqlalchemy.') DBSession.configure(bind=engine) Base.metadata.create_all(engine) with transaction.manager: user = User() DBSession.add_all([user])
def test_get_item_returns_reporting_period(self): self.setup_test_data() period = ReportingPeriod(title="2013/2014", start_date=datetime.datetime(2013, 3, 13), end_date=datetime.datetime(2014, 3, 13)) DBSession.add(period) DBSession.flush() period = ReportingPeriod.newest() user = User.newest() selected_period = user.__getitem__(period.id) self.assertIsInstance(selected_period, ReportingPeriod) self.assertEqual(selected_period, period)
def delete(self): user = self.request.context if self.request.user == user: self.request.session.flash(_(u"You cannot delete yourself"), "error") return HTTPFound(self.request.route_url('admin', traverse=())) DBSession.delete(user) self.request.session.flash(_(u"User successfully deleted"), "success") return HTTPFound(self.request.route_url('admin', traverse=()))
def delete(self): location = self.request.context if not location.children(): DBSession.delete(location) self.request.session.flash( _("Location deleted successfully"), 'success') else: self.request.session.flash( _("Cannot delete location with Children"), 'error') return HTTPFound( self.request.route_url('locations', traverse=('')))
def test_get_item_retrieves_by_id(self): period = ReportingPeriod(title="2014/2015", start_date=datetime.date(2014, 2, 1), end_date=datetime.date(2015, 2, 1)) DBSession.add(period) DBSession.flush() id = period.id factory = ReportingPeriodFactory(testing.DummyRequest()) period = factory.__getitem__(id) self.assertEqual(period.id, id) self.assertEqual(period.__parent__, factory) self.assertEqual(period.__name__, id)
def test_save_submission_with_valid_clinic_id(self): # create clinic with matching id clinic_code = "1A2B" clinic = Clinic(code=clinic_code, name="Clinic A") DBSession.add(clinic) payload = self.submissions[0] submission = Submission(raw_data=json.loads(payload)) count = ClinicSubmission.count() ClinicReportHandler(submission).handle_submission() # check that a clinic_submission record was created self.assertEqual(ClinicSubmission.count(), count + 17)
def test_save_submission_with_multiple_characteristics(self): # create clinic with matching id clinic_code = "1A2B" clinic = Clinic(code=clinic_code, name="Clinic A") DBSession.add(clinic) # check current counts count = ClinicSubmission.count() payload = self.submissions[2] submission = Submission(raw_data=json.loads(payload)) ClinicReportHandler(submission).handle_submission() # check that 17 clinic_submission record was created self.assertEqual(ClinicSubmission.count(), count + 17)
def main(global_config, **settings): """ This function returns a Pyramid WSGI application. """ engine = engine_from_config(settings, 'sqlalchemy.') DBSession.configure(bind=engine) Base.metadata.bind = engine session_factory = SignedCookieSessionFactory( settings['secret_key']) config = Configurator(settings=settings, root_factory='whoahqa.models.RootFactory', session_factory=session_factory) config.set_authentication_policy( AuthTktAuthenticationPolicy(settings['secret_key'], callback=group_finder, hashalg='sha512')) config.set_authorization_policy(ACLAuthorizationPolicy()) config.set_default_permission(perms.AUTHENTICATED) # Add custom renderers config.add_renderer('csv', 'whoahqa.renderers.CSVRenderer') # Add request object helpers add_request_helpers(config) # setup the hashid salt hashid._salt = settings['hashid_salt'] # add locale directory to project configuration config.add_translation_dirs('whoahqa:locale') # configure enketo enketo.configure( settings['enketo_url'], settings['enketo_api_token']) logging.config.fileConfig( global_config['__file__'], disable_existing_loggers=False) # configure password context pwd_context.load_path(global_config['__file__']) includeme(config) if settings.get("environment", "") == DEVELOPMENT_ENV: setup_development_data() return config.make_wsgi_app()
def push_facilities(request): states = DBSession.query(State).order_by("name asc").all() header = ['CNES', 'state', 'municipality', 'facility_name'] rows = [] for state in states: municipalities = state.children() for municipality in municipalities: clinics = municipality.children() for clinic in clinics: if clinic is not None: clinic_name = normalizeString(clinic.name) clinic_cnes = clinic.code municipality_name = normalizeString(municipality.name) state_name = normalizeString(state.name) rows.append([ clinic_cnes, fmt(state_name), fmt(municipality_name), fmt(clinic_name) ]) filename = 'clinics.csv' request.response.content_disposition = 'attachment;filename=' + filename return {'header': header, 'rows': rows}
def test_create_clinic_from_submission(self): # create user with matching id DBSession.add(User()) user = User.newest() payload = self.clinic_registrations[0] raw_data = json.loads(payload) raw_data[constants.USER_ID] = user.id submission = Submission(raw_data=raw_data) count = Clinic.count() ClinicRegistrationHandler(submission).handle_submission() # check that a clinic_submission record was created self.assertEqual(Clinic.count(), count + 1) clinic = Clinic.newest() self.assertEqual(clinic.code, '1A2B')
def get_active_periods(cls): # today = get_current_date() # return DBSession.query(ReportingPeriod).filter( # ReportingPeriod.start_date <= today).order_by( # "start_date desc").all() return DBSession.query(ReportingPeriod).order_by( "start_date asc").all()
def test_create_submission_from_json(self): # create clinic with matching id clinic_code = "1A2B" clinic = Clinic(code=clinic_code, name="Clinic A") DBSession.add(clinic) # check current counts count = Submission.count() clinic_submission_count = ClinicSubmission.count() payload = self.submissions[0] Submission.create_from_json(payload) submission = Submission.newest() self.assertEqual(Submission.count(), count + 1) self.assertEqual(submission.raw_data, json.loads(payload)) # check that a clinic_submission record was created self.assertEqual(ClinicSubmission.count(), clinic_submission_count + 17)