def test_get_active_characteristics_filters_by_period(self):
self.setup_test_data()
period_1 = ReportingPeriod.get(ReportingPeriod.title == 'Period 1')
clinic_a = Clinic.get(Clinic.name == 'Clinic A')
period2 = ReportingPeriod(
title='Period 2',
start_date=datetime.datetime(2014, 1, 1),
end_date=datetime.datetime(2014, 1, 1))
DBSession.add(period2)
DBSession.flush()
clinic_char1 = ClinicCharacteristics(
clinic_id=clinic_a.id,
characteristic_id='one',
period_id=period_1.id)
clinic_char2 = ClinicCharacteristics(
clinic_id=clinic_a.id,
characteristic_id='one',
period_id=period2.id)
DBSession.add_all([clinic_char1, clinic_char2])
characteristics = clinic_a.get_active_characteristics(period_1)
self.assertEqual(len(characteristics), 1)
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 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_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_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 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_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 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_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_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 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 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)
def test_check_if_submission_exists(self):
# create a 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()
_submission = self.submissions[1]
if type(_submission) is not dict:
payload = json.loads(_submission)
if Submission.exists(payload):
submission = Submission.newest()
self.assertEqual(Submission.count(), count)
self.assertEqual(ClinicSubmission.count(), clinic_submission_count)
self.assertIsInstance(submission, Submission)
def get_or_create_from_api_data(cls, user_data, refresh_token):
username = user_data.get('username', "")
if username is None or (not username.strip()):
raise ValueError("Invalid user profile data")
username = user_data['username']
try:
ona_user = OnaUser.get(OnaUser.username == username)
ona_user.refresh_token = refresh_token
except NoResultFound:
# By Default, all new users are in the user group
group_criteria = Group.name == groups.USER
group_params = {'name': groups.USER}
user_group = Group.get_or_create(group_criteria, **group_params)
user = User()
user.group = user_group
ona_user = OnaUser(username=username, refresh_token=refresh_token)
ona_user.user = user
DBSession.add(ona_user)
return ona_user
def create_from_json(cls, payload):
# TODO: check for and handle json.loads parse errors
if type(payload) is not dict:
payload = json.loads(payload)
submission = None
if payload.get(constants.DEPRECATED_ID, None):
# add or update existing submission
try:
submission = Submission.get(
Submission.raw_data[constants.INSTANCE_ID].astext ==
payload[constants.DEPRECATED_ID])
submission.raw_data = payload
DBSession.add(submission)
except NoResultFound:
submission = Submission(raw_data=payload)
DBSession.add(submission)
elif not Submission.exists(payload):
submission = Submission(raw_data=payload)
DBSession.add(submission)
handler_class = determine_handler_class(
submission, cls.HANDLER_TO_XFORMS_MAPPING)
handler_class(submission).handle_submission()
return submission
def create(self):
form = Form(ReportingPeriodForm().bind(),
buttons=('Save', ),
css_class='form-horizontal')
if self.request.method == "POST":
post = self.request.POST.items()
try:
payload = form.validate(post)
except ValidationFailure:
pass
else:
if payload['form_xpath'] not in ALLOWED_XPATHS and \
valid_year(payload['form_xpath']) is None:
self.request.session.flash(
_(u"Only numeric values 1-5 and calendar "
"years (YYYY) allowed For Form Xpath"), 'error')
elif DBSession.query(ReportingPeriod).filter_by(
form_xpath=payload['form_xpath']).first():
self.request.session.flash(_(u"Form Xpath Exists"),
'error')
else:
period = ReportingPeriod(title=payload['title'],
form_xpath=payload['form_xpath'],
start_date=payload['start_date'],
end_date=payload['end_date'])
DBSession.add(period)
DBSession.flush()
self.request.session.flash(_(u"Reporting period created"),
'success')
return HTTPFound(
self.request.route_url('periods', traverse=('list')))
# render form
return {'form': form, 'period': ReportingPeriod.get_current_period()}
def import_health_data():
file_name = os.path.relpath('whoahqa/data/clinics.csv')
with open(file_name, 'rU') as source:
rdr = UnicodeDictReader(source)
existing_states = [
normalizeString(state.name) for state in State.all()
]
existing_municipalities = [
normalizeString(municipality.name)
for municipality in Municipality.all()
]
existing_clinics = [clinic.code for clinic in Clinic.all()]
with transaction.manager:
for row in rdr:
state = None
municipality = None
normalized_state = normalizeString(row['state'])
normalized_municipality = normalizeString(row['municipality'])
if normalized_state not in existing_states:
existing_states.append(normalized_state)
state = State(name=normalized_state)
DBSession.add(state)
if normalized_municipality not in existing_municipalities:
existing_municipalities.append(normalized_municipality)
if state is None:
state = State.get(State.name == normalized_state)
municipality = Municipality(name=normalized_municipality,
parent=state)
DBSession.add(municipality)
if row['CNES'] not in existing_clinics:
# import ipdb; ipdb.set_trace()
existing_clinics.append(row['CNES'])
if municipality is None:
municipality = Municipality.get(
Municipality.name == normalized_municipality)
clinic = Clinic(name=row['facility_name'],
code=row['CNES'],
municipality=municipality)
DBSession.add(clinic)
def assign_to(self, user):
self.user = user
DBSession.add(self)
def test_get_returns_record_filtered_by_criterion(self):
user = User(id=1)
with transaction.manager:
DBSession.add(user)
user = User.get(User.id == 1)
self.assertIsInstance(user, User)
def activate_characteristic(self, characteristic_id, period_id):
clinic_characteristic = ClinicCharacteristics(
clinic_id=self.id,
characteristic_id=characteristic_id,
period_id=period_id)
DBSession.add(clinic_characteristic)
