def get(self, **kwargs): """Gets an item matching the given kwargs.""" matches = [ item for item in self._results if all( getattr(item, attr) == val for attr, val in kwargs.items()) ] if not matches: raise ObjectDoesNotExist() if len(matches) > 1: raise MultipleObjectsReturned() return matches[0]
def get_or_create_node(nodename, parentnode): """get or create a child named "nodename" for given parentnode; return a tuple containing the childnode and "True" or "False" depending if it has been newly created or not """ matches = [n for n in parentnode.get_children() if n.name == nodename] if not matches: newnode = parentnode.add_child(name=nodename) return newnode, True elif len(matches) == 1: return matches[0], False else: raise MultipleObjectsReturned( f"found multiple target nodes {matches} for parent: {parentnode}")
def get_connected_interface(self): try: connection = InterfaceConnection.objects.select_related().get( Q(interface_a=self) | Q(interface_b=self)) if connection.interface_a == self: return connection.interface_b else: return connection.interface_a except InterfaceConnection.DoesNotExist: return None except InterfaceConnection.MultipleObjectsReturned: raise MultipleObjectsReturned( "Multiple connections found for {} interface {}!".format( self.device, self))
def get_provider_task(self, provider_service_type): action_match = Q(providertask__action=self.action) provider_service_type_match = Q( providertask__provider_service_type=provider_service_type) #provider_match = Q(providertask__provider_service_type__provider=provider) tasks = Task.objects.filter(action_match & provider_service_type_match) if len(tasks) > 1: raise MultipleObjectsReturned( f'One ProviderTask expected for {self.action} {provider} {service_type}' ) if len(tasks) == 0: return None return tasks[0]
def split_search(self, request, *args, **kwargs): """ 拆字任务包内容查看 :param request: :param args: :param kwargs: :return: """ if not has_business_type_perm(request.user, 'split'): return HttpResponseForbidden( _("You don't have permission to view.")) hanzi_char = request.query_params.get('hanzi_char', False) hanzi_pic_id = request.query_params.get('hanzi_pic_id', False) if hanzi_char: qs_split = VariantsSplit.objects.filter(user=request.user).filter( hanzi_char=hanzi_char) elif hanzi_pic_id: qs_split = VariantsSplit.objects.filter(user=request.user).filter( hanzi_pic_id=hanzi_pic_id) else: qs_split = None if qs_split is None: return HttpResponseNotFound( _("Not found for specific char %s(%s)." % (hanzi_char, hanzi_pic_id))) # Here we assume that query result only has 1 item because hanzi_char is unique in code. # But there isn't any assurance in code defence to guarantee that. if qs_split.count() > 1: raise MultipleObjectsReturned( _("Multiple objects returned for specific char %s(%s)." % (hanzi_char, hanzi_pic_id))) business_id = qs_split[0].id qs = Tasks.objects.filter( business_type=getenum_business_type('split')).filter( object_id=business_id) page = self.paginate_queryset(qs) if page is not None: serializer = self.get_serializer(page, many=True) return self.get_paginated_response(serializer.data) serializer = self.get_serializer(qs, many=True) return Response(serializer.data)
def get(self, latest=False, **kwargs): queryset = self.filter(**kwargs) if latest: queryset = queryset.distinct() queryset = list(queryset) count = len(queryset) if count == 1: data = queryset[0] return data elif count > 1: msg = 'Should return 1 record, but get {}'.format(count) raise MultipleObjectsReturned(msg) else: msg = 'No record found(org is {})'.format(current_org.name) raise ObjectDoesNotExist(msg)
def get(self, iterable): """ Gets the unique element of iterable that matches self. This follows the QuerySet.get() api, raising ObjectDoesNotExist if no element matches and MultipleObjectsReturned if multiple objects match. """ filtered = self.filter(iterable) if len(filtered) == 0: raise ObjectDoesNotExist('Object matching query does not exist.') elif len(filtered) > 1: raise MultipleObjectsReturned( 'get() returned more than one object -- it returned %s!' % len(filtered)) else: return filtered[0]
def post(self, request): email = request.data.get('email') associated_users = User.objects.filter(Q(email=email)) if not associated_users.exists(): raise ObjectDoesNotExist("No user associated with email: " + email) if associated_users.count() > 1: raise MultipleObjectsReturned( "There are more than one User associated with email: " + email) user = associated_users.first() try: send_email_password_reset(user=user, request=request) except (BadHeaderError, SMTPException): return JsonResponse({'message': 'Fail to send email.'}, status=503) return JsonResponse({'message': 'Password reset email has been sent'})
def get(email): """ Retrieves the newsletter user :param email: email of newsletter user :type email: str :raises NotFound: if user is not found :return: the NLUser record of email :rtype: :class: `NLUser` """ nluser_filter = NLUser.objects.filter(email=email) if nluser_filter.count() > 1: raise MultipleObjectsReturned( "Received multiple records of NLUser with email: "+email) if not nluser_filter.first(): raise NotFound("Cannot find NLUser with email: "+email) return nluser_filter.first()
def _find_user(self): for search_base in settings.LDAP_SEARCH_BASE.split('|'): base_with_root = ','.join([search_base, settings.LDAP_ROOT]) user_query = '({})'.format(settings.LDAP_SEARCH_FILTER.format(self.user_id)) results = self.connection.search_s( base_with_root, ldap.SCOPE_SUBTREE, user_query, ) if len(results) > 1: raise MultipleObjectsReturned('LDAP Query returned multiple users') elif len(results) == 1: self.dn = results[0][0] self.attributes = results[0][1] return raise ObjectDoesNotExist('LDAP Query returned no users')
def get_default_for_point(cls, point): """ Returns a new BenefitCurrencyConversion for the i-Tree region that contains the given point. """ regions_covered = ITreeRegion.objects.filter(geometry__contains=point) if len(regions_covered) > 1: raise MultipleObjectsReturned( "There should not be overlapping i-Tree regions") elif len(regions_covered) == 0: return None region_code = regions_covered[0].code return cls.get_default_for_region(region_code)
def get_deployment(self, id_token): deployments = self.__class__.get_deployments( self.user, id_token, search_name=self.chart_name, # search_version=tool_deployment.tool.version, ) if not deployments: raise ObjectDoesNotExist(self) if len(deployments) > 1: log.warning(f"Multiple matches for {self!r} found") raise MultipleObjectsReturned(self) return deployments[0]
def update_investor(self, form, request): operational_stakeholder = form.cleaned_data['operational_stakeholder'] # Update operational stakeholder (involvement) involvements = InvestorActivityInvolvement.objects.filter(fk_activity=self.activity) if len(involvements) > 1: raise MultipleObjectsReturned( 'More than one operational stakeholder for activity {}'.format(str(self.activity)) ) if len(involvements): involvement = involvements.last() involvement.fk_investor = operational_stakeholder else: involvement = InvestorActivityInvolvement( fk_activity=self.activity, fk_investor=operational_stakeholder, fk_status_id=1 ) involvement.save() messages.success(request, self.success_message.format(self.deal_id))
def get_records(self, identifier, allow_multiple): if allow_multiple: records = self.filter_records(identifier) else: try: records = [self.get_record(identifier)] except (OrganisationGeography.MultipleObjectsReturned, OrganisationDivision.MultipleObjectsReturned) as e: message = str(e) + ( " This might indicate a problem which needs to be fixed, " "but it can also be valid for the same GSS code to appear " "in more than one DivisionSet. " "To import this boundary against all occurrences " "of this code, re-run the command with the --all flag" ) raise MultipleObjectsReturned(message) return records
def check(apps, schema_editor): # @UnusedVariable Department = apps.get_model('cirs', 'Department') CriticalIncident = apps.get_model('cirs', 'CriticalIncident') LabCIRSConfig = apps.get_model('cirs', 'LabCIRSConfig') config_count = LabCIRSConfig.objects.count() ci_count = CriticalIncident.objects.count() dept_count = Department.objects.count() # no multiple departments or configurations allowed if dept_count > 1 or config_count > 1: raise MultipleObjectsReturned( 'There are to many departments or configurations. ' 'Only one is allowed before you can migrate!') # there has to be exactly one department if incidents and/or configuration are present if (ci_count > 0 or config_count > 0) & (dept_count == 0): raise ValidationError( 'There are incidents and/or configuration, but no department. ' 'In this case there has to be one before you can migrate!')
def find_by_field(field, value, repo=None): ''' Static method to find a single :class:`EmailMessage` by an indexed value. Looks for the item in Solr and returns an :class:`EmailMessage` instance initialized from the repository if a single match is found for the requested field and value. Raises :class:`django.core.exceptions.MultipleObjectsReturned` if more than one match is found; raises :class:`django.core.exceptions.ObjectDoesNotExist` if no matches are found in the Solr index. :param field: solr field to search :param value: value to search on in the specified field :param repo: optional :class:`eulfedora.server.Repository` to use an existing connection with specific credentials :returns: :class:`EmailMessage` ''' solr = solr_interface() search_terms = { field: value, 'content_model': ArrangementObject.ARRANGEMENT_CONTENT_MODEL } q = solr.query(**search_terms).field_limit('pid') # check that we found one and only one found = len(q) # borrowing custom django exceptions for not found / too many # matches if found > 1: raise MultipleObjectsReturned('Found %d records with %s %s' % \ (found, field, value)) if not found: raise ObjectDoesNotExist('No record found with %s %s' % (field, value)) if repo is None: repo = Repository() return repo.get_object(q[0]['pid'], type=EmailMessage)
def testpaper_create(request): if request.method == 'POST': testpaper_name = request.POST.get('testpaper_name', ) try: if TestPaper.objects.filter(name__icontains=testpaper_name): raise MultipleObjectsReturned('Question has existed.') except ObjectDoesNotExist: pass testpaper = testmanager.create_testpaper(name=testpaper_name, created_by=request.user, is_testpaper=1) return render(request, 'exam/testpaper_edit.html', locals()) else: return render(request, 'exam/testpaper_create.html', locals())
def get_value(self, scenario_id, parameters): name = self._get_field_value('name', parameters) model_classes = [ model for model in extract_models(models.Model) if model.__name__ == name ] try: model, = model_classes except ValueError: if not model_classes: raise self.DoesNotExist('No model named \'{}\''.format( self.name)) raise MultipleObjectsReturned('Ambiguous name \'{}\' refer to ' 'too many models'.format(self.name)) key = self._get_field_value('key', parameters) data = model.objects.get(pk=key) attribute = self._get_field_value('attribute', parameters) return getattr(data, attribute)
def get_order_for_items_update(user: User): # check if there is an active order order_qs = Order.objects.filter(user=user, ordered=False) if order_qs.exists(): # cannot have more than one active order if order_qs.count() != 1: raise MultipleObjectsReturned() # Cannot update order while paying for it if Payment.objects.filter(order__in=order_qs, waiting=True).exists(): raise Exception( 'Please complete the payment of the previous order') else: return order_qs[0] else: return None
def test_validate_dos_username_exists__multiple_users_with_username_error( self, mock_logger, mock_get_dos_user_for_username ): "Test 'validate_dos_username_exists' method, multiple users with user validation error" stub_dos_username = "******" mock_get_dos_user_for_username.side_effect = MultipleObjectsReturned() with self.assertRaises(ValidationError): try: validate_dos_username_exists(stub_dos_username) except ValidationError as e: self.assertEqual( ["Unexpected multiple DoS users with given username '" + stub_dos_username + "'"], e.messages, ) raise e mock_logger.info.assert_called_with("Validate DoS user exists for name: " + str(stub_dos_username))
def by_arrangement_id(id, repo=None): ''' Static method to find an :class:`ArrangementObject` by its local or arrangement id. Looks for the item in Solr and returns an :class:`ArrangementObject` instance initialized from the repository if a single match is found for the requested id. Raises :class:`django.core.exceptions.MultipleObjectsReturned` if more than one match is found; raises :class:`django.core.exceptions.ObjectDoesNotExist` if no matches are found in the Solr index. :param id: arrangement id or local id :param repo: optional :class:`eulfedora.server.Repository` to use an existing connection with specific credentials :returns: :class:`ArrangementObject` ''' solr = solr_interface() q = solr.query(arrangement_id=id, content_model=ArrangementObject.ARRANGEMENT_CONTENT_MODEL) \ .field_limit('pid') # check that we found one and only one found = len(q) # borrowing custom django exceptions for not found / too many # matches if found > 1: raise MultipleObjectsReturned('Found %d records with arrangement id %s' % \ (found, id)) if not found: raise ObjectDoesNotExist('No record found with arrangement id %s' % id) if repo is None: repo = Repository() return repo.get_object(q[0]['pid'], type=ArrangementObject)
def next_version(self, object): """ Return the next version of the given object. In case there is no next object existing, meaning the given object is the current version, the function returns this version. """ if object.version_end_date == None: return object else: try: next = self.get(Q(identity=object.identity), Q(version_start_date=object.version_end_date)) except MultipleObjectsReturned as e: raise MultipleObjectsReturned( "next_version couldn't uniquely identify the next version of object " + str(object.identity) + " to be returned\n" + str(e)) except ObjectDoesNotExist as e: raise ObjectDoesNotExist( "next_version couldn't find a next version of object " + str(object.identity) + "\n" + str(e)) return next
def obj_get(self, bundle, **kwargs): try: obj = None if self._meta.detail_uri_name in kwargs: pk = tuple(kwargs[self._meta.detail_uri_name].split(',')) obj = self._meta.object_class._get_by_raw_pkval_(pk) obj._load_() else: obj = self._meta.object_class.get(**kwargs) if not obj: raise ObjectDoesNotExist("Couldn't find an instance of '%s'" % self._meta.object_class.__name__) bundle.obj = obj self.authorized_read_detail([obj,], bundle) return bundle.obj except orm.MultipleObjectsFoundError: raise MultipleObjectsReturned("More than one '%s' matched" % self._meta.object_class.__name__) except orm.core.UnrepeatableReadError: raise NotFound("Invalid resource lookup data provided (wrong id).") except ValueError: raise NotFound("Invalid resource lookup data provided (mismatched type).")
def retrieve_feature_id(accession: str, soterm: str) -> int: """Retrieve feature object.""" # feature.uniquename try: return Feature.objects.get(uniquename=accession, type__cv__name="sequence", type__name=soterm).feature_id except (MultipleObjectsReturned, ObjectDoesNotExist): pass # feature.name try: return Feature.objects.get(name__iexact=accession, type__cv__name="sequence", type__name=soterm).feature_id except (MultipleObjectsReturned, ObjectDoesNotExist): pass # feature.dbxref.accession try: return Feature.objects.get( dbxref__accession__iexact=accession, type__cv__name="sequence", type__name=soterm, ).feature_id except (MultipleObjectsReturned, ObjectDoesNotExist): pass # featuredbxref.dbxref.accession try: return FeatureDbxref.objects.get( dbxref__accession__iexact=accession, feature__type__cv__name="sequence", feature__type__name=soterm, ).feature_id except ObjectDoesNotExist: raise ObjectDoesNotExist("{} {} does not exist".format( soterm, accession)) except MultipleObjectsReturned: raise MultipleObjectsReturned("{} {} matches multiple features".format( soterm, accession))
def obj_get(self, bundle, **kwargs): """ Overriden get method to perform a direct lookup if we are searching by shortname instead of pk """ lookup = kwargs[self._meta.detail_uri_name] if re.search('[a-zA-Z]', lookup): # If the lookup parameter includes characters, we try to use it as a shortname object_list = self.apply_filters(bundle.request, {'shortname': lookup}) if len(object_list) <= 0: raise self._meta.object_class.DoesNotExist( "Couldn't find an course whith shortname '%s'." % (lookup)) elif len(object_list) > 1: raise MultipleObjectsReturned( "More than one course with shortname '%s'." % (lookup)) bundle.obj = object_list[0] self.authorized_read_detail(object_list, bundle) return bundle.obj else: return super().obj_get(bundle, **kwargs)
def test_occours_exception_by_get_or_create_for_member( self, mock_log, mock_get_for_model): """ Test that if model.mailchimper.get_or_create_for_member raise an exception this is logged by create Log object """ data = deepcopy(MEMBERS_RESULT['data'][0]) mock_model = Mock() exception = MultipleObjectsReturned("Boom!") mock_content_type = Mock() mock_member = Mock() mock_get_for_model.return_value = mock_content_type mock_model.mailchimper.get_or_create_for_member.side_effect = ( exception) Member.objects.get_or_create = Mock(return_value=(mock_member, True,)) Member.objects.get_or_create_for_model(data, mock_model) mock_model.mailchimper.get_or_create_for_member.\ assert_called_once_with(data, force_update=False) mock_log.assert_called_with(data, exception, ANY, model=mock_model)
def get(self, **kwargs): clone = self.filter(**kwargs) result = None for qs in clone._querysets: try: obj = qs.get() except ObjectDoesNotExist: pass # Don't catch the MultipleObjectsReturned(), allow it to raise. else: # If a second object is found, raise an exception. if result: raise MultipleObjectsReturned() result = obj # Checked all QuerySets and no object was found. if result is None: raise ObjectDoesNotExist() # Return the only result found. return result
def emitir_alvara(request, usuario, processo, obs): documentos = Documento.objects.filter(Processo__pk=processo.Numero) for documento in documentos: if documento.Assunto == u'AUTORIZAÇÃO DE FUNCIONAMENTO (AGEVISA)': raise MultipleObjectsReturned("Alvará já foi Emitido.") buffer = BytesIO() report = MyPrint(buffer, 'A4') descricao = "Autorização de Funcionamento referente ao Exercício: " + str( processo.Exercicio) + "." doc = Documento(Publico=True, Assunto='AUTORIZAÇÃO DE FUNCIONAMENTO (AGEVISA)', Descricao=descricao, Usuario=usuario, Processo=processo) doc.save() pdf = report.alvara(processo, doc.CodAutenticidade, usuario, obs) arquivo = ContentFile(pdf) filename = "Alvara-" + unicode(processo.Exercicio) + ".pdf" doc.Arquivo.save(filename, arquivo)
def obj_get(self, bundle, **kwargs): """ Method copied from parent class so we can handle the case where MultipleObjectsReturned happens for Config (deletable) models. """ # Use ignore_bad_filters=True. `obj_get_list` filters based on # request.GET, but `obj_get` usually filters based on `detail_uri_name` # or data from a related field, so we don't want to raise errors if # something doesn't explicitly match a configured filter. applicable_filters = self.build_filters(filters=kwargs, ignore_bad_filters=True) if self._meta.detail_uri_name in kwargs: applicable_filters[self._meta.detail_uri_name] = kwargs[ self._meta.detail_uri_name] try: object_list = self.apply_filters(bundle.request, applicable_filters) stringified_kwargs = ', '.join( ["%s=%s" % (k, v) for k, v in applicable_filters.items()]) if len(object_list) <= 0: raise self._meta.object_class.DoesNotExist( "Couldn't find an instance of '%s' which matched '%s'." % (self._meta.object_class.__name__, stringified_kwargs)) elif len(object_list) > 1: if self._meta.queryset.model._admin.deletable is False: object_list = object_list.order_by('-id') else: raise MultipleObjectsReturned( "More than '%s' matched '%s'." % (self._meta.object_class.__name__, stringified_kwargs)) bundle.obj = object_list[0] self.authorized_read_detail(object_list, bundle) return bundle.obj except ValueError: raise NotFound( "Invalid resource lookup data provided (mismatched type).")
def get(self, **kwargs): """Returns a single result from this queryset. This will return a single result from the list of items in this queryset. If keyword arguments are provided, they will be used to filter the queryset down. There must be only one item in the queryset matching the given criteria, or a MultipleObjectsReturned will be raised. If there are no items, then an ObjectDoesNotExist will be raised. """ clone = self.filter(**kwargs) count = len(clone) if count == 1: return clone[0] elif count == 0: raise ObjectDoesNotExist('%s matching query does not exist.' % self._data.__class__.__name__) else: raise MultipleObjectsReturned( 'get() returned more than one %s -- it returned %s!' % (self._data.__class__.__name__, count))