def __init__(self, type="", name="", code="", label='', instruction='', constraints=None, required=True, parent_field_code=None): if not constraints: constraints = [] self._dict = {} self._dict = { 'name': name, 'type': type, 'code': code, 'instruction': instruction, 'label': label, 'required': required, 'parent_field_code': parent_field_code } self.constraints = constraints self.errors = [] self.value = None if not is_empty(constraints): self._dict['constraints'] = [] for constraint in constraints: constraint_json = constraint._to_json() if not is_empty(constraint_json): self._dict['constraints'].append(constraint_json)
def create_entity(dbm, entity_type, short_code, location=None, aggregation_paths=None, geometry=None): """ Initialize and save an entity to the database. Return the entity created unless the short code used is not unique or this entity type has not been defined yet. """ assert is_string(short_code) and not is_empty(short_code) assert type(entity_type) is list and not is_empty(entity_type) type_hierarchy = [e_type for e_type in entity_type] if not entity_type_already_defined(dbm, type_hierarchy): raise EntityTypeDoesNotExistsException(entity_type) if _check_if_exists(dbm, type_hierarchy, short_code): raise DataObjectAlreadyExists("Entity", "Unique Identification Number (ID)", short_code) e = Entity(dbm, entity_type=type_hierarchy, location=location, aggregation_paths=aggregation_paths, short_code=short_code, geometry=geometry) e.save() return e
def create_entity(dbm, entity_type, short_code, location=None, aggregation_paths=None, geometry=None): """ Initialize and save an entity to the database. Return the entity created unless the short code used is not unique or this entity type has not been defined yet. """ assert is_string(short_code) and not is_empty(short_code) assert type(entity_type) is list and not is_empty(entity_type) if not entity_type_already_defined(dbm, entity_type): raise EntityTypeDoesNotExistsException(entity_type) existing = _check_if_entity_exists(dbm, entity_type, short_code, return_entity=True) if existing: entity_name = existing.data.get('name', {'value': ''}).get('value') raise DataObjectAlreadyExists(entity_type[0].capitalize(), "Unique ID Number", short_code, existing_name=entity_name) e = Entity(dbm, entity_type=entity_type, location=location, aggregation_paths=aggregation_paths, short_code=short_code, geometry=geometry) #e.save() return e
def _is_valid(self, answers): cleaned_answers = {} errors = {} short_code = self._find_code(answers, self.entity_question.code) if self.is_registration_form(): entity_code = self._find_code(answers, ENTITY_TYPE_FIELD_CODE) if is_empty(entity_code): raise EntityTypeCodeNotSubmitted() if short_code is not None and len(short_code) > 12: raise ShortCodeTooLongException() else: if is_empty(short_code): raise EntityQuestionCodeNotSubmitted() for key in answers: field = self.get_field_by_code(key) if field is None: continue answer = answers[key] if is_empty(answer): continue is_valid, result = self._validate_answer_for_field(answer, field) if is_valid: cleaned_answers[field.code] = result else: errors[key] = result return cleaned_answers, errors
def test_should_initialize_response_from_form_submission(self): form_submission_mock = Mock(spec=FormSubmission) form_submission_mock.saved = True form_submission_mock.errors = [] expected_data_record_id = 123 form_submission_mock.data_record_id = expected_data_record_id expected_short_code = 456 form_submission_mock.short_code = expected_short_code expected_cleanned_data = {'a': 1} form_submission_mock.cleaned_data = expected_cleanned_data form_submission_mock.is_registration = False expected_entity_type = 'entity_type' form_submission_mock.entity_type = expected_entity_type expected_form_code = '1' form_model_mock = Mock() form_model_mock.form_code = expected_form_code form_submission_mock.form_model = form_model_mock response = create_response_from_form_submission( reporters=None, form_submission=form_submission_mock) self.assertTrue(response.success) self.assertTrue(is_empty(response.errors)) self.assertTrue(is_empty(response.reporters)) self.assertTrue(response.success) self.assertEquals(expected_data_record_id, response.datarecord_id) self.assertEquals(expected_short_code, response.short_code) self.assertEquals(expected_cleanned_data, response.processed_data) self.assertFalse(response.is_registration) self.assertEquals(expected_entity_type, response.entity_type) self.assertEquals(expected_entity_type, response.entity_type) self.assertEquals(expected_form_code, response.form_code)
def _handle_tokens_with_only_separators(self, tokens): new_tokens = [] for token in tokens: if is_empty(token): continue if is_empty("".join(token.split("."))): continue new_tokens.append(token.strip()) return new_tokens
def test_should_delete_the_datasender_user_if_it_exists(self): self.assertTrue(User.objects.get(username=self.username)) self.assertTrue(NGOUserProfile.objects.get(reporter_id=self.reporter_id, org_id=self.org_id)) entity_ids = [self.reporter_id, 'test_id'] organization = Mock(spec=Organization) organization.org_id = self.org_id delete_datasender_users_if_any(entity_ids, organization) self.assertTrue(is_empty(User.objects.filter(username=self.username))) self.assertTrue(is_empty(NGOUserProfile.objects.filter(reporter_id=self.reporter_id, org_id=self.org_id)))
def _add_text_length_constraint(self, post_dict): max_length_from_post = post_dict.get("max_length") min_length_from_post = post_dict.get("min_length") max_length = max_length_from_post if not is_empty(max_length_from_post) else None min_length = min_length_from_post if not is_empty(min_length_from_post) else None constraints = [] if not (max_length is None and min_length is None): constraints.append(TextLengthConstraint(min=min_length, max=max_length)) return constraints
def _create_integer_question(self, post_dict, code): max_range_from_post = post_dict.get("range_max") min_range_from_post = post_dict.get("range_min") max_range = max_range_from_post if not is_empty(max_range_from_post) else None min_range = min_range_from_post if not is_empty(min_range_from_post) else None range = NumericRangeConstraint(min=min_range, max=max_range) return IntegerField(name=self._get_name(post_dict), code=code, label=post_dict["title"], constraints=[range], instruction=post_dict.get("instruction"), required=post_dict.get("required"), parent_field_code=post_dict.get('parent_field_code'))
def validate(self, values, fields=None, dbm=None): from mangrove.form_model.form_model import GEO_CODE, LOCATION_TYPE_FIELD_CODE if is_empty(case_insensitive_lookup(values, GEO_CODE)) and is_empty( case_insensitive_lookup(values, LOCATION_TYPE_FIELD_CODE)): errors = OrderedDict() errors[GEO_CODE] = 'Please fill out at least one location field correctly.' #errors[LOCATION_TYPE_FIELD_CODE] = 'Please fill out at least one location field correctly.' return errors return OrderedDict()
def _create_integer_question(post_dict, ddtype): max_range_from_post = post_dict.get("range_max") min_range_from_post = post_dict.get("range_min") max_range = max_range_from_post if not is_empty( max_range_from_post) else None min_range = min_range_from_post if not is_empty( min_range_from_post) else None range = NumericConstraint(min=min_range, max=max_range) return IntegerField(name=post_dict["title"], code=post_dict["code"].strip(), label="default", range=range, ddtype=ddtype, instruction=post_dict.get("instruction"))
def _create_text_question(post_dict, ddtype): max_length_from_post = post_dict.get("max_length") min_length_from_post = post_dict.get("min_length") max_length = max_length_from_post if not is_empty( max_length_from_post) else None min_length = min_length_from_post if not is_empty( min_length_from_post) else None length = TextConstraint(min=min_length, max=max_length) return TextField(name=post_dict["title"], code=post_dict["code"].strip(), label="default", entity_question_flag=post_dict.get("is_entity_question"), length=length, ddtype=ddtype, instruction=post_dict.get("instruction"))
def _to_json(self): dict = {} if self.min is not None: dict[ConstraintAttributes.MIN] = self.min if self.max is not None: dict[ConstraintAttributes.MAX] = self.max return ("length", dict) if not is_empty(dict) else ()
def _get_chars_constraints(self, field): constraints = {} if not is_empty(field.constraints): constraint = field.constraints[0] if constraint.max is not None: constraints["max_length"] = constraint.max if constraint.min is not None: constraints["min_length"] = constraint.min return constraints
def submit(request): dbm = get_database_manager(request) post = _get_submission(request.POST) success = True try: web_player = WebPlayer(dbm, SubmissionHandler(dbm)) message = { k: v for (k, v) in post.get('message').items() if not is_empty(v) } if message.get(LOCATION_TYPE_FIELD_CODE) is not None: message[LOCATION_TYPE_FIELD_CODE] += COUNTRY request = Request(message=message, transportInfo=TransportInfo( transport=post.get('transport'), source=post.get('source'), destination=post.get('destination'))) response = web_player.accept(request) if response.success: message = get_success_msg_for_registration_using(response, "web") else: message = get_submission_error_message_for(response.errors) entity_id = response.datarecord_id except MangroveException as exception: message = get_exception_message_for(exception=exception, channel="web") success = False entity_id = None return HttpResponse( json.dumps({ 'success': success, 'message': message, 'entity_id': entity_id }))
def payment_details(self, obj): organization = obj.organization payment_details = PaymentDetails.objects.filter(organization=organization) if not is_empty(payment_details): return payment_details[0].preferred_payment return "--"
def count_projects(dbm, include_voided_projects=True): if include_voided_projects: rows = dbm.load_all_rows_in_view('count_projects', reduce=True, group_level=0) else: rows = dbm.load_all_rows_in_view('count_projects', reduce=True, group_level=1, key=False) return rows[0]['value'] if not is_empty(rows) else 0
def _validate_post_data(dbm, request): form = ReporterRegistrationForm(request.POST) message = None success = False form_errors = [] form_errors.extend(form.non_field_errors()) if form.is_valid(): form_errors = [] form_data = {k: v for (k, v) in form.cleaned_data.items() if not is_empty(v)} try: entered_telephone_number = form_data.get("telephone_number") tel_number = _get_telephone_number(entered_telephone_number) if not helper.unique(dbm, tel_number): raise MultipleReportersForANumberException(entered_telephone_number) web_player = WebPlayer(dbm, SubmissionHandler(dbm)) response = web_player.accept( Request(message=_get_data(form_data), transportInfo=TransportInfo(transport='web', source='web', destination='mangrove'))) message = get_success_msg_for_registration_using(response, "web") success = True except MangroveException as exception: form_errors.append(exception.message) success = False return form, form_errors, message, success
def import_subjects_from_project_wizard(request, form_code): manager = get_database_manager(request.user) error_message, failure_imports, success_message, short_code_subject_details_dict = import_module.import_data( request, manager, default_parser=XlsOrderedParser, form_code=form_code) subject_details = {} if len(short_code_subject_details_dict) != 0: detail_dict = dict() form_model = get_form_model_by_code(manager, form_code) entity_type = form_model.entity_type[0] short_codes = [] for short_code in short_code_subject_details_dict.keys(): short_codes.append(short_code) subject_details = _format_imported_subjects_datetime_field_to_str( form_model, short_code_subject_details_dict) detail_dict.update({entity_type: "[%s]" % ", ".join(short_codes)}) UserActivityLog().log(request, action=IMPORTED_IDENTIFICATION_NUMBER, detail=json.dumps(detail_dict)) return HttpResponse( json.dumps({ 'success': error_message is None and is_empty(failure_imports), 'message': success_message, 'error_message': error_message, 'failure_imports': failure_imports, 'successful_imports': subject_details, }))
def post(self, request, *args, **kwargs): parser_dict = { '.xls': XlsDatasenderParser, '.xlsx': XlsxDataSenderParser } manager = get_database_manager(request.user) file_extension = os.path.splitext(request.GET["qqfile"])[1] parser = parser_dict.get(file_extension, None) is_update = request.GET.get('is_update') == 'true' error_message, failure_imports, success_message, successful_imports = import_module.import_data( request, manager, default_parser=parser, is_update=is_update) imported_data_senders = parse_successful_imports(successful_imports) self._convert_anonymous_submissions_to_registered( imported_data_senders, manager) self.update_activity_log(request, successful_imports) transaction.commit( ) #Mandatory for manually managed transaction blocks. Here it won't save anything return HttpResponse( json.dumps({ 'success': error_message is None and is_empty(failure_imports), 'message': success_message, 'error_message': error_message, 'failure_imports': failure_imports, 'successful_imports': imported_data_senders }))
def _validate_post_data(dbm, request): form = ReporterRegistrationForm(request.POST) message = None success = False form_errors = [] form_errors.extend(form.non_field_errors()) if form.is_valid(): form_errors = [] form_data = { k: v for (k, v) in form.cleaned_data.items() if not is_empty(v) } try: entered_telephone_number = form_data.get("telephone_number") tel_number = _get_telephone_number(entered_telephone_number) if not helper.unique(dbm, tel_number): raise MultipleReportersForANumberException( entered_telephone_number) web_player = WebPlayer(dbm, SubmissionHandler(dbm)) response = web_player.accept( Request(message=_get_data(form_data), transportInfo=TransportInfo(transport='web', source='web', destination='mangrove'))) message = get_success_msg_for_registration_using(response, "web") success = True except MangroveException as exception: form_errors.append(exception.message) success = False return form, form_errors, message, success
def import_subjects_from_project_wizard(request, form_code): manager = get_database_manager(request.user) error_message, failure_imports, success_message, imported_entities, successful_imports = import_module.import_data( request, manager, default_parser=XlsOrderedParser, form_code=form_code) if len(imported_entities) != 0: detail_dict = dict() for short_code, entity_type in imported_entities.items(): entity_type = entity_type.capitalize() if detail_dict.get(entity_type) is not None: detail_dict.get(entity_type).append(short_code) else: detail_dict.update({entity_type: [short_code]}) for key, detail in detail_dict.items(): detail_dict.update({key: "[%s]" % ", ".join(detail)}) UserActivityLog().log(request, action=IMPORTED_SUBJECTS, detail=json.dumps(detail_dict)) subjects_data = import_module.load_all_subjects(manager) return HttpResponse( json.dumps({ 'success': error_message is None and is_empty(failure_imports), 'message': success_message, 'error_message': error_message, 'failure_imports': failure_imports, 'all_data': subjects_data, 'imported': imported_entities.keys() }))
def handle(self, *args, **options): if is_empty(args): print "give atleast one organization id. the command is python manage.py delete_org <id1 id2 ...>" for org_id in args: try: organization = Organization.objects.get(org_id=org_id) organization_setting = OrganizationSetting.objects.get( organization=organization) document_store = organization_setting.document_store self._delete_users_and_related_data(org_id) print "deleted organization users and related information for %s" % ( org_id, ) organization_setting.delete() organization.delete() print "deleted organization registration information for %s" % ( org_id, ) self._delete_couchdb_database(document_store) print "deleted submission, datarecords, form models for %s" % ( org_id, ) print "deleted organization complete for %s" % (org_id, ) except Exception as e: print e print "error in deleting organization %s" % (org_id, )
def _get_number_constraints(self, field): constraints = {} if not is_empty(field.constraints): constraint = field.constraints[0] if constraint.max is not None: constraints["max_value"] = float(constraint.max) if constraint.min is not None: constraints["min_value"] = float(constraint.min) return constraints
def get_success_msg_for_submission_using(response): reporters = response.reporters thanks = success_messages[SUBMISSION] % reporters[0].get( NAME_FIELD) if not is_empty( reporters) else success_messages[SUBMISSION] % "" expanded_response = get_expanded_response(response.processed_data) return thanks + expanded_response
def add_data(self, entity=None, data=(), event_time=None, submission=None, multiple_records=False): """ Add a new datarecord to this Entity and return a UUID for the datarecord. Arguments: data: a sequence of ordered tuples, (label, value, type) event_time: the time at which the event occured rather than when it was reported submission_id: an id to a 'submission' document in the submission log from which this data came """ assert is_sequence(data) assert event_time is None or isinstance(event_time, datetime) assert self.id is not None, u"id should never be none, even if haven't been saved,an entity should have a UUID." if event_time is None: event_time = utcnow() for (label, value) in data: if is_empty(label): raise ValueError(u'Empty label') if multiple_records: data_list = [] for (label, value) in data: data_record = DataRecordDocument( event_time=event_time, data=[(label, value)], submission=submission ) data_list.append(data_record) return self._dbm._save_documents(data_list) else: data_record_doc = DataRecordDocument( event_time=event_time, data=data, submission=submission ) return self._dbm._save_document(data_record_doc)
def forwards(self, orm): for org in orm.Organization.objects.all(): if not org.status: status = 'Activated' status_changed_datetime = datetime.datetime.now() if is_empty(org.active_date) else org.active_date org.status_changed_datetime = status_changed_datetime org.status = status org.save()
def get_by_short_code(dbm, short_code, entity_type): assert is_string(short_code) assert is_sequence(entity_type) rows = dbm.load_all_rows_in_view("by_short_codes", key=[entity_type, short_code], reduce=False) if is_empty(rows): raise DataObjectNotFound("Entity", "Unique Identification Number (ID)", short_code) doc_id = rows[0].id return Entity.get(dbm, doc_id)
def create_entity(dbm, entity_type, short_code, location=None, aggregation_paths=None, geometry=None): """ Initialize and save an entity to the database. Return the entity created unless the short code used is not unique or this entity type has not been defined yet. """ assert is_string(short_code) and not is_empty(short_code) assert type(entity_type) is list and not is_empty(entity_type) type_hierarchy = [e_type for e_type in entity_type] if not entity_type_already_defined(dbm, type_hierarchy): raise EntityTypeDoesNotExistsException(entity_type) if _check_if_exists(dbm,type_hierarchy,short_code): raise DataObjectAlreadyExists("Entity", "Unique Identification Number (ID)", short_code) e = Entity(dbm, entity_type=type_hierarchy, location=location, aggregation_paths=aggregation_paths, short_code=short_code, geometry=geometry) e.save() return e
def _get_location_data(self, values): display_location, geo_code = values.get(LOCATION_TYPE_FIELD_CODE), values.get(GEO_CODE) location_hierarchy = self._get_location_heirarchy_from_location_name(display_location) tree = self.location_tree if location_hierarchy is None and not is_empty(geo_code): try: lat_string, long_string = tuple(geo_code.split()) location_hierarchy = tree.get_location_hierarchy_for_geocode(lat=float(lat_string), long=float(long_string)) except ValueError as e: raise GeoCodeFormatException(e.args) elif location_hierarchy is not None and is_empty(geo_code): try: translated_geo_code = tree.get_centroid(display_location.split(',')[0],len(location_hierarchy)-1) values[GEO_CODE] = "%s %s" % (translated_geo_code[1], translated_geo_code[0]) except Exception: pass values[LOCATION_TYPE_FIELD_CODE] = location_hierarchy
def _entity_by_short_code(dbm, short_code, entity_type): rows = dbm.view.entity_by_short_code(key=[entity_type, short_code], include_docs=True) if is_empty(rows): raise DataObjectNotFound("Entity", "Unique Identification Number (ID)", short_code) doc = EntityDocument.wrap(rows[0]['doc']) return Entity.new_from_doc(dbm, doc)
def _geo_code_validations(self, b): msg = "Incorrect GPS format. The GPS coordinates must be in the following format: xx.xxxx yy.yyyy. Example -18.8665 47.5315" geo_code_string = b.strip() geo_code_string = (' ').join(geo_code_string.split()) if not is_empty(geo_code_string): lat_long = geo_code_string.split(' ') self._geo_code_format_validations(lat_long, msg) self.cleaned_data['geo_code'] = geo_code_string
def crs_model_creator(data_record_id, submission_data, model, question_mapping=None, defaults=None): exists = model.objects.filter(data_record_id=data_record_id) if not is_empty(exists): return if not question_mapping: question_mapping = {} data_record = {'data_record_id': data_record_id} if not defaults: defaults = data_record else: defaults.update(data_record) _save_submission_via_model( submission_data, model,question_mapping, defaults)
def forwards(self, orm): for org in orm.OrganizationSetting.objects.all(): if org.smsc is not None and not is_empty(org.sms_tel_number): outgoing_obj = orm.OutgoingNumberSetting.objects.create( phone_number=org.sms_tel_number.split(',')[0].strip(), smsc=org.smsc) outgoing_obj.save() org.outgoing_number = outgoing_obj org.save()
def _parse_tokens(self, tokens): tokens = [token.strip() for token in tokens if token] submission = {} for token in tokens: if is_empty(token): continue field_code, answer = self._parse_token(token) if field_code in submission.keys(): raise MultipleSubmissionsForSameCodeException(field_code) submission[field_code] = answer return submission
def _validate_unique_phone_number_for_reporter(self, submission): if submission.cleaned_data.get(ENTITY_TYPE_FIELD_CODE) == [REPORTER] and submission.form_model.is_registration_form(): phone_number = submission.cleaned_data.get(MOBILE_NUMBER_FIELD_CODE) if is_empty(phone_number): raise MobileNumberMissing() actual_number = self._get_telephone_number(phone_number) try: find_reporter_entity(self.dbm, actual_number) raise MultipleReportersForANumberException(from_number=phone_number) except NumberNotRegisteredException: submission.cleaned_data[MOBILE_NUMBER_FIELD_CODE] = actual_number
def _get_location_heirarchy_from_location_name(self, display_location): if is_empty(display_location): return None display_location_list = display_location.lower().split(',') if len(display_location_list) > 1: display_location_list.reverse() return display_location_list lowest_level_location = display_location_list[0] tree = self.location_tree location_hierarchy = tree.get_hierarchy_path(lowest_level_location) return location_hierarchy
def _load_document(self, id, document_class=DocumentBase): """ Load a document from the DB into an in memory document object. Low level interface does not create wrapping DataObject """ if is_empty(id): return None else: return document_class.load(self.database, id=id)
def _parse_header(self, dict_reader): field_header = dict_reader.fieldnames if is_empty(field_header): raise CSVParserInvalidHeaderFormatException() self._remove_trailing_empty_header_field(field_header) if self._has_empty_values(field_header): raise CSVParserInvalidHeaderFormatException() return [field.strip().lower() for field in field_header]
def get_exception_message_for(exception, channel=None): ex_type = type(exception) if channel is not None: message_dict = exception_messages.get(ex_type) if message_dict is None: return exception.message message = message_dict.get(channel) if is_empty(message): message = exception_messages[ex_type].get(DEFAULT) else: message = exception_messages[ex_type][DEFAULT] if isinstance(exception,MangroveException) and exception.data is not None and "%s" in message: return message % exception.data return message
def data_types(self, tags=None): """ Returns a list of each type of data that is stored on this entity """ assert tags is None or isinstance(tags, list) or is_string(tags) if tags is None or is_empty(tags): rows = self._dbm.load_all_rows_in_view(u'entity_datatypes', key=self.id) result = get_datadict_types(self._dbm, [row[u'value'] for row in rows]) else: if is_string(tags): tags = [tags] keys = [] for tag in tags: rows = self._dbm.load_all_rows_in_view(u'entity_datatypes_by_tag', key=[self.id, tag]) keys.append([row[u'value'] for row in rows]) ids_with_all_tags = list(set.intersection(*map(set, keys))) result = get_datadict_types(self._dbm, ids_with_all_tags) return result
def add_data(self, data=(), event_time=None, submission=None, multiple_records=False): """ Add a new datarecord to this Entity and return a UUID for the datarecord. Arguments: data: a sequence of ordered tuples, (label, value, type) where type is a DataDictType event_time: the time at which the event occured rather than when it was reported submission_id: an id to a 'submission' document in the submission log from which this data came """ assert is_sequence(data) assert event_time is None or isinstance(event_time, datetime) assert self.id is not None, u"id should never be none, even if haven't been saved,an entity should have a UUID." # TODO: should we have a flag that says that this has been # saved at least once to avoid adding data records for an # Entity that may never be saved? Should docs just be saved on # init? if event_time is None: event_time = utcnow() for (label, value, dd_type) in data: if not isinstance(dd_type, DataDictType) or is_empty(label): raise ValueError(u'Data must be of the form (label, value, DataDictType).') self.update_latest_data(data=data) if multiple_records: data_list = [] for (label, value, dd_type) in data: data_record = DataRecordDocument( entity_doc=self._doc, event_time=event_time, data=[(label, value, dd_type)], submission=submission ) data_list.append(data_record) return self._dbm._save_documents(data_list) else: data_record_doc = DataRecordDocument( entity_doc=self._doc, event_time=event_time, data=data, submission=submission ) return self._dbm._save_document(data_record_doc)
def submit(request): dbm = get_database_manager(request) post = _get_submission(request.POST) success = True try: web_player = WebPlayer(dbm, SubmissionHandler(dbm)) message = {k: v for (k, v) in post.get('message').items() if not is_empty(v)} if message.get(LOCATION_TYPE_FIELD_CODE) is not None: message[LOCATION_TYPE_FIELD_CODE]+= COUNTRY request = Request(message=message, transportInfo=TransportInfo(transport=post.get('transport'), source=post.get('source'), destination=post.get('destination'))) response = web_player.accept(request) if response.success: message = get_success_msg_for_registration_using(response, "web") else: message = get_submission_error_message_for(response.errors) entity_id = response.datarecord_id except MangroveException as exception: message = get_exception_message_for(exception=exception, channel="web") success = False entity_id = None return HttpResponse(json.dumps({'success': success, 'message': message, 'entity_id': entity_id}))
def _short_code_not_in(entity_q_code, values): return is_empty(values.get(entity_q_code))
def _is_empty(self, row): return len([value for value in row if not is_empty(value)]) == 0
def _is_header_row(self, row): if is_empty(row[0]): return None, False self._remove_trailing_empty_header_field(row) return [unicode(value).strip().lower() for value in row], True
def _remove_trailing_empty_header_field(self, field_header): for field in field_header[::-1]: if is_empty(field): field_header.pop() else: break
def test_should_return_empty_dict_for_empty_integer_constraint(self): constraint = NumericConstraint() actual_dict = constraint._to_json() self.assertTrue(is_empty(actual_dict))
def get_success_msg_for_submission_using(response): reporters = response.reporters thanks = success_messages[SUBMISSION] % reporters[0].get(NAME_FIELD) if not is_empty(reporters) else success_messages[SUBMISSION] % "" expanded_response = get_expanded_response(response.processed_data) return thanks + expanded_response
def test_should_return_empty_dict_for_empty_text_constraint(self): constraint = TextConstraint() actual_dict = constraint._to_json() self.assertTrue(is_empty(actual_dict))
def _has_empty_values(self, values_list): for value in values_list: if is_empty(value): return True return False