def create_type(request):
success = False
form = EntityTypeForm(request.POST)
if form.is_valid():
entity_name = form.cleaned_data["entity_type_regex"]
entity_name = [entity_name.strip().lower()]
try:
manager = get_database_manager(request.user)
define_type(manager, entity_name)
create_registration_form(manager, entity_name)
message = _("Entity definition successful")
success = True
UserActivityLog().log(request,
action=ADDED_SUBJECT_TYPE,
detail=entity_name[0].capitalize())
except EntityTypeAlreadyDefined:
if request.POST["referer"] == 'project':
message = _(
"%s already registered as a subject type. Please select %s from the drop down menu."
) % (entity_name[0], entity_name[0])
else:
message = _("%s already registered as a subject type.") % (
entity_name[0], )
else:
message = form.errors['entity_type_regex']
return HttpResponse(json.dumps({
'success': success,
'message': _(message)
}))
def create_type(request):
success = False
form = EntityTypeForm(request.POST)
if form.is_valid():
entity_name = form.cleaned_data["entity_type_regex"]
entity_name = [entity_name.strip().lower()]
try:
manager = get_database_manager(request.user)
if entity_type_already_defined(manager, entity_name):
raise EntityTypeAlreadyDefined(u"Type: %s is already defined" %
u'.'.join(entity_name))
create_registration_form(manager, entity_name)
define_type(manager, entity_name)
message = _("Entity definition successful")
success = True
UserActivityLog().log(request,
action=ADDED_IDENTIFICATION_NUMBER_TYPE,
project=entity_name[0].capitalize())
except EntityTypeAlreadyDefined:
message = _("%s already exists.") % (entity_name[0].capitalize(), )
else:
message = form.errors['entity_type_regex']
return HttpResponse(json.dumps({
'success': success,
'message': _(message)
}))
def test_should_import_subjects_with_form_code(self):
file_name = "reporters.csv"
request = Mock()
request.GET = {'qqfile': file_name}
request.raw_post_data = self.csv_subjects_data
organization = Mock(spec=Organization)
entity_type = "clinic"
define_type(self.manager, [entity_type])
self.create_form_for_entity_type()
with patch("datawinners.utils.get_organization_from_manager"
) as get_organization_from_dbm_mock:
get_organization_from_dbm_mock.return_value = Mock(
return_value=organization)
with patch(
"datawinners.utils.get_organization") as get_organization:
mock = Mock(return_value=organization)
mock.org_id = 'abc'
get_organization.return_value = mock
error_message, failure_imports, success_message, imported_entities = import_data(
request=request, manager=self.manager, form_code=FORM_CODE)
self.assertEqual(
4,
get_entity_count_for_type(self.manager,
entity_type=entity_type))
self.assertEqual(4, len(imported_entities))
self.assertEqual(entity_type, imported_entities["cli1"])
self.assertEqual(entity_type, imported_entities["cli2"])
self.assertEqual(entity_type, imported_entities["cli3"])
self.assertEqual(entity_type, imported_entities["cli4"])
def setUp(self):
MangroveTestCase.setUp(self)
define_type(self.manager, ["reporter"])
#Register Reporter
self.first_reporter = self.register(self.manager,
data=[(MOBILE_NUMBER_FIELD, "1234567890"),
(NAME_FIELD, "A")],
location=[],
source="sms", short_code="REP1")
self.register(self.manager,
data=[(MOBILE_NUMBER_FIELD, "8888567890"),
(NAME_FIELD, "B")],
location=[],
source="sms", short_code="rep5")
self.register(self.manager,
data=[(MOBILE_NUMBER_FIELD, "1234567890"),
(NAME_FIELD, "B")],
location=[],
source="sms", short_code="REP2")
self.register(self.manager,
data=[(MOBILE_NUMBER_FIELD, "1234567891"),
(NAME_FIELD, "C")],
location=[],
source="sms", short_code="REP3")
def create_entity_types(manager, entity_types):
for entity_type in entity_types:
try:
define_type(manager, entity_type)
activate(DEFAULT_LANGUAGE)
create_registration_form(manager, entity_type)
except EntityTypeAlreadyDefined:
pass
def test_should_delete_entity_type(self):
entity_type = ["clinic", "Clinic"]
entity_types = get_all_entity_types(self.dbm)
self.assertNotIn(entity_type, entity_types)
define_type(self.dbm, entity_type)
delete_type(self.dbm, entity_type)
types = get_all_entity_types(self.dbm)
self.assertNotIn(entity_type, types)
def build(self):
if not entity_type_already_defined(self._manager, self._entity_type):
define_type(self._manager, self._entity_type)
entity = self.create_or_update_entity(self._manager, entity_type=self._entity_type, short_code=self._short_code,
aggregation_paths=self._aggregation_paths, location=self._location, geometry=self._geometry)
for each in self._data: entity.add_data(each)
return entity
def build(self):
if not entity_type_already_defined(self._manager, self._entity_type):
define_type(self._manager, self._entity_type)
self.form_model = FormModel(self._manager, name=self._name, label=self._label,
form_code=self._form_code, fields=self._fields, is_registration_model=self._is_reg)
form_model_id = self.form_model.save()
return FormModel.get(self._manager, form_model_id)
def _create_default_dd_type(self):
self.entity_type = ["HealthFacility", "Clinic"]
define_type(self.manager, ["HealthFacility", "Clinic"])
self.default_ddtype = DataDictType(self.manager,
name='Default String Datadict Type',
slug='string_default',
primitive_type='string')
self.default_ddtype.save()
def test_should_define_entity_type(self):
entity_type = ["HealthFacility", "Clinic"]
entity_types = get_all_entity_types(self.dbm)
self.assertNotIn(entity_type, entity_types)
define_type(self.dbm, entity_type)
types = get_all_entity_types(self.dbm)
self.assertIn(entity_type, types)
self.assertIn([entity_type[0]], types)
def register_datasender(dbm):
define_type(dbm, ["reporter"])
TestReporter.register(dbm,
data=[(MOBILE_NUMBER_FIELD, "1234567890"),
(NAME_FIELD, "B")],
location=None,
source="sms",
short_code="rep2")
return get_by_short_code_include_voided(dbm, "rep2", REPORTER_ENTITY_TYPE).id
def test_should_import_subjects_with_wrong_form_code(self):
file_name = "reporters.csv"
request = Mock()
request.GET = {'qqfile': file_name}
request.raw_post_data = self.csv_subjects_data_with_error_form_code
organization = Mock(spec=Organization)
entity_type = "clinic"
define_type(self.manager, [entity_type])
self.create_form_for_entity_type()
with patch("datawinners.utils.get_organization_from_manager") as get_organization_from_dbm_mock:
get_organization_from_dbm_mock.return_value = Mock(return_value=organization)
with patch("datawinners.entity.import_data.get_organization") as get_organization:
mock = Mock( return_value=organization )
mock.org_id = 'abc'
get_organization.return_value = mock
error_message, failure_imports, success_message, imported_entities = import_data(request=request, manager = self.manager, form_code=FORM_CODE )
self.assertEqual(0, len(imported_entities))
self.assertEqual('The file you are uploading is not a list of [clinic]. Please check and upload again.', error_message)
def test_should_load_all_entity_types(self):
define_type(self.dbm, ["HealthFacility", "Clinic"])
define_type(self.dbm, ["HealthFacility", "Hospital"])
define_type(self.dbm, ["WaterPoint", "Lake"])
define_type(self.dbm, ["WaterPoint", "Dam"])
entity_types = get_all_entity_types(self.dbm)
expected = [['HealthFacility'], ['HealthFacility', 'Clinic'],
['HealthFacility', 'Hospital'], ['WaterPoint'],
['WaterPoint', 'Lake'], ['WaterPoint', 'Dam']]
for e in expected:
self.assertIn(e, entity_types)
def _create_entities(self):
self.entity_type = ['clinic']
define_type(self.manager, self.entity_type)
create_registration_form(self.manager, self.entity_type)
self.entity_type = ['waterpoint']
define_type(self.manager, self.entity_type)
create_registration_form(self.manager, self.entity_type)
define_type(self.manager, ['reporter'])
self.name_type = DataDictType(self.manager, name='Name', slug='name', primitive_type='string')
self.telephone_number_type = DataDictType(self.manager, name='telephone_number', slug='telephone_number',
primitive_type='string')
rep1 = create_entity(self.manager, ['reporter'], 'rep1')
rep1.add_data(data=[(MOBILE_NUMBER_FIELD, '1234', self.telephone_number_type),
(NAME_FIELD, "Test_reporter", self.name_type)], submission=dict(submission_id="2"))
def test_get_entity_count_for_type(self):
entity_type = ["Clinic"]
define_type(self.manager, entity_type)
create_entity(self.manager, entity_type, "1").save()
self.assertEqual(1, get_entity_count_for_type(self.manager,
entity_type))
def safe_define_type(manager, type):
try:
define_type(manager, type)
except EntityTypeAlreadyDefined:
pass
def test_should_define_single_entity(self):
define_type(self.dbm, ["Clinic"])
entity_types = get_all_entity_types(self.dbm)
self.assertListEqual(entity_types, [["Clinic"]])
def test_should_disallow_redefining_the_same_entity_with_different_case(
self):
define_type(self.dbm, ["HealthFacility", "Clinic"])
with self.assertRaises(EntityTypeAlreadyDefined):
define_type(self.dbm, ["healTHfaciLIty", "clinic"])
def test_get_entity_count_for_type_as_string(self):
entity_type = "Clinic"
define_type(self.manager, [entity_type])
create_entity(self.manager, [entity_type], "1").save()
self.assertEqual(1, get_entity_count_for_type(self.manager,
entity_type))
def _create_entity_types(manager, entity_types):
for entity_type in entity_types:
try:
define_type(manager, entity_type)
except EntityTypeAlreadyDefined:
pass
def create_identification_number_type(db_name, entity_type, no_of_questions):
dbm = get_db_manager(db_name)
define_type(dbm, [entity_type])
form_model = _create_registration_form(dbm, entity_type, no_of_questions)
form_model.save()
entity_form_model_change_handler(form_model._doc, dbm)
def setUp(self):
MangroveTestCase.setUp(self)
initializer.run(self.manager)
define_type(self.manager, ["dog"])
self.entity_type = ["clinic"]
define_type(self.manager, self.entity_type)
self.entity = create_entity(
self.manager,
entity_type=self.entity_type,
location=["India", "Pune"],
aggregation_paths=None,
short_code="cli1",
)
self.data_record_id = self.entity.add_data(
data=[("Name", "Ruby")], submission=dict(submission_id="1"))
self.reporter = create_entity(
self.manager,
entity_type=["reporter"],
location=["India", "Pune"],
aggregation_paths=None,
short_code="rep1",
)
self.reporter.add_data(data=[(MOBILE_NUMBER_FIELD, '1234'),
(NAME_FIELD, "Test_reporter")],
submission=dict(submission_id="2"))
#Web submission Form Model
question1 = UniqueIdField(unique_id_type='clinic',
name="entity_question",
code="EID",
label="What is associated entity")
question2 = TextField(name="Name",
code="NAME",
label="Clinic Name",
defaultValue="some default value",
constraints=[TextLengthConstraint(4, 15)],
required=False)
question3 = IntegerField(
name="Arv stock",
code="ARV",
label="ARV Stock",
constraints=[NumericRangeConstraint(min=15, max=120)],
required=False)
question4 = SelectField(name="Color",
code="COL",
label="Color",
options=[("RED", 1), ("YELLOW", 2)],
required=False)
self.form_model = FormModel(
self.manager,
name="aids",
label="Aids form_model",
form_code="clinic",
fields=[question1, question2, question3, question4])
self.form_model.save()
#Activity Report Form Model
question1 = UniqueIdField(unique_id_type='reporter',
name="entity_question",
code="EID",
label="What is associated entity")
question2 = TextField(name="Name",
code="NAME",
label="Clinic Name",
defaultValue="some default value",
constraints=[TextLengthConstraint(4, 15)])
question3 = IntegerField(
name="Arv stock",
code="ARV",
label="ARV Stock",
constraints=[NumericRangeConstraint(min=15, max=120)])
activity_report = FormModel(self.manager,
name="report",
label="reporting form_model",
form_code="acp",
fields=[question1, question2, question3])
activity_report.save()
self.web_player = WebPlayerV2(self.manager)
def test_should_throw_assertionError_if_entity_type_is_not_list(self):
with self.assertRaises(AssertionError):
entity_type = "HealthFacility"
define_type(self.dbm, entity_type)
def test_should_disallow_redefining_the_same_entity(self):
define_type(self.dbm, ["HealthFacility", "Clinic"])
with self.assertRaises(EntityTypeAlreadyDefined):
define_type(self.dbm, ["HealthFacility", "Clinic"])
def CreateSchoolEntityType(self):
define_type(self.manager, self.entity_type)
print "Entity Type is", self.entity_type
