def event_does_not_exist( request, event_id, redirect_url ): # {{{1
""" if event_id was deleted it shows event redirection or deleted page,
otherwise raises 404 """
try:
deleted_version = reversion.get_deleted(Event).get(object_id=event_id)
except Version.DoesNotExist:
raise Http404
revision_meta = deleted_version.revision.revisioninfo_set.all()
assert( len( revision_meta ) == 1 )
redirect = revision_meta[0].redirect
if redirect:
messages.info( request,
_( u'redirected from deleted event %(event_nr)s' ) % \
{'event_nr': event_id} )
return HttpResponseRedirect( reverse( redirect_url,
kwargs = {'event_id': redirect,} ) )
else:
messages.info( request,
_('You have tried to access an event which has been deleted.'))
return HttpResponseRedirect( reverse(
'event_deleted', kwargs = { 'event_id': event_id } ) )
python类DoesNotExist()的实例源码
def _set_startdate(self, value):
try:
eventdate = self.dates.get( eventdate_name = 'start' )
if value:
eventdate.eventdate_date = value
eventdate.save()
self.startdate_cache = eventdate.eventdate_date
else:
eventdate.delete()
self.startdate_cache = None
except EventDate.DoesNotExist:
if value:
new_eventdate = self.dates.create(
eventdate_name='start',
eventdate_date = value )
self.startdate_cache = new_eventdate.eventdate_date
else:
self.startdate_cache = None
def _set_enddate(self, value):
try:
eventdate = self.dates.get(eventdate_name='end')
if value:
eventdate.eventdate_date = value
eventdate.save()
self.enddate_cache = eventdate.eventdate_date
else:
eventdate.delete()
self.enddate_cache = None
except EventDate.DoesNotExist:
if value:
new_eventdate = self.dates.create(
eventdate_name='end',
eventdate_date=value )
self.enddate_cache = new_eventdate.eventdate_date
else:
self.enddate_cache = None
def compute_dataset_basic_stats(store_key, dataset_id):
logger.info('Start computing data for {0}'.format(store_key))
try:
dataset = Dataset.objects.get(id=dataset_id)
store.set(store_key, {
'num_taxonomy_nodes': dataset.taxonomy.get_num_nodes(),
'num_sounds': dataset.num_sounds,
'num_annotations': dataset.num_annotations,
'avg_annotations_per_sound': dataset.avg_annotations_per_sound,
'percentage_validated_annotations': dataset.percentage_validated_annotations,
'num_ground_truth_annotations': dataset.num_ground_truth_annotations,
'num_verified_annotations': dataset.num_verified_annotations,
'num_user_contributions': dataset.num_user_contributions
})
logger.info('Finished computing data for {0}'.format(store_key))
except Dataset.DoesNotExist:
pass
def forgot_password(request):
name = _('Forgot Password')
if request.method == 'POST':
form = PasswordResetRequestForm(request.POST)
if form.is_valid():
data = form.cleaned_data
try:
u = User.objects.get(email=data['email'])
except(User.DoesNotExist):
messages.error(request,
'A user with the email supplied '
'does not exist.')
return HttpResponseRedirect(reverse('forgot_password'))
# success - user found so ask some question
return HttpResponseRedirect(reverse('secret_question_challenge',
args=(u.username,)))
else:
return render(request,
'generic/bootstrapform.html',
{'name': name, 'form': form})
else:
return render(request,
'generic/bootstrapform.html',
{'name': name, 'form': PasswordResetRequestForm()})
def get_backend_authenticated_client(username, backend):
"""Creates a new authenticated client for the user
and backend
@type username: str
@type backend: str
@rtype: api_server.clients.base_client.BaseAuthenticatedClient
@raises e: ClientError
@raises e: BackendsError
"""
try:
user = User.objects.get(username__iexact=username)
except User.DoesNotExist:
raise BackendsUserError('{} does not exist.'.format(username))
client = get_backend_client(backend)
try:
password = user.profile.get_credential(backend).get_password()
except Profile.NoCredentials:
raise BackendsUserError('{user} does not have access to {backend}.'.format(
user=username, backend=backend))
c, _ = client.login_or_register(
user.username, password, user.email)
return c
def delete(self, request, group_name):
"""
Delete a group. The user has to be an admin or the creator of the group
Args:
request: Django rest framework request
group_name: Group name from the request
Returns:
Http status of the request
"""
try:
group = Group.objects.get(name=group_name)
bgroup = BossGroup.objects.get(group=group)
bpm = BossPrivilegeManager(request.user)
if request.user == bgroup.creator or bpm.has_role('admin'):
group.delete()
return Response(status=204)
else:
return BossHTTPError('Groups can only be deleted by the creator or administrator',
ErrorCodes.MISSING_ROLE)
except Group.DoesNotExist:
return BossGroupNotFoundError(group_name)
def active_user(request, token): # ??????
try:
username = token_confirm.confirm_validate_token(token)
except:
username = token_confirm.remove_validate_token(token)
users = User.objects.filter(username=username)
for user in users:
user.delete()
return render(request, 'message.html',
{'message': u'????????????????<a href=\"' + unicode(settings.DOMAIN) + u'/signup\">??</a>'})
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
return render(request, 'message.html', {'message': u"????????????????????"})
user.is_active = True
user.save()
message = u'????????<a href=\"' + unicode(settings.ROOT_URLCONF) + u'/login\">??</a>??'
return render(request, 'message.html', {'message':message})
def delete(request):
if request.method != 'POST':
return HttpResponseRedirect('/crm/search/')
try:
person = Person.objects.get(pk=request.POST['person_id'])
except (Person.DoesNotExist, MultiValueDictKeyError):
raise Http404('Person has already been deleted')
# copy contact data to DeletedConcact
for contact in person.contact_set.all():
del_contact = DeletedContact(
original_pk=contact.pk,
original_person_id=contact.author.pk,
event=contact.event,
date_of_contact=contact.date_of_contact,
notes=contact.notes,
method=contact.notes,
)
del_contact.save()
add_change_record(person, 'delete', request.user)
person.delete()
return HttpResponseRedirect('/crm/search/')
def _update_territory_specfics(self):
try:
self.event_assignment = EventAssignment.objects.get(
pk=self.request.session['assignment_id']
)
my_territory = self.build_user_territory_list(True)
self.in_territory = self.object in my_territory
if self.in_territory:
try:
self.flag = Flags.objects.get(
person=self.object,
event_assignment=self.event_assignment
)
except Flags.DoesNotExist:
pass # default flag=False is fine
except EventAssignment.DoesNotExist:
pass # default values are fine
def save_category_changes(request):
updated_category_success = None
category_form = PersonCategoryUpdateForm()
if request.method == 'POST':
try:
person = Person.objects.get(pk=request.POST['person_id'])
add_to_recent_contacts(request, request.POST['person_id'])
category_form = PersonCategoryUpdateForm(request.POST,
instance=person)
if category_form.is_valid():
category_form.save()
updated_category_success = True
except (Person.DoesNotExist, MultiValueDictKeyError):
raise Http404('Sorry, this person seems to have been deleted ' \
'from the database.')
context = {
'updated_category_success': updated_category_success,
'category_form': category_form,
}
return render(request, 'crm/detail_addins/detail_categorize.html', context)
def save_person_details(request):
""" ajax call to save person details and update that section of page """
updated_details_success = None
person = None
person_details_form = PersonDetailsForm()
if request.method == 'POST':
try:
person = Person.objects.get(pk=request.POST['person_id'])
add_change_record(person, 'update', request.user)
add_to_recent_contacts(request, request.POST['person_id'])
person_details_form = PersonDetailsForm(request.POST,
instance=person)
if person_details_form.is_valid():
person_details_form.save()
updated_details_success = True
except (Person.DoesNotExist, MultiValueDictKeyError):
raise Http404('Sorry, this person seems to have been deleted ' \
'from the database')
context = {
'person': person,
'person_details_form': person_details_form,
'updated_details_success': updated_details_success
}
return render(request, 'crm/detail_addins/person_detail_edit_panel.html', context)
def handle(self, *args, **kwargs):
# only creates user if it does not exists
username = kwargs['username']
password = kwargs['password']
try:
user = User._default_manager.get(username=username)
except User.DoesNotExist:
# user need to be created
u = User(username=username)
u.set_password(password)
u.is_staff = True
u.is_superuser = True if kwargs['is_admin'] else False
u.save()
else:
if kwargs['force_update']:
user.password = password
user.is_superuser = True if kwargs['is_admin'] else False
user.save()
else:
return 'user already exists'
def activate(request, uidb64, token):
try:
uid = force_text(urlsafe_base64_decode(uidb64))
user = User.objects.get(pk=uid)
except (TypeError, ValueError, OverflowError, User.DoesNotExist):
user = None
if user is not None and account_activation_token.check_token(user, token):
user.is_active = True
user.profile.email_confirmed = True
user.save()
login(request, user)
return redirect('post_detail')
else:
return render(request, 'blog/post_list.html')
def authenticate(self, request, signature, csrf_token, username=None):
channel = grpc.insecure_channel(settings.LND_RPCHOST)
stub = lnrpc.LightningStub(channel)
verifymessage_resp = stub.VerifyMessage(ln.VerifyMessageRequest(msg=csrf_token, signature=signature))
if not verifymessage_resp.valid:
print "Invalid signature"
return None
pubkey = verifymessage_resp.pubkey
# Try fetching an existing profile
try:
profile = Profile.objects.get(identity_pubkey=pubkey)
return profile.user
except Profile.DoesNotExist:
# Create a new profile if they provided a username
if len(username) > 3 and len(username) < 36:
user = User(username=username)
user.save()
profile, created = Profile.objects.get_or_create(
user=user,
identity_pubkey=pubkey)
assert created is True
# TODO Auth them in
else:
raise Exception("No username provided")
return user
def get_user(self, user_id):
try:
return User.objects.get(pk=user_id)
except User.DoesNotExist:
return None
def login(request):
form = None
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
data = form.data
if '@' in data['identity']:
kwargs = {'email': data['identity'].lower()}
else:
kwargs = {'username': data['identity'].lower()}
try:
user = User.objects.get(**kwargs)
if user is not None and user.check_password(data['password']):
login(request, user)
if 'keep_connected' in data:
request.session.set_expiry(0)
next_page = request.GET.get('next', None)
redirect_path = reverse('home')
if next_page is not None and next_page != '':
redirect_path = next_page
user_account = Account.get_by_user(user=user)
request.session['user_avatar'] = user_account.user_avatar
request.session.save()
return redirect(redirect_path)
except User.DoesNotExist:
pass
return render(request, 'index.html', {'form': form})
def generate_username(self, form):
def random_username():
h = hashlib.sha1(form.cleaned_data["email"]).hexdigest()[:25]
# don't ask
n = random.randint(1, (10 ** (5 - 1)) - 1)
return "%s%d" % (h, n)
while True:
try:
username = random_username()
User.objects.get(username=username)
except User.DoesNotExist:
break
return username
