def setUpClass(cls):
FormModelDocument.registered_functions = []
cls.db_name = uniq('mangrove-test')
cls.manager = get_db_manager('http://localhost:5984/', cls.db_name)
initializer._create_views(cls.manager)
create_views(cls.manager)
question1 = UniqueIdField(unique_id_type='clinic',
name="entity_question",
code="ID",
label="What is associated entity")
question2 = TextField(name="question1_Name",
code="Q1",
label="What is your name",
defaultValue="some default value",
constraints=[TextLengthConstraint(5, 10)])
cls.project1 = Project(dbm=cls.manager,
name=project1_name,
goals="Testing",
devices=['web'],
form_code="abc",
fields=[question1, question2])
cls.project1_id = cls.project1.save()
cls.project2 = Project(dbm=cls.manager,
name=project2_name,
goals="Testing",
devices=['web'],
form_code="def",
fields=[question1, question2])
cls.project2_id = cls.project2.save()
def setUp(self):
MangroveTestCase.setUp(self)
create_views(self.manager)
self.project1 = Project(name="Test1", goals="Testing", project_type="Survey", entity_type="Clinic",
devices=['web'])
self.project1_id = self.project1.save(self.manager)
self.project2 = Project(name="Test2", goals="Testing", project_type="Survey", entity_type="Clinic",
devices=['web'])
self.project2_id = self.project2.save(self.manager)
self._create_form_model_for_project(self.project1)
def test_should_return_data_senders_without_submissions(self):
reminder_and_deadline_for_month = {
"reminders_enabled": "True",
"deadline_month": "5",
"deadline_type": "current",
"frequency_enabled": "True",
"has_deadline": "True",
"frequency_period": "month"
}
project = Project()
project.reminder_and_deadline = reminder_and_deadline_for_month
project.data_senders = ["rep1", "rep2", "rep3", "rep4", "rep5"]
dbm = Mock(spec=DatabaseManager)
with patch(
"datawinners.project.models.get_reporters_who_submitted_data_for_frequency_period") as get_reporters_who_submitted_data_for_frequency_period_mock:
with patch("datawinners.project.models.load_all_subjects_of_type") as load_all_subjects_of_type_mock:
load_all_subjects_of_type_mock.return_value = (
[{"cols": ["rep%s" % i, i], "short_code": "rep%s" % i} for i in
range(
10)], ["short_code", "mobile_number"],
["What is DS Unique ID", "What is DS phone number"])
get_reporters_who_submitted_data_for_frequency_period_mock.return_value = [
self._create_reporter_entity("rep1"), self._create_reporter_entity("rep3")]
data_senders = project.get_data_senders_without_submissions_for(date(2011, 11, 5), dbm)
self.assertEqual(3, len(data_senders))
self.assertIn("rep2", [ds["short_code"] for ds in data_senders])
self.assertIn("rep4", [ds["short_code"] for ds in data_senders])
self.assertIn("rep5", [ds["short_code"] for ds in data_senders])
def test_get_correct_web_submission_link(self):
request = Mock()
request.user = Mock(spec=User)
manager = Mock(spec=DatabaseManager)
manager.database = dict()
raw_project = dict(
value=dict(_id="pid",
devices=["sms", "web"],
activity_report=["no"],
name="Project Name",
created="2012-05-23T02:57:09.788294+00:00",
project_type="survey"))
project = Project(project_type="survey",
entity_type="clinic",
state=ProjectState.ACTIVE)
profile = Mock(spec=NGOUserProfile)
questionnaire = Mock()
questionnaire.form_code = "q01"
with patch("datawinners.project.models.Project.load") as get_project:
get_project.return_value = project
with patch.object(DatabaseManager, "get") as db_manager:
db_manager.return_value = questionnaire
with patch("django.contrib.auth.models.User.get_profile"
) as get_profile:
get_profile.return_value = profile
profile.reporter = False
project_info = get_project_info(manager, raw_project)
self.assertEqual(project_info["web_submission_link"],
"/project/testquestionnaire/pid/")
def _initialize(self, project_id):
self.manager = None
self.project = self.project = Project(entity_type="someTest")
self.is_data_sender = True
self.disable_link_class, self.hide_link_class = None, None
self.form_code = None
self.form_model = None
def test_project_name_should_be_case_insensitively_unique(self):
project = Project(name="tEsT2",
goals="Testing",
project_type="Survey",
entity_type="Clinic",
devices=['web'])
with self.assertRaises(DataObjectAlreadyExists):
project.save(self.dbm)
def setUp(self):
self.dbm = get_db_manager(database='mangrove-test')
create_views(self.dbm)
self.project1 = Project(name="Test1",
goals="Testing",
project_type="Survey",
entity_type="Clinic",
devices=['web'])
self.project1_id = self.project1.save(self.dbm)
self.project2 = Project(name="Test2",
goals="Testing",
project_type="Survey",
entity_type="Clinic",
devices=['web'])
self.project2_id = self.project2.save(self.dbm)
self._create_form_model_for_project(self.project1)
def test_should_create_subject_field(self):
self.dbm.database.view = Mock(return_value=Mock(rows=[{"key":(0,"cli1"),"value":"Clinic One"}]))
entity_field = UniqueIdField("","reporting on", "rep_on", "rep", instruction="")
project = Project(self.dbm, 'some form', 'some', 'form_code_1', fields=[entity_field])
subject_field_creator = Mock(spec=SubjectQuestionFieldCreator)
mock_field = Mock()
subject_field_creator.create.return_value = mock_field
form = SurveyResponseForm(project, None, True)
self.assertEquals(form.fields["rep_on"].choices, [('cli1', 'Clinic One(cli1)')])
def test_project_name_should_be_case_insensitively_unique(self):
questionnaire = Project(self.manager,
name=project2_name.upper(),
goals="Testing",
devices=['web'])
with self.assertRaises(Exception) as cm:
questionnaire.save()
the_exception = cm.exception
self.assertEqual(
the_exception.message,
"Questionnaire with Name = '%s' already exists." %
project2_name.upper())
def test_get_deadline_day(self):
reminder_and_deadline_for_month = {
"reminders_enabled": "True",
"deadline_month": "5",
"deadline_type": "current",
"frequency_enabled": "True",
"has_deadline": "True",
"frequency_period": "month"
}
project_reminders = Project(self.manager, name="ReminderProject")
project_reminders.reminder_and_deadline = reminder_and_deadline_for_month
self.assertEquals(5, project_reminders.get_deadline_day())
def test_project_name_should_be_unique(self):
questionnaire = Project(dbm=self.manager,
name=project2_name,
goals="Testing",
devices=['web'],
form_code="name_form",
fields=[])
with self.assertRaises(Exception) as cm:
questionnaire.save()
the_exception = cm.exception
self.assertEqual(
the_exception.message,
"Questionnaire with Name = '%s' already exists." % project2_name)
def test_should_deactivate_form_on_project_deactivate(self):
project = Project(state=ProjectState.ACTIVE)
dbm = Mock(spec=DatabaseManager)
form_model_mock = Mock(spec=FormModel)
dbm.get.return_value = form_model_mock
with patch("datawinners.project.models.Project.save") as project_save_mock:
project.deactivate(dbm)
form_model_mock.deactivate.assert_called_once_with()
form_model_mock.save.assert_called_once_with()
project_save_mock.assert_called_once_with(dbm)
self.assertEqual(ProjectState.INACTIVE, project.state)
def create_profile(request):
manager = get_database_manager(request)
entity_list = get_all_entity_types(manager)
entity_list = helper.remove_reporter(entity_list)
project_summary = dict(name='New Project')
if request.method == 'GET':
form = ProjectProfile(entity_list=entity_list,
initial={'activity_report': 'yes'})
return render_to_response('project/profile.html', {
'form': form,
'project': project_summary,
'edit': False
},
context_instance=RequestContext(request))
form = ProjectProfile(data=request.POST, entity_list=entity_list)
if form.is_valid():
entity_type = form.cleaned_data['entity_type']
project = Project(name=form.cleaned_data["name"],
goals=form.cleaned_data["goals"],
project_type=form.cleaned_data['project_type'],
entity_type=entity_type,
devices=form.cleaned_data['devices'],
activity_report=form.cleaned_data['activity_report'],
sender_group=form.cleaned_data['sender_group'])
form_model = helper.create_questionnaire(post=form.cleaned_data,
dbm=manager)
try:
pid = project.save(manager)
qid = form_model.save()
project.qid = qid
pid = project.save(manager)
except DataObjectAlreadyExists as e:
messages.error(request, e.message)
return render_to_response('project/profile.html', {
'form': form,
'project': project_summary,
'edit': False
},
context_instance=RequestContext(request))
return HttpResponseRedirect(reverse(subjects_wizard, args=[pid]))
else:
return render_to_response('project/profile.html', {
'form': form,
'project': project_summary,
'edit': False
},
context_instance=RequestContext(request))
def test_should_get_correct_template_for_data_sender(self):
request = Mock()
request.user = Mock(spec=User)
manager = Mock(spec=DatabaseManager)
manager.database = dict()
project = Project(project_type="survey",
entity_type="clinic",
state=ProjectState.ACTIVE)
with patch.object(FormModel, "get") as get_form_model:
get_form_model.return_value = {}
is_data_sender = True
subject = False
form_model, template = get_form_model_and_template(
manager, project, is_data_sender, subject)
self.assertEquals(template, "project/data_submission.html")
def test_create_entity_list_for_reporters(self):
with patch(
"datawinners.project.questionnaire_fields.EntityField._data_sender_choice_fields"
) as ds_choice_fields:
choices = ChoiceField(choices=[('rep1', 'ashwin'), ('rep2',
'pooja')])
ds_choice_fields.return_value = choices
project = Project(entity_type="reporter")
subject_field = EntityField(Mock(spec=DatabaseManager), project)
question_field = Mock(spec=TextField)
question_code = PropertyMock(return_value="eid")
type(question_field).code = question_code
result_field = subject_field.create(question_field, 'reporter')
self.assertEquals(result_field.get('eid'), choices)
def test_get_associated_data_senders(self):
entity = Entity(self.manager,
entity_type=["reporter"],
short_code="rep1")
entity_id = entity.save()
project = Project(dbm=self.manager,
name="TestDS",
goals="Testing",
devices=['web'],
form_code="ds_form",
fields=[])
project.data_senders = ["rep1"]
project.save()
result = project.get_associated_datasenders(self.manager)
self.assertEquals(result[0].short_code, entity.short_code)
self.assertEquals(result[0].id, entity_id)
def test_create_entity_list_for_subjects(self):
with patch(
"datawinners.project.questionnaire_fields.EntityField._subject_choice_fields"
) as subject_choice_fields:
choices = ChoiceField(
choices=[('sub1', 'one_subject'), ('sub2', 'another_subject')])
subject_choice_fields.return_value = choices
project = Project(entity_type="some_subject")
subject_field = EntityField(Mock(spec=DatabaseManager), project)
question_field = Mock(spec=TextField)
question_code = PropertyMock(return_value="eid")
type(question_field).code = question_code
result_field = subject_field.create(question_field, 'some_subject')
self.assertEquals(result_field.get('eid'), choices)
def get_web_preview_context(manager, post, project_info):
form_model = get_questionnaire_form_model(manager, project_info, post)
project = Project(name=unicode(project_info['name']),
goals=unicode(project_info['goals']),
project_type='survey',
entity_type=unicode(project_info['entity_type']),
activity_report=unicode(project_info['activity_report']),
state=post['project_state'],
devices=[u'sms', u'web', u'smartPhone'],
language=unicode(project_info['language']))
questionnaire_form = SurveyResponseForm(
form_model, SubjectQuestionFieldCreator(manager, project))
return {
'project': project_info,
'questionnaire_form': questionnaire_form,
'add_link': add_link_context(project),
}
def create_questionnaire(post, manager, name, language, reporter_id):
questionnaire_code = post['questionnaire-code'].lower()
datasenders = json.loads(post.get('datasenders', "[]"))
json_string = post['question-set']
question_set = json.loads(json_string)
questionnaire = Project(manager,
name=name,
fields=[],
form_code=questionnaire_code,
language=language,
devices=[u'sms', u'web', u'smartPhone'])
if reporter_id is not None:
questionnaire.data_senders.append(reporter_id)
if datasenders:
questionnaire.data_senders.extend(
filter(lambda ds: ds != reporter_id, datasenders))
QuestionnaireBuilder(questionnaire, manager)\
.update_questionnaire_with_questions(question_set)\
.update_reminder(json.loads(post.get('reminder_and_deadline', '{}')))
return questionnaire
def test_should_get_changed_data_when_project_is_edited(self):
project_info = {'name':'changed name','language':'en'}
project = Project(dbm=Mock(spec= DatabaseManager), name='old name', language='en',
form_code="change_form", fields=[])
changed_dict = _get_changed_data(project,project_info)
self.assertDictEqual({'Name':'changed name'},changed_dict)
def test_project_name_should_be_case_insensitively_unique(self):
project = Project(name="tEsT2", goals="Testing", project_type="Survey", entity_type="Clinic", devices=['web'])
with self.assertRaises(Exception) as cm:
project.save(self.manager)
the_exception = cm.exception
self.assertEqual(the_exception.message, "Project with Name = 'test2' already exists.")
def create_clinic_projects(CLINIC_ENTITY_TYPE, manager):
name_type = create_data_dict(manager,
name='Name',
slug='Name',
primitive_type='string')
# Entity id is a default type in the system.
entity_id_type = get_datadict_type_by_slug(manager, slug='entity_id')
age_type = create_data_dict(manager,
name='Age Type',
slug='age',
primitive_type='integer')
date_type = create_data_dict(manager,
name='Report Date',
slug='date',
primitive_type='date')
select_type = create_data_dict(manager,
name='Choice Type',
slug='choice',
primitive_type='select')
geo_code_type = create_data_dict(manager,
name='GeoCode Type',
slug='geo_code',
primitive_type='geocode')
question1 = TextField(label="entity_question",
code="EID",
name="What is associated entity?",
language="eng",
entity_question_flag=True,
ddtype=entity_id_type,
length=TextConstraint(min=1, max=12))
question2 = TextField(label="Name",
code="NA",
name="What is your name?",
length=TextConstraint(min=1, max=10),
defaultValue="some default value",
language="eng",
ddtype=name_type)
question3 = IntegerField(label="Father age",
code="FA",
name="What is age of father?",
range=NumericConstraint(min=18, max=100),
ddtype=age_type)
question4 = DateField(label="Report date",
code="RD",
name="What is reporting date?",
date_format="dd.mm.yyyy",
ddtype=date_type)
question5 = SelectField(label="Blood Group",
code="BG",
name="What is your blood group?",
options=[("O+", "a"), ("O-", "b"), ("AB", "c"),
("B+", "d")],
single_select_flag=True,
ddtype=select_type)
question6 = SelectField(label="Symptoms",
code="SY",
name="What are symptoms?",
options=[("Rapid weight loss", "a"),
("Dry cough", "b"), ("Pneumonia", "c"),
("Memory loss", "d"),
("Neurological disorders ", "e")],
single_select_flag=False,
ddtype=select_type)
question7 = GeoCodeField(name="What is the GPS code for clinic",
code="GPS",
label="What is the GPS code for clinic?",
language="eng",
ddtype=geo_code_type)
form_model = FormModel(manager,
name="AIDS",
label="Aids form_model",
form_code="cli001",
type='survey',
fields=[
question1, question2, question3, question4,
question5, question6, question7
],
entity_type=CLINIC_ENTITY_TYPE)
try:
qid = form_model.save()
except DataObjectAlreadyExists as e:
get_form_model_by_code(manager, "cli001").delete()
qid = form_model.save()
project = Project(name="Clinic Test Project",
goals="This project is for automation",
project_type="survey",
entity_type=CLINIC_ENTITY_TYPE[-1],
devices=["sms"],
activity_report='no',
sender_group="close")
project.qid = qid
project.state = ProjectState.ACTIVE
try:
project.save(manager)
except Exception:
pass
form_model2 = FormModel(manager,
name="AIDS",
label="Aids form_model",
form_code="cli002",
type='survey',
fields=[
question1, question2, question3, question4,
question5, question6, question7
],
entity_type=CLINIC_ENTITY_TYPE)
try:
qid2 = form_model2.save()
except DataObjectAlreadyExists as e:
get_form_model_by_code(manager, "cli002").delete()
qid2 = form_model2.save()
project2 = Project(name="Clinic2 Test Project",
goals="This project is for automation",
project_type="survey",
entity_type=CLINIC_ENTITY_TYPE[-1],
devices=["sms"],
activity_report='no',
sender_group="close")
project2.qid = qid2
project2.state = ProjectState.ACTIVE
try:
project2.save(manager)
except Exception:
pass
def create_project(request):
manager = get_database_manager(request.user)
entity_list = get_all_entity_types(manager)
entity_list = helper.remove_reporter(entity_list)
all_projects_name = get_all_project_names(get_database_manager(request.user))
name = generate_project_name(all_projects_name)
project_summary = dict(name=name)
ngo_admin = NGOUserProfile.objects.get(user=request.user)
if request.method == 'GET':
form = CreateProject(entity_list=entity_list, initial={'name': name})
activity_report_questions = json.dumps(helper.get_activity_report_questions(manager), default=field_to_json)
subject_report_questions = json.dumps(helper.get_subject_report_questions(manager), default=field_to_json)
return render_to_response('project/create_project.html',
{'form': form, "activity_report_questions": repr(activity_report_questions),
'subject_report_questions': repr(subject_report_questions),
'preview_links': get_preview_and_instruction_links(),
'existing_questions': repr(activity_report_questions), 'project': project_summary,
'questionnaire_code': helper.generate_questionnaire_code(manager),
'is_edit': 'false',
'post_url': reverse(create_project)}, context_instance=RequestContext(request))
if request.method == 'POST':
project_info = json.loads(request.POST['profile_form'])
form = CreateProject(entity_list, data=project_info)
if form.is_valid():
project = Project(name=form.cleaned_data['name'], goals=form.cleaned_data['goals'],
project_type='survey', entity_type=form.cleaned_data['entity_type'],
activity_report=form.cleaned_data['activity_report'],
state=request.POST['project_state'], devices=[u'sms', u'web', u'smartPhone'],
language=form.cleaned_data['language'])
if ngo_admin.reporter_id is not None:
project.data_senders.append(ngo_admin.reporter_id)
try:
questionnaire = create_questionnaire(post=request.POST, manager=manager,
entity_type=form.cleaned_data['entity_type'],
name=form.cleaned_data['name'],
language=form.cleaned_data['language'])
except (QuestionCodeAlreadyExistsException, QuestionAlreadyExistsException,
EntityQuestionAlreadyExistsException) as ex:
return HttpResponse(
json.dumps({'success': False, 'error_message': _(ex.message), 'error_in_project_section': False}))
try:
project.qid = questionnaire.save()
except DataObjectAlreadyExists:
return HttpResponse(json.dumps(
{'success': False, 'error_message': "Questionnaire with this code already exists",
'error_in_project_section': False}))
try:
project.save(manager)
UserActivityLog().log(request, action=CREATED_PROJECT, project=project.name, detail=project.name)
except DataObjectAlreadyExists as ex:
questionnaire.delete()
message = _("%s with %s = %s already exists.") % (_(ex.data[2]), _(ex.data[0]), "'%s'" % project.name)
return HttpResponse(
json.dumps({'success': False, 'error_message': message, 'error_in_project_section': True}))
return HttpResponse(json.dumps({'success': True, 'project_id': project.id}))
def test_should_not_create_subject_fields_if_entity_field_is_not_present_in_form_model(self):
form_model = Project(self.dbm, 'some form', 'some', 'form_code_1', fields=[])
form = SurveyResponseForm(form_model, data=None, is_datasender=True)
self.assertIsNone(form.fields.get('entity_question_code'))
