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))
