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)
