def is_user_exists(request):
"""
Checks if user is exists. If exists return True, else False.
"""
if request.is_ajax():
is_user_exists_form = IsUserExistsForm(request.GET)
if is_user_exists_form.is_valid():
try:
User.objects.get(username=is_user_exists_form.cleaned_data['username'])
return HttpResponse(json.dumps(True), content_type='application/json')
except ObjectDoesNotExist:
return HttpResponse(json.dumps(False), content_type='application/json')
else:
return HttpResponse(status=404)
# ----------------------------------------------------------------------------------------------------------------------
python类ObjectDoesNotExist()的实例源码
def is_mail_exists(request):
"""
Checks if mail is exists. If exists return True, else False.
"""
if request.is_ajax():
is_mail_exists_form = IsMailExistsForm(request.GET)
if is_mail_exists_form.is_valid():
try:
User.objects.get(email=is_mail_exists_form.cleaned_data['email'])
return HttpResponse(json.dumps(True), content_type='application/json')
except ObjectDoesNotExist:
return HttpResponse(json.dumps(False), content_type='application/json')
else:
return HttpResponse(status=404)
# ----------------------------------------------------------------------------------------------------------------------
def set_rating(request, rating_form):
"""
Checks if rating for books exists. If exists, changes it. If not, creates a new one.
"""
try:
book_rating = BookRating.objects.get(id_user=TheUser.objects.get(id_user=request.user),
id_book=Book.objects.get(id=rating_form.cleaned_data['book']))
book_rating.rating = rating_form.cleaned_data['rating']
book_rating.save()
except ObjectDoesNotExist:
BookRating.objects.create(id_user=TheUser.objects.get(id_user=request.user),
id_book=Book.objects.get(id=rating_form.cleaned_data['book']),
rating=rating_form.cleaned_data['rating'])
finally:
logger.info("User '{}' set rating '{}' to book with id: '{}'."
.format(request.user, rating_form.cleaned_data['rating'], rating_form.cleaned_data['book']))
# ----------------------------------------------------------------------------------------------------------------------
def get_related_objects_for_create(user_id, book_form):
"""
Selects related objects to book instance when create new book; creates author object if needed.
:param int user_id: The id of user.
:param app.forms.AddBookForm book_form: The form with received data.
:return: A dict of objects related to book.
"""
try:
author = Author.objects.get(author_name__iexact=book_form.cleaned_data['author'])
except ObjectDoesNotExist:
author = Author.objects.create(author_name=book_form.cleaned_data['author'])
logger.info("Created new author with name: '{}' and id: '{}'."
.format(author.author_name, author.id))
category = Category.objects.get(category_name=book_form.cleaned_data['category'])
lang = Language.objects.get(language=book_form.cleaned_data['language'])
user = TheUser.objects.get(id_user=user_id)
return {'author': author, 'category': category, 'lang': lang, 'user': user}
# ------------------------------------------------------------------------------------------------------------------
def get_related_objects_create_api(user, data):
"""
Selects related object for book instance when create a new book; creates author object if needed.
"""
try:
author = Author.objects.get(author_name__iexact=data.get('author'))
except ObjectDoesNotExist:
author = Author.objects.create(author_name=data.get('author'))
logger.info("Created new author with name: '{}' and id: '{}'."
.format(author.author_name, author.id))
category = Category.objects.get(category_name=data.get('category'))
lang = Language.objects.get(language=data.get('language'))
return {'author': author, 'category': category, 'lang': lang}
# ------------------------------------------------------------------------------------------------------------------
def is_user_exists(request):
"""
Checks if user is exists. If exists return True, else False.
"""
try:
User.objects.get(username=request.data.get('username'))
return Response({'status': 200,
'detail': 'successful',
'data': {'user': True}})
except ObjectDoesNotExist:
return Response({'status': 200,
'detail': 'successful',
'data': {'user': False}})
# ----------------------------------------------------------------------------------------------------------------------
def is_mail_exists(request):
"""
Checks if mail is exists. If exists return True, else False.
"""
try:
User.objects.get(email=request.data.get('email'))
return Response({'status': 200,
'detail': 'successful',
'data': {'email': True}})
except ObjectDoesNotExist:
return Response({'status': 200,
'detail': 'successful',
'data': {'email': False}})
# ----------------------------------------------------------------------------------------------------------------------
def resolve_user_or_group(self, old_id):
"""Resolve a user by its user id from old dudel."""
# connect to db
conn = psycopg2.connect(self.conn_string)
cursor = conn.cursor()
cursor.execute('SELECT username FROM "user" WHERE id=%s', (old_id,))
username = cursor.fetchone()
try:
if username:
return get_user_model().objects.get(username=username[0])
else:
cursor.execute('SELECT name FROM "group" WHERE id=%s', (old_id,))
groupname = cursor.fetchone()
if groupname:
return Group.objects.get(name=groupname[0])
except ObjectDoesNotExist:
return None
def connect(self, **kwargs):
"""Connect to standard set of databases. Optionally override in
derived class named "Connector" to connect to own databases (mostly
useful for custom REST interfaces). Define or import "Connector" class
in app's `views.py` (where @mapi_func is used)."""
try:
self.default_db = self.get_database('mpcontribs_read')
except ObjectDoesNotExist:
try:
from home.models import DBConfig
except ImportError:
from models import DBConfig
dbconf = DBConfig(
release=self.release, db_type='mpcontribs_read',
config="host: 0.0.0.0\ndb: mpcontribs\nport: 27017"
)
dbconf.save()
self.default_db = self.get_database('mpcontribs_read')
def pre_save(self, model_instance, add):
if getattr(model_instance, self.attname) is None:
# no current value
try:
qs = self.model.objects.all()
if self.for_fields:
# filter by objects with the same field
# values for the fields in "for_fields"
query = {field: getattr(model_instance, field) for field in self.for_fields}
qs = qs.filter(**query)
# get the order of the last item
last_item = qs.latest(self.attname)
value = last_item.order + 1
except ObjectDoesNotExist:
value = 0
setattr(model_instance, self.attname, value)
return value
else:
return super(OrderField, self).pre_save(model_instance, add)
def get_process_single(self, id):
#####
# Retrieves a single object
#####
try:
clean_id = int(id)
except:
return status.HTTP_400_BAD_REQUEST
try:
object = self.Meta.Model.objects.get(id=clean_id)
except ObjectDoesNotExist:
return status.HTTP_404_NOT_FOUND
self.setResult(object.get_as_dict())
return status.HTTP_200_OK
def delete_process_single(self, id):
#####
# Deletes a single product
#####
try:
clean_id = int(id)
except:
return status.HTTP_400_BAD_REQUEST
try:
object = self.Meta.Model.objects.get(id=clean_id)
except ObjectDoesNotExist:
return status.HTTP_404_NOT_FOUND
object.delete()
return status.HTTP_200_OK
def suggest(request):
'''
Suggest gene names based on the input text
'''
# suggestions are taken from a gene annotations tileset
tileset_uuid = request.GET['d']
text = request.GET['ac']
try:
tileset = tm.Tileset.objects.get(uuid=tileset_uuid)
except ObjectDoesNotExist:
raise rfe.NotFound('Suggestion source file not found')
result_dict = tsu.get_gene_suggestions(
tut.get_datapath(tileset.datafile.url), text
)
return JsonResponse(result_dict, safe=False)
def __get__(self, instance, instance_type=None):
if instance is None:
return self
try:
return getattr(instance, self.cache_attr)
except AttributeError:
rel_obj = None
# Make sure to use ContentType.objects.get_for_id() to ensure that
# lookups are cached (see ticket #5570). This takes more code than
# the naive ``getattr(instance, self.ct_field)``, but has better
# performance when dealing with GFKs in loops and such.
f = self.model._meta.get_field(self.ct_field)
ct_id = getattr(instance, f.get_attname(), None)
if ct_id is not None:
ct = self.get_content_type(id=ct_id, using=instance._state.db)
try:
rel_obj = ct.get_object_for_this_type(pk=getattr(instance, self.fk_field))
except ObjectDoesNotExist:
pass
setattr(instance, self.cache_attr, rel_obj)
return rel_obj
def verify_fk(self, feat, rel_model, rel_mapping):
"""
Given an OGR Feature, the related model and its dictionary mapping,
this routine will retrieve the related model for the ForeignKey
mapping.
"""
# TODO: It is expensive to retrieve a model for every record --
# explore if an efficient mechanism exists for caching related
# ForeignKey models.
# Constructing and verifying the related model keyword arguments.
fk_kwargs = {}
for field_name, ogr_name in rel_mapping.items():
fk_kwargs[field_name] = self.verify_ogr_field(feat[ogr_name], rel_model._meta.get_field(field_name))
# Attempting to retrieve and return the related model.
try:
return rel_model.objects.using(self.using).get(**fk_kwargs)
except ObjectDoesNotExist:
raise MissingForeignKey(
'No ForeignKey %s model found with keyword arguments: %s' %
(rel_model.__name__, fk_kwargs)
)
def verify_fk(self, feat, rel_model, rel_mapping):
"""
Given an OGR Feature, the related model and its dictionary mapping,
this routine will retrieve the related model for the ForeignKey
mapping.
"""
# TODO: It is expensive to retrieve a model for every record --
# explore if an efficient mechanism exists for caching related
# ForeignKey models.
# Constructing and verifying the related model keyword arguments.
fk_kwargs = {}
for field_name, ogr_name in rel_mapping.items():
fk_kwargs[field_name] = self.verify_ogr_field(feat[ogr_name], rel_model._meta.get_field(field_name))
# Attempting to retrieve and return the related model.
try:
return rel_model.objects.using(self.using).get(**fk_kwargs)
except ObjectDoesNotExist:
raise MissingForeignKey(
'No ForeignKey %s model found with keyword arguments: %s' %
(rel_model.__name__, fk_kwargs)
)
def clean(self):
cleaned_data = super(AddToCartForm, self).clean()
quantity = cleaned_data.get('quantity')
if quantity is None:
return cleaned_data
try:
product_variant = self.get_variant(cleaned_data)
except ObjectDoesNotExist:
msg = self.error_messages['variant-does-not-exists']
self.add_error(NON_FIELD_ERRORS, msg)
else:
cart_line = self.cart.get_line(product_variant)
used_quantity = cart_line.quantity if cart_line else 0
new_quantity = quantity + used_quantity
try:
product_variant.check_quantity(new_quantity)
except InsufficientStock as e:
remaining = e.item.get_stock_quantity() - used_quantity
if remaining:
msg = self.error_messages['insufficient-stock']
self.add_error('quantity', msg % remaining)
else:
msg = self.error_messages['empty-stock']
self.add_error('quantity', msg)
return cleaned_data
def move_to_group(self, item, target_group, quantity):
try:
target_item = target_group.items.get(
product=item.product, product_name=item.product_name,
product_sku=item.product_sku)
except ObjectDoesNotExist:
target_group.items.create(
delivery_group=target_group, product=item.product,
product_name=item.product_name, product_sku=item.product_sku,
quantity=quantity, unit_price_net=item.unit_price_net,
stock=item.stock,
unit_price_gross=item.unit_price_gross)
else:
target_item.quantity += quantity
target_item.save()
item.quantity -= quantity
self.remove_empty_groups(item)
def speaker_create_staff(request, pk):
user = get_object_or_404(User, pk=pk)
if not request.user.is_staff:
raise Http404
try:
return redirect(user.speaker_profile)
except ObjectDoesNotExist:
pass
if request.method == "POST":
form = SpeakerForm(request.POST, request.FILES)
if form.is_valid():
speaker = form.save(commit=False)
speaker.user = user
speaker.save()
messages.success(request, "Speaker profile created.")
return redirect("user_list")
else:
form = SpeakerForm(initial={"name": user.get_full_name()})
return render(request, "speakers/speaker_create.html", {
"form": form,
})
def speaker_create_token(request, token):
speaker = get_object_or_404(Speaker, invite_token=token)
request.session["pending-token"] = token
if request.user.is_authenticated():
# check for speaker profile
try:
existing_speaker = request.user.speaker_profile
except ObjectDoesNotExist:
pass
else:
del request.session["pending-token"]
additional_speakers = ProposalBase.additional_speakers.through
additional_speakers._default_manager.filter(
speaker=speaker
).update(
speaker=existing_speaker
)
messages.info(request, "You have been associated with all pending "
"talk proposals")
return redirect("dashboard")
else:
if not request.user.is_authenticated():
return redirect("account_login")
return redirect("speaker_create")
def proposal_submit(request):
if not request.user.is_authenticated():
return redirect("home") # @@@ unauth'd speaker info page?
else:
try:
request.user.speaker_profile
except ObjectDoesNotExist:
return redirect("dashboard")
kinds = []
for proposal_section in ProposalSection.available():
for kind in proposal_section.section.proposal_kinds.all():
kinds.append(kind)
return render(request, "proposals/proposal_submit.html", {
"kinds": kinds,
})
def proposal_leave(request, pk):
queryset = ProposalBase.objects.select_related("speaker")
proposal = get_object_or_404(queryset, pk=pk)
proposal = ProposalBase.objects.get_subclass(pk=proposal.pk)
try:
speaker = proposal.additional_speakers.get(user=request.user)
except ObjectDoesNotExist:
return HttpResponseForbidden()
if request.method == "POST":
proposal.additional_speakers.remove(speaker)
# @@@ fire off email to submitter and other speakers
messages.success(request, "You are no longer speaking on %s" % proposal.title)
return redirect("dashboard")
ctx = {
"proposal": proposal,
}
return render(request, "proposals/proposal_leave.html", ctx)
def proposal_submit(request):
if not request.user.is_authenticated():
return redirect("home") # @@@ unauth'd speaker info page?
else:
try:
request.user.speaker_profile
except ObjectDoesNotExist:
return redirect("dashboard")
kinds = []
for proposal_section in ProposalSection.available():
for kind in proposal_section.section.proposal_kinds.all():
kinds.append(kind)
return render(request, "proposals/proposal_submit.html", {
"kinds": kinds,
})
def reject_suggestion(request, unit, suggid):
try:
sugg = unit.suggestion_set.get(id=suggid)
except ObjectDoesNotExist:
raise Http404
# In order to be able to reject a suggestion, users have to either:
# 1. Have `review` rights, or
# 2. Be the author of the suggestion being rejected
if (not check_permission('review', request) and
(request.user.is_anonymous or request.user != sugg.user)):
raise PermissionDenied(_('Insufficient rights to access review mode.'))
unit.reject_suggestion(sugg, request.translation_project, request.user)
r_data = QueryDict(request.body)
if "comment" in r_data and r_data["comment"]:
handle_suggestion_comment(request, sugg, unit, r_data["comment"],
"rejected")
json = {
'udbid': unit.id,
'sugid': suggid,
'user_score': request.user.public_score,
}
return JsonResponse(json)
def accept_suggestion(request, unit, suggid):
try:
suggestion = unit.suggestion_set.get(id=suggid)
except ObjectDoesNotExist:
raise Http404
unit.accept_suggestion(suggestion, request.translation_project, request.user)
if "comment" in request.POST and request.POST["comment"]:
handle_suggestion_comment(request, suggestion, unit,
request.POST["comment"], "accepted")
json = {
'udbid': unit.id,
'sugid': suggid,
'user_score': request.user.public_score,
'newtargets': [target for target in unit.target.strings],
'checks': _get_critical_checks_snippet(request, unit),
}
return JsonResponse(json)
def pluralize_target(unit, nplurals=None):
if not unit.hasplural():
return [(0, unit.target, None)]
if nplurals is None:
try:
nplurals = unit.store.translation_project.language.nplurals
except ObjectDoesNotExist:
pass
forms = []
if nplurals is None:
for i, target in enumerate(unit.target.strings):
forms.append((i, target, _('Plural Form %d', i)))
else:
for i in range(nplurals):
try:
target = unit.target.strings[i]
except IndexError:
target = ''
forms.append((i, target, _('Plural Form %d', i)))
return forms
def get_queryset(self):
if settings.ENV_TYPE == 'debug' or settings.ENV_TYPE == 'dev':
queryset = self.queryset
try:
parent = self.request.user.parent
except (AttributeError, exceptions.ObjectDoesNotExist):
parent = None
if parent is not None:
queryset = queryset.filter(parent=parent)
else:
parent = self.get_parent()
queryset = self.queryset.filter(parent=parent)
subject_id = self.request.query_params.get('subject', None)
if subject_id is not None:
subject = get_object_or_404(models.Subject, pk=subject_id)
queryset = queryset.filter(
exercise_session__live_course_timeslot__live_course__subject=subject
)
return queryset.order_by('-updated_at')
def _get_new_field_html(self, field_name):
try:
f, attr, value = lookup_field(field_name, self.org_obj, self)
except (AttributeError, ObjectDoesNotExist):
return EMPTY_CHANGELIST_VALUE
else:
allow_tags = False
if f is None:
allow_tags = getattr(attr, 'allow_tags', False)
boolean = getattr(attr, 'boolean', False)
if boolean:
allow_tags = True
text = boolean_icon(value)
else:
text = smart_text(value)
else:
if isinstance(f.rel, models.ManyToOneRel):
field_val = getattr(self.org_obj, f.name)
if field_val is None:
text = EMPTY_CHANGELIST_VALUE
else:
text = field_val
else:
text = display_for_field(value, f)
return mark_safe(text) if allow_tags else conditional_escape(text)
def create(self, tenant=None, *args, **kwargs):
if not tenant:
tenant = get_current_tenant()
if tenant:
with transaction.atomic():
try:
model_instance = self.get_original_queryset().get(**kwargs)
except ObjectDoesNotExist:
model_instance = super(MultipleTenantModelManager, self).create(*args, **kwargs)
model_instance.tenants.add(tenant)
return model_instance
else:
raise TenantNotFoundError()
else:
model_instance = super(MultipleTenantModelManager, self).create(*args, **kwargs)
model_instance.tenants.add(tenant)
return model_instance
def getWorkLog(self, contract, month, year):
try:
if contract.contract_begin.year > year or \
contract.contract_end.year < year or \
(contract.contract_begin.year == year and contract.contract_begin.month > month) or \
(contract.contract_end.year == year and contract.contract_end.month < month):
raise ValidationError("Invalid workLog (shouldn't happen)")
workL = WorkLog.objects.get(contract=contract, month=month, year=year)
workSum = workL.calcHours()
except ObjectDoesNotExist:
workL = WorkLog()
workL.month = month
workL.year = year
workL.contract = contract
workL.save()
return workL
