def password_reset(request): post_reset_redirect = reverse('django.contrib.auth.views.password_reset_done') if request.method == "POST": form = PasswordResetForm(request.POST) if form.is_valid(): opts = { 'use_https': request.is_secure(), 'token_generator': default_token_generator, 'from_email': None, 'email_template_name': 'mail/password_reset_body.html', 'subject_template_name': 'mail/password_reset_subject.txt', 'request': request, } form.save(**opts) return JsonResponse({'status': True, 'redirect': post_reset_redirect}) else: status = False else: form = PasswordResetForm() status = True context = { 'form': form, } if request.is_ajax(): return JsonResponse({'status': status, 'template': render_to_string( 'account/password_reset/reset_form.html', context, context_instance=RequestContext(request))}) return TemplateResponse(request, 'account/password_reset/reset_container.html', context)
def password_reset(request): """Password reset form. Based on django.contrib.auth.views. This view sends the email. """ if request.method == "POST": form = PasswordResetForm(request.POST) was_valid = form.is_valid() if was_valid: try_send_email_with_form( form.save, form, 'email', use_https=request.is_secure(), token_generator=default_token_generator, email_template_name='users/email/pw_reset.ltxt') # Form may now be invalid if email failed to send. # PasswordResetForm is invalid iff there is no user with the entered # email address. # The condition below ensures we don't leak existence of email address # _unless_ sending an email fails. if form.is_valid() or not was_valid: # Don't leak existence of email addresses. return HttpResponseRedirect(reverse('users.pw_reset_sent')) else: form = PasswordResetForm() return jingo.render(request, 'users/pw_reset_form.html', {'form': form})
def forget_password(request,*args,**kwargs): if request.method == "POST": form = PasswordResetForm(request.POST) if form.is_valid(): user=form.get_users(form.cleaned_data['email']) if user is not None: user.reset_password_code=make_password(user.username,'reset_password',hasher='pbkdf2_sha256') subject='password reset' message='please open the link below to activate your account\n'\ +SITE_URL+'people/'+user.username+'/reset_password_code/'+tokens user.email_user(subject,message,EMAIL_SENDER) user.save() return redirect('/people/reset_password_done/') else: username=None context={'title':'activation','message':'your account has been activated or activation code is out of date'} redirect('/people/%s/' %username,context) # return HttpResponseRedirect(post_reset_redirect) else: form = PasswordResetForm() context = { 'form': form, 'title':'Password reset', } return render(request, 'people/reset_password.html',context)
def handle_noargs(self, **options): # user = User.objects.get(pk=1) group = Group.objects.get(pk=2) # group.students.add(user) for student in sys.stdin: fields = student.strip().split(' ') email = fields[0] # print email, len(fields) if len(fields) > 3: continue username = email.split('@')[0] last_name = fields[1] first_name = fields[2] print email, username, last_name, first_name user, created = User.objects.get_or_create(username=username, first_name=first_name, last_name=last_name, email=email) group.students.add(user) reset_form = PasswordResetForm({'email': email}) print reset_form reset_form.save() group.save()
def request_password_change(email, orig_host, is_secure): """Email a single-use link for performing a password reset. Users must confirm the password change before we update their information. Args: email (string): An email address orig_host (string): An originating host, extracted from a request with get_host is_secure (Boolean): Whether the request was made with HTTPS Returns: None Raises: AccountUserNotFound AccountRequestError """ # Binding data to a form requires that the data be passed as a dictionary # to the Form class constructor. form = PasswordResetForm({'email': email}) # Validate that an active user exists with the given email address. if form.is_valid(): # Generate a single-use link for performing a password reset # and email it to the user. form.save( from_email=settings.DEFAULT_FROM_EMAIL, domain_override=orig_host, use_https=is_secure ) else: # No active user with the provided email address exists. raise AccountUserNotFound
def send_user_password_reset_email(user, request, new_user): """ Send a password reset email to the user. The http request object is also required in order to figure out the URL to include in the email. :param user: CtsUser :param request: HttpRequest :param new_user: Whether user is new """ # Code copied and adapted from django.contrib.auth.views.password_reset(). form_data = { 'email': user.email, } reset_form = PasswordResetForm(form_data) if reset_form.is_valid(): opts = { 'use_https': request.is_secure(), 'token_generator': PasswordResetTokenGenerator(), 'from_email': None, 'request': request, } if new_user: opts['email_template_name'] = 'accounts/new_account_email.html' opts['subject_template_name'] = 'accounts/new_account_subject.txt' else: opts['email_template_name'] = 'accounts/password_reset_email.html' opts['subject_template_name'] = 'accounts/password_reset_subject.txt' reset_form.save(**opts)
def test_nonexistant_email(self): # Test nonexistant email address. This should not fail because it would # expose information about registered users. data = {'email': '*****@*****.**'} form = PasswordResetForm(data) self.assertTrue(form.is_valid()) self.assertEqual(len(mail.outbox), 0)
def testValidUser(self): data = { 'email': '*****@*****.**', } form = PasswordResetForm(data) self.assertEqual(form.is_valid(), False) self.assertEqual(form["email"].errors, [u"That e-mail address doesn't have an associated user account. Are you sure you've registered?"])
def password_reset(request, template): """Password reset form. Based on django.contrib.auth.views. This view sends the email. """ if request.method == "POST": form = PasswordResetForm(request.POST) was_valid = form.is_valid() if was_valid: # TODO: Since we're using Jingo in a way that doesn't # override the Django template loader, the pw_reset.ltxt # email template must be a Django template and not a Jinja # template. # # After we switch all the rendering everywhere, we can # probably change this back. Until then, I'm pretty sure # this won't get translated. try_send_email_with_form( form.save, form, 'email', use_https=request.is_secure(), token_generator=default_token_generator, email_template_name='users/email/pw_reset.ltxt') # Form may now be invalid if email failed to send. # PasswordResetForm is invalid iff there is no user with the entered # email address. # The condition below ensures we don't leak existence of email address # _unless_ sending an email fails. if form.is_valid() or not was_valid: # Don't leak existence of email addresses. return HttpResponseRedirect(reverse('users.pw_reset_sent')) else: form = PasswordResetForm() return jingo.render(request, template, {'form': form})
def password_reset(request): """ View for entering email of registered player to change password :param request: """ if request.user.is_authenticated(): return HttpResponseRedirect(reverse("index")) context = {} if request.method == "POST": form = PasswordResetForm(request.POST) if form.is_valid(): opts = { "use_https": request.is_secure(), "token_generator": default_token_generator, "from_email": settings.KASKA_EMAIL, "email_template_name": "players/email/email_template.html", "subject_template_name": "players/email/email_subject.txt", "request": request, } try: Player.objects.get(email__iexact=form.cleaned_data["email"]) except Player.DoesNotExist: return HttpResponseRedirect(reverse("players:password_reset_no_email")) else: form.save(**opts) return HttpResponseRedirect(reverse("players:password_reset_check_email")) else: form = PasswordResetForm() context.update({"form": form}) return render(request, "players/password_reset/password_reset.html", context)
def user_password_reset(self, request, id, form_url=''): from django.contrib.auth.tokens import default_token_generator from django.contrib.auth.forms import PasswordResetForm if not self.has_change_permission(request): raise PermissionDenied user = get_object_or_404(self.get_queryset(request), pk=id) post_reset_redirect = urlresolvers.reverse('admin:%s_%s_change' % (self.model._meta.app_label, self.model._meta.model_name), args=(id,)) form = PasswordResetForm({'email': user.email}) if form.is_valid(): opts = { 'use_https': request.is_secure(), 'token_generator': default_token_generator, 'from_email': None, 'email_template_name': 'registration/password_reset_email.html', 'subject_template_name': 'registration/password_reset_subject.txt', 'request': request, } opts = dict(opts, domain_override=request.get_host()) form.save(**opts) msg = ugettext('Password reset link sent.') messages.success(request, msg) else: msg = ugettext('Error ocurred while sending password reset link.') messages.error(request, msg) return HttpResponseRedirect(post_reset_redirect)
def test_cleaned_data(self): # Regression test (user, username, email) = self.create_dummy_user() data = {"email": email} form = PasswordResetForm(data) self.assertTrue(form.is_valid()) self.assertEqual(form.cleaned_data["email"], email)
def post(self, request, format=None): serializer = self.serializer_class(data=request.DATA) if serializer.is_valid(): # Create PasswordResetForm with the serializer password_reset_form = PasswordResetForm(data=serializer.data) if password_reset_form.is_valid(): # Set some values to be used for the send_email method. opts = { 'use_https': request.is_secure(), 'request': request, 'subject_template_name': self.subject_template_name, 'email_template_name': self.email_template_name, } password_reset_form.save(**opts) # Return the success message with OK HTTP status return Response(serializer.data) else: return Response(password_reset_form.errors, status=status.HTTP_400_BAD_REQUEST) # coming this far means there likely was a problem return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def handle(self, *args, **options): # We first retrieve all users accounts = Account.objects.all().filter(is_active=True) for account in accounts: password = Account.objects.make_random_password() account.set_password(password) account.save() opts = { 'use_https': True, 'from_email': getattr(settings, 'DEFAULT_FROM_EMAIL'), 'request': None, 'subject_template_name': 'email/authentication/welcome_subject.txt', 'html_email_template_name': 'email/authentication/html_welcome.html', 'email_template_name': 'email/authentication/welcome.html', 'domain_override': getattr(settings, 'SITE_URL'), 'extra_email_context': { 'site_url': getattr(settings, 'SITE_URL'), 'email': account.email, 'password': password } } reset_form = PasswordResetForm(dict(email=account.email)) if not reset_form.is_valid(): print reset_form.errors raise CommandError("Email not valid: " + account.email) reset_form.save(**opts)
def test_nonexistant_email(self): # Test nonexistant email address data = {'email':'*****@*****.**'} form = PasswordResetForm(data) self.assertFalse(form.is_valid()) self.assertEqual(form.errors, {'email': [u"That e-mail address doesn't have an associated user account. Are you sure you've registered?"]})
def test_cleaned_data(self): # Regression test user = User.objects.create_user("jsmith3", "*****@*****.**", "test123") data = {'email':'*****@*****.**'} form = PasswordResetForm(data) self.assertTrue(form.is_valid()) self.assertEqual(form.cleaned_data['email'], u'*****@*****.**')
def password_reset(self, request, queryset): count = 0 for user in queryset: # Do the password reset stuff. form = PasswordResetForm({'email': user.email}) if form.is_valid(): opts = { 'use_https': request.is_secure(), 'token_generator': default_token_generator, 'from_email': 'OpenData Cincy<*****@*****.**>', 'email_template_name': 'registration/password_reset_email.html', 'subject_template_name': 'registration/password_reset_subject.txt', 'request': request, } opts = dict(opts, domain_override=request.get_host()) form.save(**opts) count += 1 if count == 1: message_bit = '1 user was' else: message_bit = '%s users were' % count self.message_user(request, '%s emailed password reset instructions' % message_bit)
def test_save_html_email_template_name(self): """ Test the PasswordResetFOrm.save() method with html_email_template_name parameter specified. Test to ensure that a multipart email is sent with both text/plain and text/html parts. """ (user, username, email) = self.create_dummy_user() form = PasswordResetForm({"email": email}) self.assertTrue(form.is_valid()) form.save(html_email_template_name='registration/html_password_reset_email.html') self.assertEqual(len(mail.outbox), 1) self.assertEqual(len(mail.outbox[0].alternatives), 1) message = mail.outbox[0].message() self.assertEqual(message.get('subject'), 'Custom password reset on example.com') self.assertEqual(len(message.get_payload()), 2) self.assertTrue(message.is_multipart()) self.assertEqual(message.get_payload(0).get_content_type(), 'text/plain') self.assertEqual(message.get_payload(1).get_content_type(), 'text/html') self.assertEqual(message.get_all('to'), [email]) self.assertTrue(re.match(r'^http://example.com/reset/[\w/-]+', message.get_payload(0).get_payload())) self.assertTrue( re.match(r'^<html><a href="http://example.com/reset/[\w/-]+/">Link</a></html>$', message.get_payload(1).get_payload()) )
def add_profile(request): if request.method == 'POST': profile_formset = ProfileFormset(request.POST) if profile_formset.is_valid(): user_added = False for form in profile_formset: if form.cleaned_data: username = form.cleaned_data['username'] first_name = form.cleaned_data['first_name'] last_name = form.cleaned_data['last_name'] email = form.cleaned_data['email'] password = generate_random_id() new_user = create_profile(username, email, password, first_name, last_name) activate_profile(new_user.profile) new_user.profile.send_welcome_email(request) user_added = True reset_form = PasswordResetForm({'email': email}) assert reset_form.is_valid() reset_form.save( request=request, use_https=request.is_secure(), email_template_name='profiles/reset_password.txt', ) if user_added: messages.success(request, _('The profiles have been created')) profile_formset = ProfileFormset() else: messages.warning(request, _('Please check the fields below for error')) else: profile_formset = ProfileFormset() return render(request, 'profiles/add_profile.html', {'profile_formset': profile_formset,})
def save(self, domain_override=None, subject_template_name='registration/password_reset_subject.txt', email_template_name='registration/password_reset_email.html', use_https=False, token_generator=default_token_generator, from_email=None, request=None, html_email_template_name=None, extra_email_context=None): """ Generates a one-use only link for resetting password and sends to the user. """ email_or_username = self.cleaned_data["email_or_username"] for user in self.get_users(email_or_username): if not domain_override: current_site = get_current_site(request) site_name = current_site.name domain = current_site.domain else: site_name = domain = domain_override context = { 'email': user.email, 'domain': domain, 'site_name': site_name, 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'user': user, 'token': token_generator.make_token(user), 'protocol': 'https' if use_https else 'http', } if extra_email_context is not None: context.update(extra_email_context) dj_auth_form = PasswordResetForm() dj_auth_form.send_mail( subject_template_name, email_template_name, context, from_email, user.email, html_email_template_name=html_email_template_name, )
def password_reset(request): ''' Attempts to send a password reset e-mail. ''' if request.method != "POST": raise Http404 # By default, Django doesn't allow Users with is_active = False to reset their passwords, # but this bites people who signed up a long time ago, never activated, and forgot their # password. So for their sake, we'll auto-activate a user for whom password_reset is called. try: user = User.objects.get(email=request.POST['email']) user.is_active = True user.save() except: log.exception("Tried to auto-activate user to enable password reset, but failed.") form = PasswordResetForm(request.POST) if form.is_valid(): form.save(use_https=request.is_secure(), from_email=settings.DEFAULT_FROM_EMAIL, request=request, domain_override=request.get_host()) return HttpResponse(json.dumps({'success': True, 'value': render_to_string('registration/password_reset_done.html', {})})) else: return HttpResponse(json.dumps({'success': False, 'error': 'Invalid e-mail'}))
def passwordReset(self, request, **kwargs): self.method_check(request, allowed=['post']) postData = simplejson.loads(request.raw_post_data) key = postData['token'] user = getUserByKey(key) if user is not None: if user.is_active: data = {'email': user.email} resetForm = PasswordResetForm(data) if resetForm.is_valid(): resetForm.save() return self.create_response(request,{'status':OK, 'message': 'check your email for instructions'}) else: return self.create_response(request, {'status': SYSTEM_ERROR, 'message': 'form not valid'}) else: return self.create_response(request, {'status':FORBIDDEN, 'message':'Account disabled'}) else: return self.create_response(request, {'status': UNAUTHORIZED, 'error': 'User does not exists'})
def post(self, request): # Create a serializer with request.DATA serializer = self.serializer_class(data=request.DATA) result = {'errCode':10000,'errDesc':errMsg[10000]} if serializer.is_valid(): # Create PasswordResetForm with the serializer reset_form = PasswordResetForm(data=serializer.data) if reset_form.is_valid(): # Sett some values to trigger the send_email method. opts = { 'use_https': request.is_secure(), 'from_email': getattr(settings, 'DEFAULT_FROM_EMAIL'), 'request': request, } reset_form.save(**opts) # Return the success message with OK HTTP status return Response(result, status=status.HTTP_200_OK) else: logger.debug(reset_form._errors) logger.debug(serializer.errors) result['errCode']=10009 result['errDesc']=errMsg[10009] return Response(result, status=status.HTTP_200_OK)
def test_nonexistant_email(self): # Test nonexistant email address data = {'email': '*****@*****.**'} form = PasswordResetForm(data) self.assertFalse(form.is_valid()) self.assertEqual(form.errors, {'email': [force_text(form.error_messages['unknown'])]})
def send_email(self, request): try: reset_form = PasswordResetForm({"email": self.cleaned_data["email"]}) assert reset_form.is_valid() reset_form.save( request=request, from_email="*****@*****.**", use_https=request.is_secure(), subject_template_name="bdiadmin/account_creation_subject.txt", email_template_name="bdiadmin/account_creation_email.html", ) messages.success( request, _("Profile created and mail sent to {0}.").format( self.cleaned_data["email"] ), ) except: messages.warning( request, _("Profil created, but unable to send mail to {0}.").format( self.cleaned_data["email"] ), ) pass
def post(self, request): # Create a serializer with request.DATA serializer = self.serializer_class(data=request.DATA) if serializer.is_valid(): # Create PasswordResetForm with the serializer reset_form = PasswordResetForm(data=serializer.data) if reset_form.is_valid(): # Sett some values to trigger the send_email method. opts = { 'use_https': request.is_secure(), 'from_email': getattr(settings, 'DEFAULT_FROM_EMAIL'), 'request': request, } reset_form.save(**opts) # Return the success message with OK HTTP status return Response( {"success": "Password reset e-mail has been sent."}, status=status.HTTP_200_OK) else: return Response(reset_form._errors, status=status.HTTP_400_BAD_REQUEST) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def send_password_reset(request, user_id): user = get_object_or_404(User, id=user_id) form = PasswordResetForm({"email": user.email}) if form.is_valid(): form.save(email_template_name="auto_password_reset_email.html") messages.success(request, "Password reset email sent.") return HttpResponseRedirect(reverse("participant_overview", args=(user.id,)))
def test_inactive_user(self): # tests that inactive user cannot # receive password reset email (user, username, email) = self.create_dummy_user() user.is_active = False user.save() form = PasswordResetForm({"email": email}) self.assertFalse(form.is_valid())
def test_cleaned_data(self): (user, username, email) = self.create_dummy_user() data = {'email': email} form = PasswordResetForm(data) self.assertTrue(form.is_valid()) form.save(domain_override='example.com') self.assertEqual(form.cleaned_data['email'], email) self.assertEqual(len(mail.outbox), 1)
def form_valid(self, form): self.object, new_position = form.save(commit=False) username = form.cleaned_data['username'] password = form.cleaned_data['password'] self.object.set_password(password) url = form.cleaned_data['picture'] if url and not str(url).find('Default'): domain, path = utils.split_url(str(url)) try: extension = utils.valid_url_extension(str.lower(path)) except not extension: error = 'File was not a valid image (jpg, jpeg, png, gif)' form.non_field_errors(error) try: pil_image = Image.open(url) except utils.valid_image_size(pil_image): form.non_field_errors('Image is too large (> 4mb)') # saving this for later # try: # passed = False # passed = utils.make_thumbnail(pil_image, domain, path) # except not passed: # form.non_field_errors("Couldn't make thumbnail image") form.save(commit=True) # automatically login after registering msg = "Thanks for registering. You are now logged in." messages.info(self.request, msg) new_user = authenticate(username=username, password=password) if new_user is not None and new_user.is_active: login(self.request, new_user) reset_form = PasswordResetForm(self.request.POST) reset_form.is_valid() # Must trigger validation # Copied from django/contrib/auth/views.py : password_reset opts = { 'use_https': self.request.is_secure(), 'email_template_name': 'registration/activate.html', 'subject_template_name': 'registration/activation_email_subject.txt', 'request': self.request, # 'html_email_template_name': # provide an HTML content template if you desire. } # This form sends the email on save() reset_form.save(**opts) return redirect(self.success_url)
from django.contrib.auth.forms import PasswordResetForm from django.contrib.auth.models import User for user in User.objects.all(): reset_form = PasswordResetForm() reset_form.cleaned_data = {} reset_form.cleaned_data["email"] = user.username reset_form.save(domain_override="northeasthockeyleague.org")
def get_context_data(self, **kwargs): context = super().get_context_data(**kwargs) context.update({ 'reset_form': PasswordResetForm(), }) return context
def reset_user_password_email(user, request): if user.email: form = PasswordResetForm({'email': user.email}) form.is_valid() form.save(from_email=settings.DEFAULT_FROM_EMAIL, request=request)
def Reset(request): reset_url = 'accounts/reset.html' if request.user.is_authenticated: if request.is_ajax(): error_dict = {'username': '******'} jsonData = { 'Access-Control-Allow-Origin': "*", 'status': False, 'errors': { 'confirmphone': error_dict }, 'cookies': { 'csrftoken': request.META["CSRF_COOKIE"], 'sessionid': request.session.session_key, 'csrfmiddlewaretoken': csrf.get_token(request) } } return HttpResponse(json.dumps(jsonData), status=200, content_type='application/json') else: return HttpResponseRedirect('/') elif request.method == 'GET': if request.is_ajax(): jsonData = { 'Access-Control-Allow-Origin': "*", 'status': True, 'cookies': { 'csrftoken': request.META["CSRF_COOKIE"], 'sessionid': request.session.session_key, 'csrfmiddlewaretoken': csrf.get_token(request) } } return HttpResponse(json.dumps(jsonData), status=200, content_type='application/json') else: return render(request, reset_url, {'form': PasswordResetForm()}) elif request.method == 'POST': #Блять здесь скопируем пост, для того, чтобы преобразовать юзернейм #Я хз как по другому сделать username = request.POST['username'] post_copy = request.POST.copy() username = username.replace(' ', '') username = username.replace(')', '') username = username.replace('(', '') username = username.replace('-', '') username = username.replace('+7', '8') if username.isdigit() != True: error_dict = {'username': '******'} if request.is_ajax(): jsonData = { 'Access-Control-Allow-Origin': "*", 'status': False, 'errors': error_dict, 'cookies': { 'csrftoken': request.META["CSRF_COOKIE"], 'sessionid': request.session.session_key, 'csrfmiddlewaretoken': csrf.get_token(request) } } return HttpResponse(json.dumps(jsonData), status=200, content_type='application/json') else: return render(request, reset_url, { 'username': username, 'errors': error_dict }) #Проверим существует ли такой пользователь try: u = User.objects.get(username=username) except: error_dict = { 'username': '******' } if request.is_ajax(): jsonData = { 'Access-Control-Allow-Origin': "*", 'status': False, 'errors': error_dict, 'cookies': { 'csrftoken': request.META["CSRF_COOKIE"], 'sessionid': request.session.session_key, 'csrfmiddlewaretoken': csrf.get_token(request) } } return HttpResponse(json.dumps(jsonData), status=200, content_type='application/json') else: return render(request, reset_url, { 'username': username, 'errors': error_dict }) if request.POST['password1'] != request.POST['password2']: error_dict = { 'password2': 'Пароль и подтверждение пароля не совпадают' } if request.is_ajax(): jsonData = { 'Access-Control-Allow-Origin': "*", 'status': False, 'errors': error_dict, 'cookies': { 'csrftoken': request.META["CSRF_COOKIE"], 'sessionid': request.session.session_key, 'csrfmiddlewaretoken': csrf.get_token(request) } } return HttpResponse(json.dumps(jsonData), status=200, content_type='application/json') else: return render(request, reset_url, { 'username': username, 'errors': error_dict }) else: post_copy[ 'email'] = username + "@xxx.com" #для того чтобы использовать стандартные формы form = PasswordResetForm(post_copy) print("form_data" + str(form.data)) # print(form.username.errors) username = form.data.get('username', '') password = post_copy.get('password1', '') print(username) print('1!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!') if form.is_valid(): username = form.cleaned_data.get('email').replace( '@xxx.com', '') print("username: "******"password: "******"*", 'status': True, 'errors': { 'confirmphone': 'Для завершения восстановления пароля введите код подтверждения полученный по СМС' }, 'cookies': { 'csrftoken': request.META["CSRF_COOKIE"], 'sessionid': request.session.session_key, 'csrfmiddlewaretoken': csrf.get_token(request) } } response = HttpResponse( json.dumps(jsonData), status=200, content_type='application/json') return response else: return render( request, reset_url, { 'form': form, 'username': username, 'password1': password, 'password2': password, 'confirmphone': True, 'personaldataisallowed': True }) else: print("confirmphone = " + str(confirmphone)) if confirmphone == ConfirmCodes.GetCode( phoneNumber=username) or confirmphone == '56503': #вот тоже хуевая штука u = User.objects.get(username=username) u.set_password(password) u.save() #---------------- user = authenticate(username=username, password=password) auth_login(request, user) if request.is_ajax(): return HttpResponse( json.dumps( getJsonData(request=request, type='SIGNUP')), status=200, content_type='application/json') else: return HttpResponseRedirect('/worker/settings/') else: error_dict = { 'confirmphone': 'Код подтверждения указан неверно' } if request.is_ajax(): jsonData = { 'Access-Control-Allow-Origin': "*", 'status': False, 'errors': error_dict, 'cookies': { 'csrftoken': request.META["CSRF_COOKIE"], 'sessionid': request.session.session_key, 'csrfmiddlewaretoken': csrf.get_token(request) } } response = HttpResponse( json.dumps(jsonData), status=200, content_type='application/json') return response else: form.add_error(None, "Код подтверждения указан неверно") return render( request, reset_url, { 'form': form, 'username': username, 'password1': password, 'password2': password, 'confirmphone': True, 'errors': error_dict }) else: #print(form.username.errors) username = form.data.get('username', '') password = form.data.get('password1', '') print(username) error_dict = {} for key, value in form.errors.as_data().items(): error_dict[key] = str(value[0].message) print('' + key + ':' + str(value[0].message)) if request.is_ajax(): jsonData = { 'Access-Control-Allow-Origin': "*", 'status': False, 'errors': error_dict, 'cookies': { 'csrftoken': request.META["CSRF_COOKIE"], 'sessionid': request.session.session_key, 'csrfmiddlewaretoken': csrf.get_token(request) } } return HttpResponse(json.dumps(jsonData), status=200, content_type='application/json') else: return render( request, reset_url, { 'form': form, 'username': username, 'password1': password, 'errors': error_dict }) else: return HttpResponseRedirect('/')
def form(self, request: HttpRequest, params: Dict) -> 'forms.Form': return PasswordResetForm(params)
def test_invalid_email(self): data = {'email': 'not valid'} form = PasswordResetForm(data) self.assertFalse(form.is_valid()) self.assertEqual(form['email'].errors, [force_unicode(EmailField.default_error_messages['invalid'])])
def send_mail_task(subject_template_name, email_template_name, context, from_email, to_email, html_email_template_name): PasswordResetForm.send_mail(None, subject_template_name, email_template_name, context, from_email, to_email, html_email_template_name)
def create_user(request: HttpRequest) -> HttpResponse: header_title = "Add New User" cur_user = request.user cur_user = User.objects.get(username=cur_user.username) if request.method == 'POST': user_role = request.POST.get("user_role") new_user_data = get_post_new_user_data(cur_user, request, user_role) organisation = new_user_data['organisation'] newuser_form = new_user_data['newuser_form'] user_type = new_user_data['user_type'] if not user_role: messages.warning(request, 'Please input all the fields properly.') elif newuser_form.is_valid(): user = User.objects.filter( Q(username=newuser_form.cleaned_data['username']) | Q(email=newuser_form.cleaned_data['email'])) if not user.exists(): user = User.objects.create( first_name=newuser_form.cleaned_data['first_name'], last_name=newuser_form.cleaned_data['last_name'], email=newuser_form.cleaned_data['email'], username=newuser_form.cleaned_data['email']) user.type = user_type user.is_staff = new_user_data['is_staff'] user.set_password(newuser_form.cleaned_data['password']) user.save() newuser = newuser_form.save(commit=False) newuser.organisation = organisation newuser.role = user_role newuser.user = user newuser.save() reset_password_form = PasswordResetForm( data={'email': user.email}) if newuser_form.cleaned_data[ 'send_email'] and reset_password_form.is_valid(): reset_password_form.save( request=request, from_email=DEFAULT_FROM, subject_template_name= 'registration/password_reset_subject_new.txt', email_template_name= 'registration/password_reset_email_new.html') messages.success(request, 'New User Account created successfully.') return redirect("accounts:view_users") else: messages.warning(request, 'User Account Existing In Database') else: messages.warning(request, 'Please input all the fields properly.') user_type_form = get_user_type_form(cur_user) newuser_form = user_type_form['newuser_form'] user_type = user_type_form['user_type'] response = render( request, 'user_management/new_user.html', { 'header_title': header_title, 'newuser_form': newuser_form, 'user_type': user_type }) return response
def add_partner_user(request): if request.method == 'POST': user_form = AddUserForm(request.POST) partner_user_form = PartnerUserForm(request.POST) print user_form.is_valid(), partner_user_form.is_valid() print user_form.errors print partner_user_form.errors if user_form.is_valid() and partner_user_form.is_valid(): user_cd = user_form.cleaned_data user_name = user_cd['username'] first_name = user_cd['first_name'] last_name = user_cd['last_name'] email = user_cd['email'] partner_user_cd = partner_user_form.cleaned_data phone_number = partner_user_cd['phone_number'] organization = partner_user_cd['organization'] new_user = User.objects.create_user(username=user_name, first_name=first_name, last_name=last_name, email=email, password=get_random_string()) new_user.save() partner_user = PartnerUser.objects.create(user=new_user, phone_number = phone_number, organization = organization) partner_user.save() person_Id = uuid.uuid4() data = { "$class": "org.kibaati.PartnerUser", "email": email, "phoneNumber": phone_number, "organization": organization, "personId": person_Id, "firstName": first_name, "lastName": last_name, "balance": 0 } # access_token = '6Ks7RDiFxTTIIq6F9PtFs65w3padbW67lYE66tYXRkL4AsCGCa8Z1TXD4XbGvR2c' # params={'access_token':access_token} # cookies = request.COOKIES required_cookies = ['access_token','connect.sid'] cookies = {key: request.session[key] for key in required_cookies} try: r = requests.post('http://{}/api/PartnerUser'.format(settings.HYPER_SERVER), data=data, cookies=cookies) if r.status_code / 100 != 2: raise ValueError(r.text) except ValueError: return HttpResponse(r.text) data = { "participant": "org.kibaati.PartnerUser#{}".format(person_Id), "userID": user_name } try: r = requests.post('http://{}/api/system/identities/issue'.format(settings.HYPER_SERVER),data=data, cookies=cookies) if r.status_code / 100 != 2: raise ValueError(r.text) except: return HttpResponse(r.text) path = os.path.join(settings.BASE_DIR, 'account/cards/%s.card' % user_name) try: card = open(path, 'w') except IOError, (errno, strerror): print "I/O error(%s): %s" % (errno, strerror) card.write(r.content) card.close() set_password_form = PasswordResetForm({'email':email}) print set_password_form.is_valid(), set_password_form if set_password_form.is_valid(): print 'Reset Form is Valid' set_password_form.save( request=request, use_https=False, from_email='*****@*****.**', email_template_name='account/activate_account.html' ) print set_password_form new_user.is_active = False return HttpResponse('PartnerUser has been created')
def reset_password_email(self, email, template='telemeta/registration/password_reset_email.html'): form = PasswordResetForm({'email': email}) opts = {'from_email':self.from_email, 'email_template_name':template, 'token_generator': default_token_generator } return form.save(**opts)
def password_reset_form(context): """Tag for rendering reset_pass form and return it in place""" context.update({'form': PasswordResetForm()}) return context
def get(self, request): form = PasswordResetForm() ctx = {'form': form} return render(request, 'reset_password.html', ctx)
def new_user(request): org = get_organization(request) add_user_success = False manager = get_database_manager(request.user) if request.method == 'GET': profile_form = UserProfileForm() return render_to_response( "accountmanagement/account/add_new_user.html", { 'profile_form': profile_form, 'is_pro_sms': org.is_pro_sms, 'current_lang': get_language() }, context_instance=(RequestContext(request))) if request.method == 'POST': post_parameters = request.POST org = get_organization(request) form = UserProfileForm(organization=org, data=request.POST) if form.is_valid(): username = post_parameters['username'] role = post_parameters['role'] if not form.errors: user = User.objects.create_user(username, username, 'test123') user.first_name = post_parameters['full_name'] group = Group.objects.filter(name=role) user.groups.add(group[0]) user.save() mobile_number = post_parameters['mobile_phone'] ngo_user_profile = NGOUserProfile( user=user, title=post_parameters['title'], mobile_phone=mobile_number, org_id=org.org_id) ngo_user_profile.reporter_id = make_user_as_a_datasender( manager=manager, organization=org, current_user_name=user.get_full_name(), mobile_number=mobile_number, email=username) ngo_user_profile.save() reset_form = PasswordResetForm({"email": username}) name = post_parameters["full_name"] if role == 'Extended Users': associate_user_with_all_projects_of_organisation( manager, ngo_user_profile.reporter_id) UserActivityLog().log(request, action=ADDED_USER, detail=activity_log_detail( name, friendly_name(role))) elif role == 'Project Managers': selected_questionnaires = post_parameters.getlist( 'selected_questionnaires[]') selected_questionnaire_names = post_parameters.getlist( 'selected_questionnaire_names[]') if selected_questionnaires is None: selected_questionnaires = [] associate_user_with_projects(manager, ngo_user_profile.reporter_id, user.id, selected_questionnaires) UserActivityLog().log(request, action=ADDED_USER, detail=activity_log_detail( name, friendly_name(role), selected_questionnaire_names)) if reset_form.is_valid(): send_email_to_data_sender(reset_form.users_cache[0], request.LANGUAGE_CODE, request=request, type="created_user", organization=org) form = UserProfileForm() add_user_success = True if len(request.user.groups.filter(name__in=["NGO Admins"])) < 1: current_user_type = "Administrator" else: current_user_type = "Account-Administrator" data = { "add_user_success": add_user_success, "errors": form.errors, "current_user": current_user_type } return HttpResponse(json.dumps(data), mimetype="application/json", status=201)
def recover_password_request(request): email = request.data.get('email') # check if user is edo-user password_change_link = 'https://ac.naks.ru/auth/external/change.php' check_user_exist_data = { 'LOGIN': email, 'IS_EXIST': 'Y', 'AUTH_ID': '*****@*****.**', } edo_check_response = requests.post( password_change_link, check_user_exist_data).content.decode('utf8') if 'exist' in edo_check_response and not CustomUser.objects.filter( email=email).exists(): return Response({ 'user_recover_link': 'https://ac.naks.ru/index.php?TYPE=SEND_PWD&USER_LOGIN={}&AUTH_FORM=Y' .format(email) }) form = PasswordResetForm({'email': email}) if form.is_valid(): try: user = CustomUser.objects.get(email=form.cleaned_data['email']) # token for password reset token = default_token_generator.make_token(user) uid = urlsafe_base64_encode(force_bytes(user.pk)).decode() update_password_url = reverse('users:update-password', kwargs={ 'uid': uid, 'token': token }) plaintext_message = get_template('users/email_plain.txt') html_message = get_template('users/email_template.html') cntxt = { 'username': user, 'password_change_link': _get_absolute_url(request, update_password_url) } subject, from_email, to = 'НАКС: восстановление пароля учетной записи', '*****@*****.**', email text_content = plaintext_message.render(cntxt) html_content = html_message.render(cntxt) # Ссылка для восстановления пароля на сайте НАКС (naks.ru): # _get_absolute_url(request, update_password_url) send_mail(subject, text_content, from_email, [to], fail_silently=False, html_message=html_content) return Response({ 'password_recovery_email_sent': 'На указанный адрес отправлено письмо со \ ссылкой для восстановления пароля' }) except CustomUser.DoesNotExist: # import pdb; pdb.set_trace() return Response( {'password_recovery_error': ['Пользователь не найден']}) except SMTPException: return Response({ 'password_recovery_error': 'Ошибка отправки, обратитесь к администратору сайта' }) else: errors = [v[0] for k, v in form.errors.items()] return Response({'password_recovery_error': errors}, status=HTTP_200_OK)
def test_invalid_email(self): data = {'email': 'not valid'} form = PasswordResetForm(data) self.assertFalse(form.is_valid()) self.assertEqual(form['email'].errors, [_('Enter a valid email address.')])
def render_embeddable(request, creator=0, embeddable=0): ### re-directing to home return redirect(reverse('debra.account_views.brand_home')) try: embeddable = Embeddable.objects.get(id=embeddable) except ObjectDoesNotExist: return render(request, 'embeddables/renderable.html', { 'renderable_404': True, 'hide_header': True }, context_instance=RequestContext(request)) request_user = request.user.userprofile if request.user and request.user.is_authenticated() else None type = embeddable.type # if the type is a lottery widget, we cant use anything we've stored in the db because that data will be stale if type == Embeddable.LOTTERY_WIDGET: lottery = embeddable.lottery # if the lottery is in test mode, we have to check if its started and - if it has - remove test mode True and destroy completed entries if lottery.in_test_mode and lottery.is_running: lottery.clear_test_mode() completed_tasks = request_user.completed_lottery_tasks(lottery) if request_user else [] incomplete_tasks = request_user.incomplete_lottery_tasks(lottery).order_by('-mandatory', 'step_id') if request_user else [] all_tasks = lottery.self_tasks.order_by('-mandatory', 'step_id') mandatory_tasks = all_tasks.filter(mandatory=True) bonus_tasks = all_tasks.filter(mandatory=False) points_available = mandatory_tasks.aggregate(Sum('point_value'))['point_value__sum'] if mandatory_tasks else 0 bonus_points_available = bonus_tasks.aggregate(Sum('point_value'))['point_value__sum'] if bonus_tasks else 0 all_points_available = points_available + bonus_points_available html = render_to_string('embeddables/lottery.html', { 'time_remaining': lottery.time_remaining_dict, 'finished_mandatory': request_user.completed_mandatory_tasks(lottery) if request_user else False, 'finished_everything': len(completed_tasks) == len(all_tasks), 'lottery': lottery, 'enter_lottery_form': EnterLotteryForm(), 'embeddable': embeddable, 'completed_tasks': completed_tasks, 'last_incomplete_task': incomplete_tasks[len(incomplete_tasks) - 1] if request_user and len(incomplete_tasks) > 0 else 0, 'tasks': all_tasks, 'prizes': lottery.self_prizes, 'completed_points': completed_tasks.aggregate(Sum('point_value'))['point_value__sum'] if completed_tasks else 0, 'points_available': points_available, 'bonus_points_available': bonus_points_available, 'all_points_available': all_points_available, 'all_points_completed': lottery.total_points_completed if lottery.total_points_completed else 0, 'winners': lottery.self_completed_tasks.filter(is_winner=True).select_related('entry', 'entry__user', 'entry__user__user') if lottery.show_winners else None, 'user': request_user if request_user else None }, context_instance=RequestContext(request)) else: html = render_to_string('embeddables/collage.html', { 'html': embeddable.html }, context_instance=RequestContext(request)) response = render(request, 'embeddables/renderable.html', { 'html': html, 'hide_header': True, 'embeddable_id': embeddable.id, 'embeddable_type': embeddable.type, 'password_reset_form': PasswordResetForm(), 'next': reverse('debra.widget_views.render_embeddable', args=(creator, embeddable.id,)), 'page_title': SEO_VALUES['embeddable']['title'], 'meta_description': SEO_VALUES['embeddable']['meta_desc'] }, context_instance=RequestContext(request)) return response
def obj_create(self, bundle, **kwargs): password_form = PasswordResetForm(data=bundle.data) password_form.full_clean() password_form.save()
def get(self, request): form = PasswordResetForm() return render(request, 'benchmarks/password.html', {'form': form})
def get_context_data(self, **kwargs): context = super().get_context_data(**kwargs) # pragma: no cover context.update({ # pragma: no cover 'reset_form': PasswordResetForm(), }) return context # pragma: no cover
def new_user(request): org = get_organization(request) add_user_success = True manager = get_database_manager(request.user) if request.method == 'GET': profile_form = UserProfileForm() return render_to_response( "accountmanagement/account/add_new_user.html", { 'profile_form': profile_form, 'is_pro_sms': org.is_pro_sms, 'current_lang': get_language() }, context_instance=(RequestContext(request))) if request.method == 'POST': post_parameters = request.POST org = get_organization(request) form = UserProfileForm(organization=org, data=request.POST) errors = {} if form.is_valid(): username = post_parameters['username'].lower() role = post_parameters['role'] if not form.errors: with transaction.commit_manually(): sid = transaction.savepoint() try: user = User.objects.create_user( username, username, 'test123') user.first_name = post_parameters['full_name'] group = Group.objects.filter(name=role) user.groups.add(group[0]) user.save() mobile_number = post_parameters['mobile_phone'] ngo_user_profile = NGOUserProfile( user=user, title=post_parameters['title'], mobile_phone=mobile_number, org_id=org.org_id) ngo_user_profile.reporter_id = make_user_as_a_datasender( manager=manager, organization=org, current_user_name=user.get_full_name(), mobile_number=mobile_number, email=username) ngo_user_profile.save() handle_feature_toggle_impact_for_new_user( ngo_user_profile) reset_form = PasswordResetForm({"email": username}) name = post_parameters["full_name"] if role == 'Extended Users': link_user_to_all_projects.delay( ngo_user_profile.user_id) UserActivityLog().log(request, action=ADDED_USER, detail=activity_log_detail( name, friendly_name(role))) elif role in ['Project Managers', "No Delete PM"]: selected_questionnaires = post_parameters.getlist( 'selected_questionnaires[]') selected_questionnaire_names = post_parameters.getlist( 'selected_questionnaire_names[]') if selected_questionnaires is not None: link_user_to_some_projects.delay( ngo_user_profile.user_id, *tuple(selected_questionnaires)) UserActivityLog().log( request, action=ADDED_USER, detail=activity_log_detail( name, friendly_name(role), selected_questionnaire_names)) transaction.savepoint_commit(sid) except Exception as e: transaction.savepoint_rollback(sid) datawinners_logger.exception(e.message) add_user_success = False transaction.commit( ) #Mandatory for manually managed transaction blocks. Here it won't save anything if add_user_success and reset_form.is_valid(): send_email_to_data_sender(reset_form.users_cache[0], request.LANGUAGE_CODE, request=request, type="created_user", organization=org) form = UserProfileForm() else: add_user_success = False else: errors = form.errors add_user_success = False if len(request.user.groups.filter(name__in=["NGO Admins"])) < 1: current_user_type = "Administrator" else: current_user_type = "Account-Administrator" data = { "add_user_success": add_user_success, "errors": errors, "current_user": current_user_type } return HttpResponse(json.dumps(data), mimetype="application/json", status=201)
def password_forget_view(request): if request.method == 'POST': pass else: form = PasswordResetForm() return render(request, "auth/password_forget.html", {'form': form})
def send_reset_password_email(user, language_code): reset_form = PasswordResetForm({"email": user.email}) if reset_form.is_valid(): reset_form.save( email_template_name=_get_email_template_name_for_reset_password( language_code))
def save(self, *args, **kwargs): kwargs['email_template_name'] = 'registration/password_reset_email.txt' kwargs['html_email_template_name'] = 'registration/password_reset_email.html' PasswordResetForm.save(self, *args, **kwargs)
def test_html_autocomplete_attributes(self): form = PasswordResetForm() self.assertEqual(form.fields['email'].widget.attrs['autocomplete'], 'email')
def register(request): if settings.APP_PREVIEW and waffle.switch_is_active('browserid-login'): messages.error(request, loc('Registrations must be through browserid.')) form = None elif (settings.REGISTER_USER_LIMIT and UserProfile.objects.count() > settings.REGISTER_USER_LIMIT and not can_override_reg_limit(request)): _m = loc('Sorry, no more registrations are allowed. ' '<a href="https://developer.mozilla.org/en-US/apps">' 'Learn more</a>') messages.error(request, _m, title_safe=True, message_safe=True) form = None elif request.user.is_authenticated(): messages.info(request, _('You are already logged in to an account.')) form = None elif request.method == 'POST': form = forms.UserRegisterForm(request.POST) mkt_user = UserProfile.objects.filter(email=form.data['email'], password='') if form.is_valid(): try: u = form.save(commit=False) u.set_password(form.cleaned_data['password']) u.generate_confirmationcode() u.save() u.create_django_user() log.info(u'Registered new account for user (%s)', u) log_cef('New Account', 5, request, username=u.username, signature='AUTHNOTICE', msg='User created a new account') u.email_confirmation_code() msg = _('Congratulations! Your user account was ' 'successfully created.') messages.success(request, msg) msg = _(u'An email has been sent to your address {0} to ' 'confirm your account. Before you can log in, you ' 'have to activate your account by clicking on the ' 'link provided in this email.').format(u.email) messages.info(request, _('Confirmation Email Sent'), msg) except IntegrityError, e: # I was unable to reproduce this, but I suspect it happens # when they POST twice quickly and the slaves don't have the # new info yet (total guess). Anyway, I'm assuming the # first one worked properly, so this is still a success # case to the end user so we just log it... log.error('Failed to register new user (%s): %s' % (u, e)) return http.HttpResponseRedirect(reverse('users.login')) elif mkt_user.exists(): f = PasswordResetForm() f.users_cache = [mkt_user[0]] f.save(use_https=request.is_secure(), email_template_name='users/email/pwreset.ltxt', request=request) return jingo.render(request, 'users/newpw_sent.html', {}) else: messages.error(request, _('There are errors in this form'), _('Please correct them and resubmit.'))
def register(request): if waffle.switch_is_active('browserid-login'): messages.error(request, loc('Registrations must be through browserid.')) form = None raise http.Http404() elif request.user.is_authenticated(): messages.info(request, _('You are already logged in to an account.')) form = None elif request.method == 'POST': form = forms.UserRegisterForm(request.POST) mkt_user = UserProfile.objects.filter(email=form.data['email'], password='') if form.is_valid(): try: u = form.save(commit=False) u.set_password(form.cleaned_data['password']) u.generate_confirmationcode() u.lang = request.LANG u.save() log.info(u'Registered new account for user (%s)', u) log_cef('New Account', 5, request, username=u.username, signature='AUTHNOTICE', msg='User created a new account') u.email_confirmation_code() msg = _('Congratulations! Your user account was ' 'successfully created.') messages.success(request, msg) msg = _(u'An email has been sent to your address {0} to ' 'confirm your account. Before you can log in, you ' 'have to activate your account by clicking on the ' 'link provided in this email.').format(u.email) messages.info(request, _('Confirmation Email Sent'), msg) except IntegrityError, e: # I was unable to reproduce this, but I suspect it happens # when they POST twice quickly and the slaves don't have the # new info yet (total guess). Anyway, I'm assuming the # first one worked properly, so this is still a success # case to the end user so we just log it... log.error('Failed to register new user (%s): %s' % (u, e)) return http.HttpResponseRedirect(reverse('users.login')) elif mkt_user.exists(): # Handle BrowserID if (mkt_user.count() == 1 and mkt_user[0].source in amo.LOGIN_SOURCE_BROWSERIDS): messages.info(request, _('You already have an account.')) form = None else: f = PasswordResetForm() f.users_cache = [mkt_user[0]] f.save(use_https=request.is_secure(), email_template_name='users/email/pwreset.ltxt', request=request) return render(request, 'users/newpw_sent.html', {}) else: messages.error(request, _('There are errors in this form'), _('Please correct them and resubmit.'))
def password_reset_form(*args, **kwargs): """Custom error form""" return PasswordResetForm(*args, error_class=DivErrorList, **kwargs)
def index(request): form = PasswordResetForm() return render(request, "index.html", {"form": form})
def add_trucker(request): if request.method == 'POST': user_form = AddUserForm(request.POST) trucker_form = TruckerForm(request.POST) print user_form.is_valid(), trucker_form.is_valid() if user_form.is_valid() and trucker_form.is_valid(): user_cd = user_form.cleaned_data user_name = user_cd['username'] first_name = user_cd['first_name'] last_name = user_cd['last_name'] trucker_cd = trucker_form.cleaned_data phone_number = trucker_cd['phone_number'] new_user = User.objects.create_user(username=user_name, first_name=first_name, last_name=last_name, email=email, password=get_random_string()) new_user.save() trucker = Trucker.objects.create(user=new_user, phone_number = phone_number, organization = organization) trucker.save() person_Id = uuid.uuid4() data = { "$class": "org.kibaati.Trucker", "truckId": "", "phoneNumber": 0, "personId": "string", "firstName": "string", "lastName": "string", "balance": 0 } required_cookies = ['access_token','connect.sid'] cookies = {key: request.session[key] for key in required_cookies} try: r = requests.post('http://{}/api/Trucker'.format(settings.HYPER_SERVER), data=data, cookies=cookies) if r.status_code / 100 != 2: raise ValueError(r.text) except ValueError: return HttpResponse(r.text) data = { "participant": "org.kibaati.Trucker#{}".format(person_Id), "userID": user_name } try: r = requests.post('http://{}/api/system/identities/issue'.format(settings.HYPER_SERVER),data=data, cookies=cookies) if r.status_code / 100 != 2: raise ValueError(r.text) except: return HttpResponse(r.text) path = os.path.join(settings.BASE_DIR, 'account/cards/%s.card' % user_name) try: card = open(path, 'w') except IOError, (errno, strerror): print "I/O error(%s): %s" % (errno, strerror) card.write(r.content) card.close() set_password_form = PasswordResetForm({'email':email}) print set_password_form.is_valid(), set_password_form if set_password_form.is_valid(): print 'Reset Form is Valid' set_password_form.save( request=request, use_https=False, from_email='*****@*****.**', email_template_name='account/activate_account.html' ) print set_password_form new_user.is_active = False try: r = requests.get('http://{}/api/Trucker'.format(settings.HYPER_SERVER), cookies=cookies) if r.status_code / 100 != 2: raise ValueError(r.text) except ValueError: return HttpResponse (r.text) people = r.json() return render(request, 'account/add_trucker.html', {'section_name': section_name, 'trucker_form': trucker_form, 'user_form':user_form, 'persons':people })
def handle_uploaded_file(request, name): csvf = StringIO(request.FILES['file'].read().decode()) reader = csv.reader(csvf, delimiter=',') reader.__next__() count = 0 failcount = 0 existcount = 0 emailcount = 0 for row in reader: try: if row[1] and row[2] and row[3]: if re.match( r'^[0-9a-zA-Z_]{1,50}@[0-9a-zA-Z]{1,30}\.[0-9a-zA-Z]{1,3}$', row[1]): if (len(User.objects.all().filter(email=row[1])) > 0): targetUser = User.objects.all().filter(email=row[1])[0] targetUser.is_active = True targetUser.save() targetProfile = targetUser.profile targetProfile.program = Program.objects.all().filter( program_name=name)[0] targetProfile.points = 0 targetProfile.pre_assessment = 'No' targetProfile.post_assessment = 'No' targetProfile.save() count += 1 else: vu = RegisterUser(email=row[1], first_name=row[2], last_name=row[3], program=name) current_site = get_current_site(request) alphabet = string.ascii_letters + string.digits # theUser = User(username=generate(), password = generate_temp_password(8), first_name = row[2],last_name = row[3], email =row[1]) theUser = User(username=vu.email, first_name=row[2], last_name=row[3], email=row[1]) theUser.set_password('fitgirl1') theUser.save() profile = Profile.objects.create( user=theUser, program=Program.objects.all().filter( program_name=name)[0]) profile.save() form = PasswordResetForm({'email': theUser.email}) if form.is_valid(): request = HttpRequest() request.META[ 'SERVER_NAME'] = 'empoweru.herokuapp.com' request.META['SERVER_PORT'] = '80' form.save( request=request, from_email=settings.EMAIL_HOST_USER, subject_template_name= 'registration/new_user_subject.txt', email_template_name= 'registration/password_reset_newuser_email.html' ) if vu is not None: vu.save() count = count + 1 else: emailcount += 1 else: failcount += 1 except Exception as e: print(e) existcount += 1 return (count, failcount, existcount, emailcount)