def _reset_password(error_message=''): ''' subfunction used to reset password ''' if request.method == "POST" and request.POST['reset_pass']: if not request.POST['reset_email']: error_message = 'Email field are empty.' else: associated_users= User.objects.filter(Q(email=request.POST['reset_email'])|Q(username=request.POST['reset_email'])) if associated_users.exists(): for user in associated_users: email_temp_data = Context({ 'email': user.email, 'domain': request.META['HTTP_HOST'], 'site_name': '127.0.0.2:8000', 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'time': urlsafe_base64_encode(force_bytes(datetime.now())), 'user': user, 'token': default_token_generator.make_token(user), 'protocol': 'http', }) text_subject = get_template('chtor_admin/_res_/reset_subject.txt').render() html_content = get_template('chtor_admin/_res_/reset_email.html').render(email_temp_data) msg = EmailMultiAlternatives(text_subject, html_content, '*****@*****.**', [request.POST['reset_email']]) msg.content_subtype = "html" msg.send() messages.error(request, error_message) return render(request, 'chtor_admin/reset_password_done.html', { 'email': user.email }) else: messages.error(request, 'This username does not exist in the system.') return render(request, 'chtor_admin/reset_password.html') # send_mail('Subject here', 'Here is the message.', '*****@*****.**', [request.POST['reset_email']], fail_silently=False) messages.error(request, error_message) return render(request, 'chtor_admin/reset_password.html')
def testregister(): username = '******' password = '******' username = http.urlsafe_base64_encode(username.encode()).decode() password = http.urlsafe_base64_encode(password.encode()).decode() babyname = 'ruyi01' babyheight = 1.4 babyweight = 34 birthday = '2013-05-05' babysex = 'girl' homelng = '116.30799772131' homelat = '39.971353229973' schoollng = '116.30799772131' schoollat = '39.971353229973' homeaddr = '北京市用友软件园' schooladdr = '北京市万泉庄小学' url = 'http://localhost:8000/user/register/' headers = {'content-Type': 'application/x-www-form-urlencoded'} #payload = {'username': username, 'password': password, 'babyname': babyname, # 'babyheight':babyheight, 'babyweight':babyweight, 'birthday':birthday, # 'babysex':babysex, 'homeaddr':homeaddr, 'schooladdr':schooladdr} # payload = {'username': username, 'password': password, 'babyname': babyname, # 'birthday':birthday, 'homeaddr':homeaddr, 'schooladdr':schooladdr} payload = {'username': username, 'password': password, 'babyname': babyname, 'birthday':birthday, 'homelng':homelng, 'homelat':homelat, 'schoollng':schoollng, 'schoollat':schoollat} r = requests.post(url, data=payload, headers = headers) fp = open("test.html",'w') fp.write(r.text) fp.close() return r.text
def get_password_reset_email(user, reset_url, subject_template_name='registration/password_reset_subject.txt', # noqa email_template_name='api_password_reset_email.html', # noqa token_generator=default_token_generator, email_subject=None): """Creates the subject and email body for password reset email.""" result = urlparse(reset_url) site_name = domain = result.hostname encoded_username = urlsafe_base64_encode( b(user.username.encode('utf-8'))) c = { 'email': user.email, 'domain': domain, 'path': result.path, 'site_name': site_name, 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'username': user.username, 'encoded_username': encoded_username, 'token': token_generator.make_token(user), 'protocol': result.scheme if result.scheme != '' else 'http', } # if subject email provided don't load the subject template subject = email_subject or loader.render_to_string(subject_template_name, c) # Email subject *must not* contain newlines subject = ''.join(subject.splitlines()) email = loader.render_to_string(email_template_name, c) return subject, email
def test_user_can_reset_password(self): url = reverse("password_new") beverly = UserFactory(username="******") beverly.set_password("jack") beverly.save() mismatch_password_data = { "uid": urlsafe_base64_encode(force_bytes(beverly.pk)).decode(), "token": default_token_generator.make_token(beverly), "password": encode_string("wesley"), "confirm_password": encode_string("WESLEY") } response = self.client.post(url, mismatch_password_data, format='json') self.assertEqual(response.status_code, 400) self.assertFalse(User.objects.get(username='******').check_password('wesley')) bad_uid_data = { "uid": urlsafe_base64_encode(force_bytes(UserFactory().pk)).decode(), "token": default_token_generator.make_token(beverly), "password": encode_string("wesley"), "confirm_password": encode_string("wesley") } response = self.client.post(url, bad_uid_data, format='json') self.assertEqual(response.status_code, 400) self.assertFalse(User.objects.get(username='******').check_password('wesley')) good_data = { "uid": urlsafe_base64_encode(force_bytes(beverly.pk)).decode(), "token": default_token_generator.make_token(beverly), "password": encode_string("wesley"), "confirm_password": encode_string("wesley") } self.assertSchemaPost(url, "$setPasswordRequest", "$userResponse", good_data, None, status_OK=True) self.assertTrue(User.objects.get(username='******').check_password('wesley'))
def testupdate(): username = '******' password = '******' username = http.urlsafe_base64_encode(username.encode()).decode() password = http.urlsafe_base64_encode(password.encode()).decode() babyname = 'shenruyi2' babyheight = 1.4 babyweight = 34 birthday = '2012-08-08' babysex = 'girl' #homeaddr = '湖南省长沙市黄兴南路' homeaddr = '北京市海淀区紫金庄园' schooladdr = '北京市万泉河路小学' schoollng = '116.31789772131' schoollat = '39.971353229973' url = 'http://localhost:8000/user/update/' loginurl = 'http://localhost:8000/user/login/' headers = {'content-Type': 'application/x-www-form-urlencoded'} payload = {'username': username, 'password': password} r = requests.post(loginurl, data=payload, headers = headers) cookies = r.cookies headers = {'content-Type': 'application/x-www-form-urlencoded'} payload = { 'babyname': babyname, 'babyheight':babyheight, 'babyweight':babyweight, 'birthday':birthday, 'babysex':babysex, 'schoollng':schoollng, 'schoollat':schoollat} r = requests.post(url, data=payload, headers = headers, cookies = cookies) fp = open("test.html",'w') fp.write(r.text) fp.close() return r.text
def nav_get_next_comic(self, user): base_dir = Setting.objects.get(name='BASE_DIR').value if self.directory: folder = path.join(base_dir, self.directory.path) else: folder = base_dir dir_list = ComicBook.get_ordered_dir_list(folder) comic_index = dir_list.index(self.file_name) try: next_comic = dir_list[comic_index + 1] try: if self.directory: book = ComicBook.objects.get(file_name=next_comic, directory=self.directory) else: book = ComicBook.objects.get(file_name=next_comic, directory__isnull=True) except ComicBook.DoesNotExist: if self.directory: book = ComicBook.process_comic_book(next_comic, self.directory) else: book = ComicBook.process_comic_book(next_comic) if type(book) is str: raise IndexError comic_path = urlsafe_base64_encode(book.selector.bytes).decode() cs, _ = ComicStatus.objects.get_or_create(comic=book, user=user) index = cs.last_read_page except IndexError: if self.directory: comic_path = urlsafe_base64_encode(self.directory.selector.bytes).decode() else: comic_path = '' index = -1 return comic_path, index
def post(self, request, *args, **kwargs): form = self.form_class(request.POST) if form.is_valid(): data= form.cleaned_data["email_or_username"] if self.validate_email_address(data) is True: associated_users= User.objects.filter(Q(email=data)|Q(username=data)) if associated_users.exists(): for user in associated_users: c = { 'email': user.email, 'domain': request.META['HTTP_HOST'], 'site_name': 'SinComplique', 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'user': user, 'token': default_token_generator.make_token(user), 'protocol': 'http', } subject_template_name = 'users/password_reset_subject.txt' email_template_name = 'users/password_reset_subject.html' subject = 'Cambio de Contraseña' subject = ''.join(subject.splitlines()) email_txt = loader.render_to_string(subject_template_name, c) email_html = loader.render_to_string(email_template_name, c) send_mail(subject, email_html, settings.DEFAULT_FROM_EMAIL, [user.email]) result = self.form_valid(form) messages.success(request, 'An email has been sent to ' + data +". Please check its inbox to continue reseting password.") return result result = self.form_invalid(form) messages.warning(request, 'No user is associated with this email address') return result else: associated_users= User.objects.filter(username=data) if associated_users.exists(): for user in associated_users: c = { 'email': user.email, 'domain': request.META['HTTP_HOST'], 'site_name': 'SinComplique', 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'user': user, 'token': default_token_generator.make_token(user), 'protocol': 'http', } subject_template_name='users/password_reset_subject.txt' email_template_name='users/password_reset_subject.html' subject = loader.render_to_string(subject_template_name, c) subject = ''.join(subject.splitlines()) email_txt = loader.render_to_string(subject_template_name, c) email_html = loader.render_to_string(email_template_name, c) send_mail(subject, email_html, settings.DEFAULT_FROM_EMAIL , [user.email]) result = self.form_valid(form) messages.success(request, 'Email has been sent to ' + data +"'s email address. Please check its inbox to continue reseting password.") return result result = self.form_invalid(form) messages.error(request, 'This username does not exist in the system.') return result messages.error(request, 'Invalid Input') return self.form_invalid(form)
def register(request): """ Display the user registration form and store the :model:`auth.User` and his :model:`inviMarket.Profile` in the database. **Context** ``form`` An instace of the user registration form. ``error`` A string variable containing any general error message. **Template:** :template:`inviMarket/register.html` """ error = None if request.user.is_authenticated(): return redirect('index') if request.method == 'POST': form = RegisterForm(request.POST) if 'terms' not in request.POST: error= _("You must read and accept the terms and conditions.") elif form.is_valid(): if form.cleaned_data['last_name'] != "": return redirect('confirm') new_user = form.save() # Create a random activation key and store it in the user profile salt = hashlib.sha1(str(random.random())).hexdigest()[:5] activation_key = hashlib.sha1(salt+new_user.email).hexdigest() key_expires = timezone.now() + datetime.timedelta(2) lang = request.LANGUAGE_CODE profile = Profile(user=new_user, activation_key=activation_key, key_expires=key_expires, lang=lang, last_visit=timezone.now()) profile.save() # Send the activation key to the user text = render_to_string('email/activation.txt', {'name': new_user.first_name, 'uidb64': urlsafe_base64_encode(force_bytes(new_user.id)), 'key': activation_key, 'domain': settings.DOMAIN, }) html = render_to_string('email/activation.html', {'name': new_user.first_name, 'uidb64': urlsafe_base64_encode(force_bytes(new_user.id)), 'key': activation_key, 'domain': settings.DOMAIN, }) subject = "Account activation" send_mail(subject, text, "inviMarket <*****@*****.**>", [new_user.email], html_message=html,fail_silently=False) return redirect('confirm') else: form = RegisterForm() return render(request, 'register.html', {'form': form, 'error': error})
def new_token(user): """ The token format will be: [ts] - [token + uid]- [uid_len] :param user: :return: string """ uid = urlsafe_base64_encode(str(user.id)) return default_token_generator.make_token(user) + uid + "-" + urlsafe_base64_encode(str(len(uid)))
def send_signup_confirm_email(request, user): uid = urlsafe_base64_encode(force_bytes(user.pk)) token = token_generator.make_token(user) context = { 'user': user, 'host': request.scheme + '://' + request.META['HTTP_HOST'], 'uid': urlsafe_base64_encode(force_bytes(user.pk)) 'token': token_generator.make_token(user), }
def testgethead(): username = '******' password = '******' username = http.urlsafe_base64_encode(username.encode()).decode() password = http.urlsafe_base64_encode(password.encode()).decode() url = 'http://localhost:8000/photos/gethead/' payload = {'username': username, 'password': password} r = requests.post(url, data = payload) fp = open("test.html",'w') fp.write(r.text) fp.close()
def test_nav_last_page_with_nothing_below(self): user = User.objects.get(username='******') book = ComicBook.objects.get(file_name='test4.rar') nav = book.nav(3, user) self.assertEqual(nav.next_index, -1) self.assertEqual(nav.next_path, '') self.assertEqual(nav.prev_index, 2) self.assertEqual(nav.prev_path.encode(), urlsafe_base64_encode(book.selector.bytes)) self.assertEqual(nav.cur_index, 3) self.assertEqual(nav.cur_path.encode(), urlsafe_base64_encode(book.selector.bytes)) self.assertEqual(nav.q_prev_to_directory, False) self.assertEqual(nav.q_next_to_directory, True)
def test_nav_first_page_with_folder_above(self): book = ComicBook.objects.get(file_name='test1.rar') user = User.objects.get(username='******') nav = book.nav(0, user) self.assertEqual(nav.next_index, 1) self.assertEqual(nav.next_path.encode(), urlsafe_base64_encode(book.selector.bytes)) self.assertEqual(nav.prev_index, -1) self.assertEqual(nav.prev_path, '') self.assertEqual(nav.cur_index, 0) self.assertEqual(nav.cur_path.encode(), urlsafe_base64_encode(book.selector.bytes)) self.assertEqual(nav.q_prev_to_directory, True) self.assertEqual(nav.q_next_to_directory, False)
def test_get_topicbyid_webview(): username = '******' password = '******' username = http.urlsafe_base64_encode(username.encode()).decode() password = http.urlsafe_base64_encode(password.encode()).decode() url = 'http://localhost:8000/jiaquan/gettopicwebview/14/' headers = {'content-Type': 'application/x-www-form-urlencoded'} payload = {'username': username, 'password': password} r = requests.get(url) fp = open("test_gettopic.html",'w') fp.write(r.text) fp.close()
def avatar_path(instance, filename): uploaded_filename = os.path.join( AVATARS_PATH, urlsafe_base64_encode(instance.user.username) + "-" + urlsafe_base64_encode(str(instance.user.id)) + "." + filename.split(".")[-1], ) if os.path.isfile(uploaded_filename): os.remove(uploaded_filename) return uploaded_filename if uploaded_filename[0] not in ["/", "\\"] else uploaded_filename[1:]
def test_nav_in_comic(self): user = User.objects.get(username='******') book = ComicBook.objects.get(file_name='test1.rar', directory__isnull=True) nav = book.nav(1, user) self.assertEqual(nav.next_index, 2) self.assertEqual(nav.next_path.encode(), urlsafe_base64_encode(book.selector.bytes)) self.assertEqual(nav.prev_index, 0) self.assertEqual(nav.prev_path.encode(), urlsafe_base64_encode(book.selector.bytes)) self.assertEqual(nav.cur_index, 1) self.assertEqual(nav.cur_path.encode(), urlsafe_base64_encode(book.selector.bytes)) self.assertEqual(nav.q_prev_to_directory, False) self.assertEqual(nav.q_next_to_directory, False)
def test_get_topic(): username = '******' password = '******' username = http.urlsafe_base64_encode(username.encode()).decode() password = http.urlsafe_base64_encode(password.encode()).decode() url = 'http://localhost:8000/jiaquan/getcircletopic/' headers = {'content-Type': 'application/x-www-form-urlencoded'} payload = {'username': username, 'password': password} r = requests.post(url, data=payload, headers = headers) print(r.text) fp = open("test_gettopic.html",'w') fp.write(r.text) fp.close()
def test_add_comment(): username = '******' password = '******' topicid = 6 username = http.urlsafe_base64_encode(username.encode()).decode() password = http.urlsafe_base64_encode(password.encode()).decode() comment = '呵呵,测试一下在圈子里发个评论呗aaa。' url = 'http://localhost:8000/jiaquan/addcomment/' headers = {'content-Type': 'application/x-www-form-urlencoded'} payload = {'username': username, 'password': password, 'topicid':topicid, 'comment':comment} r = requests.post(url, data=payload, headers = headers) fp = open("test.html",'w') fp.write(r.text) fp.close()
def testgetconsumptions(): username = '******' password = '******' username = http.urlsafe_base64_encode(username.encode()).decode() password = http.urlsafe_base64_encode(password.encode()).decode() url = 'http://localhost:8000/mobile/getconsumptions/' headers = {'content-Type': 'application/x-www-form-urlencoded'} payload = {'username': username, 'password': password, 'knumber': 5, 'snumber':2, 'cnumber':2} r = requests.post(url, data=payload, headers = headers) fp = open("test.html",'w') fp.write(r.text) fp.close() return r.text
def send_signup_confirm_email(request, user): uid = urlsafe_base64_encode(force_bytes(user.pk)) token = token_generator.make_token(user) context = { "user": user, "host": request.scheme + "://" + request.META["HTTP_HOST"], "uid": urlsafe_base64_encode(force_bytes(user.pk)), "token": token_generator.make_token(user), } subject = render_to_string("accounts/signup_confirm_subject.txt", context) body = render_to_string("accounts/signup_confirm_body.txt", context) to_email = [user.email] send_mail(subject, body, None, to_email, fail_silently=False)
def send_signup_confirm_email(request, user): uid = urlsafe_base64_encode(force_bytes(user.pk)) token = token_generator.make_token(user) context = { 'user': user, 'host': request.scheme + '://' + request.META['HTTP_HOST'], 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'token': token_generator.make_token(user), } subject = render_to_string('accounts/signup_confirm_subject.txt', context).splitlines() [0] # newline 이 포함될 수 없습니다. body = render_to_string('accounts/signup_confirm_body.txt', context) to_email = [user.email] send_mail(subject, body, None, to_email, fail_silently=False)
def get(self, request, *args, **kwargs): try: user = BaseUser.objects.get(id=self.request.session["_auth_user_id"]) except (BaseUser.DoesNotExist, TypeError, ValueError, OverflowError, KeyError): return HttpResponse('{"status":"error"}', mimetype='application/json') if user.is_active: return HttpResponse('{"status": "is_already_active"}', mimetype='application/json') send_mail_time = self.request.session.get('_send_signup_mail_time', None) if send_mail_time: send_mail_time = datetime.datetime.fromtimestamp(send_mail_time) if send_mail_time + datetime.timedelta(minutes=10) > datetime.datetime.now(): return HttpResponse('{"status":"please wait 10 minutes."}', mimetype='application/json') self.request.session["_send_signup_mail_time"] = datetime.datetime.now().timestamp() token = signup_token_generator.make_token(user) current_site = get_current_site(self.request) site_name = current_site.name domain = current_site.domain use_https = self.request.is_secure() c = { 'email': user.email, 'domain': domain, 'site_name': site_name, 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'user': user, 'token': token, 'protocol': 'https' if use_https else 'http', } subject = loader.render_to_string('steam/email_confirm.html', c) user.email_user(_('Welcome SQA Game Center Project'), subject) return HttpResponse('{"status":"ok"}', mimetype='application/json')
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 = self.cleaned_data["email"] for user in self.get_users(email): 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) self.send_mail(subject_template_name, email_template_name, context, from_email, user.email, html_email_template_name=html_email_template_name)
def wrapped_func(self, request, *args, **kwargs): response_format = self.perform_content_negotiation(request)[0].format etag_user = (':'+str(request.user.pk or 0)) if response_format == 'api' else '' raw_etag = '%s%s:%s:%s' % (response_format, etag_user, get_language(), (etag_func(request) if permissions else MapUpdate.current_cache_key())) if base_mapdata_check and self.base_mapdata: raw_etag += ':%d' % request.user_permissions.can_access_base_mapdata etag = quote_etag(raw_etag) response = get_conditional_response(request, etag=etag) if response is None: cache_key = 'mapdata:api:'+request.path_info[5:].replace('/', '-').strip('-')+':'+raw_etag if cache_parameters is not None: for param, type_ in cache_parameters.items(): value = int(param in request.GET) if type_ == bool else type_(request.GET.get(param)) cache_key += ':'+urlsafe_base64_encode(str(value).encode()).decode() data = request_cache.get(cache_key) if data is not None: response = Response(data) if response is None: with GeometryMixin.dont_keep_originals(): response = func(self, request, *args, **kwargs) if cache_parameters is not None and response.status_code == 200: request_cache.set(cache_key, response.data, 900) if response.status_code == 200: response['ETag'] = etag response['Cache-Control'] = 'no-cache' return response
def save(self, subject_template_name, email_template_name, token_generator=default_token_generator, html_email_template_name=None, **_): """ Generates a one-use only link for resetting password and sends to the user. """ email = self.cleaned_data["email"] user = MONGO.retrieve_user(email) c = { 'email': user.email, 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'user': user, 'token': token_generator.make_token(user), } subject = loader.render_to_string(subject_template_name, c) # Email subject *must not* contain newlines subject = ''.join(subject.splitlines()) email = loader.render_to_string(email_template_name, c) if html_email_template_name: html_email = loader.render_to_string(html_email_template_name, c) else: html_email = None send_mail(subject, email, "*****@*****.**", [user.email], html_message=html_email)
def save(self, domain_override=None, subject_template_name='micq/email/password_reset_subject.txt', email_template_name='micq/email/password_reset_email.html', use_https=False, token_generator=default_token_generator, from_email=None, request=None, html_email_template_name=None): #生成一个一次性使用唯一的链接,重置密码,并发送至用户 email = self.cleaned_data['email'] for user in self.get_users(email): 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, #将user.pk解析成字符串,再编码以便在URL中使用 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'user': user, #生成加密验证数据 'token': token_generator.make_token(user), 'protocol': 'https' if use_https else 'http', } self.send_email(subject_template_name, email_template_name, context, from_email, user.email, html_email_template_name=html_email_template_name)
def generate_password_reset_url(user_profile: UserProfile, token_generator: PasswordResetTokenGenerator) -> str: token = token_generator.make_token(user_profile) uid = urlsafe_base64_encode(force_bytes(user_profile.id)).decode('ascii') endpoint = reverse('django.contrib.auth.views.password_reset_confirm', kwargs=dict(uidb64=uid, token=token)) return "{}{}".format(user_profile.realm.uri, endpoint)
def form_valid(self, form): user = form.save() if not self.domain_override: current_site = get_current_site(self.request) site_name = current_site.name domain = current_site.domain else: site_name = domain = self.domain_override if django.VERSION < (1, 6): encoded_uid = int_to_base36(user.pk) else: from django.utils.http import urlsafe_base64_encode from django.utils.encoding import force_bytes encoded_uid = urlsafe_base64_encode(force_bytes(user.pk)) c = { 'email': user.email, 'domain': domain, 'site_name': site_name, 'uid': encoded_uid, 'user': user, 'token': self.token_generator.make_token(user), 'protocol': 'https' if self.use_https else 'http', } subject = loader.render_to_string(self.subject_template_name, c) # Email subject *must not* contain newlines subject = ''.join(subject.splitlines()) email = loader.render_to_string(self.email_template_name, c) send_mail(subject, email, self.from_email, [user.email]) if self.success_message: messages.success(self.request, self.success_message) return super(RegistrationView, self).form_valid(form)
def account_activate_manually(request): if request.user.is_authenticated(): return HttpResponseRedirect(reverse('login')) template_name = 'registration/account_activate_manually.html' if request.method == "GET": return render(request, template_name) elif request.method == "POST": data = request.POST email = data.get('email') if email and TheUser.objects.filter(email__iexact=email).exists() and \ len(TheUser.objects.filter(email__iexact=email)) == 1: the_user = TheUser.objects.get(email__iexact=email) if not the_user.is_active: user_email = the_user.email current_site = get_current_site(request) site_name = current_site.name domain = current_site.domain context = { 'email': user_email, 'domain': domain, 'site_name': site_name, 'uid': urlsafe_base64_encode(force_bytes(the_user.id)), 'the_user': the_user, 'token': default_token_generator.make_token(the_user), 'protocol': 'http', } send_activate_email('registration/email/account_activate_subject.txt', 'registration/email/account_activate_body.html', context, settings.DEFAULT_FROM_MAIL, user_email) return HttpResponseRedirect(reverse('account_activate')) else: return HttpResponseRedirect(reverse('login'))
def user_login(request): user = request.user if user.is_authenticated and user.is_adminkvm: return HttpResponseRedirect('/home') elif user.is_authenticated and user.is_adminkvm == False: return HttpResponseRedirect('/client') else: if request.method == 'POST': # post form để User yêu cầu reset mật khẩu, gửi link về mail if 'uemail' in request.POST: form = UserResetForm(request.POST) if form.is_valid(): to_email = form.cleaned_data['uemail'] current_site = get_current_site(request) user = get_user_email(to_email) mail_subject = 'Reset password your account.' message = render_to_string( 'kvmvdi/resetpwd.html', { 'user': user, 'domain': current_site.domain, 'uid': urlsafe_base64_encode(force_bytes( user.id)).decode(), 'token': account_activation_token.make_token(user), }) email = EmailMessage(mail_subject, message, to=[to_email]) thread = EmailThread(email) thread.start() return render( request, 'kvmvdi/login.html', {'mess': 'Please check email to reset your password!'}) else: error = '' for field in form: error += field.errors return render(request, 'kvmvdi/login.html', {'error': error}) elif 'agentname' and 'agentpass' in request.POST: username = request.POST['agentname'] password = request.POST['agentpass'] user = authenticate(username=username, password=password) if user: if user.is_active and user.is_adminkvm: login(request, user) return HttpResponseRedirect('/home') elif user.is_active and user.is_adminkvm == False: login(request, user) return HttpResponseRedirect('/client') else: return render(request, 'kvmvdi/login.html', {'error': 'Your account is blocked!'}) else: return render(request, 'kvmvdi/login.html', {'error': 'Invalid username or password '}) elif 'firstname' and 'email' and 'password2' in request.POST: user_form = UserForm(request.POST) if user_form.is_valid(): user = user_form.save() ip = '192.168.40.146' username = '******' password = '******' project_name = 'admin' user_domain_id = 'default' project_domain_id = 'default' connect = keystone(ip=ip, username=username, password=password, project_name=project_name, user_domain_id=user_domain_id, project_domain_id=project_domain_id) connect.create_project(name=user.username, domain='default') check = False while check == False: if connect.find_project(user.username): check = True connect.add_user_to_project(user.username) return redirect('/') else: error = '' for field in user_form: error += field.errors return render(request, 'kvmvdi/login.html', {'error': error}) return render(request, 'kvmvdi/login.html')
def register(request): if request.user.is_authenticated: return HttpResponseRedirect(reverse('public:myprofile', )) registered = False if request.method == 'POST': user_form = SignUpForm(request.POST) regisadm_form = AdministrasiForm(request.POST) if user_form.is_valid() and regisadm_form.is_valid(): user = user_form.save() # load the profile instance created by the signal user.refresh_from_db() user.profile.phone = user_form.cleaned_data.get('phone') user.profile.date_birth = user_form.cleaned_data.get('birth_date') user.save() regadm = regisadm_form.save(commit=False) regis_pay = AdministrationType.objects.get( paymentstype="Registration and First Dues") regadm.jenis = regis_pay regadm.user = user regadm.nominal = regis_pay.nominal regadm.save() kelas = Kelas.objects.get(nama_kelas='Violin Basic') today = timezone.now().date() LogKelas.objects.create(kelas_current=kelas, user=user, joined_date=today) #<EMAIL> for treasurers bendaharas = User.objects.filter(groups__name='bendahara') subjectb = 'Pendaftar Baru ' + str(user) messageb = render_to_string( 'mails/registration-treasurers.html', { 'first_name': user.first_name, 'last_name': user.last_name, 'phone': user.profile.phone, 'method': str(regadm.method), }) from_emailb = settings.EMAIL_HOST_USER list_mail = [] for bendahara in bendaharas: list_mail.append(bendahara.email) send_mail(subjectb, messageb, from_emailb, list_mail, fail_silently=False) current_site = get_current_site(request) # </EMAIL> for new user subject = 'Segera Aktifasi Akun Anda' message = render_to_string( 'login/account_activation_email.html', { 'user': user, 'domain': current_site.domain, 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'token': account_activation_token.make_token(user), }) list_mail_user = [] list_mail_user.append(str(user.email)) send_mail(subject, message, from_emailb, list_mail_user) return render(request, 'login/account_activation_sent.html') else: user_form = SignUpForm() regisadm_form = AdministrasiForm() context = { 'user_form': user_form, 'regisadm_form': regisadm_form, } condition_query = Article.objects.get(title="Syarat dan Ketentuan") context['conditions'] = condition_query regis_fee = AdministrationType.objects.get( paymentstype="Registration and First Dues") context['regis_fee'] = regis_fee.nominal questions = QuestionAnswer.objects.all context['questionanswer'] = questions return render(request, 'public/register.html', context)
def get_uid_token_verify(user): uid = urlsafe_base64_encode(force_bytes(user.pk)) verify_token = account_activation_token.make_token(user) return uid, verify_token
def path_avatar(instance, filename): path = 'avatar/' ext = filename.split('.')[-1] file_name = '%s.%s' % (urlsafe_base64_encode(force_bytes( instance.user.pk)), ext) return os.path.join(path, file_name)
def activation_token(): token_ = str(uuid.uuid4()).replace('-', '') return urlsafe_base64_encode(force_bytes(token_))
def post(self, request): context = {'data': request.POST, 'has_error': False} # data=request.POST # print(data) email = request.POST.get('email') username = request.POST.get('username') full_name = request.POST.get('name') password = request.POST.get('password') password2 = request.POST.get('password2') if len(password) < 6: messages.add_message( request, messages.ERROR, 'El password debe tener almenos de 6 caracteres') context['has_error'] = True if password != password2: messages.add_message(request, messages.ERROR, 'El password ingresado no coincide') context['has_error'] = True if not validate_email(email): messages.add_message(request, messages.ERROR, 'Ingrese un email válido') context['has_error'] = True try: if User.objects.get(email=email): messages.add_message(request, messages.ERROR, 'El email se encuentra en uso') context['has_error'] = True except Exception as identifier: pass try: if User.objects.get(username=username): messages.add_message(request, messages.ERROR, 'El usuario se encuentra en uso') context['has_error'] = True except Exception as identifier: pass if context['has_error']: return render(request, 'auth/register.html', context, status=400) user = User.objects.create_user(username=username, email=email) user.set_password(password) user.first_name = full_name user.last_name = full_name user.is_active = False user.save() current_site = get_current_site(request) email_subject = 'Active su usuario' message = render_to_string( 'auth/activate.html', { 'user': user, 'domain': current_site.domain, 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'token': generate_token.make_token(user) }) email_message = EmailMessage(email_subject, message, settings.EMAIL_HOST_USER, to=[email]) print(message) email_message.send() # si envia un error de este tipo # SMTPAuthenticationError at /register # (535, b'5.7.8 Username and Password not accepted. Learn more at\n5.7.8 https://support.google.com/mail/?p=BadCredentials d25sm5710486qka.39 - gsmtp') # se resuelve permitiendo acceso a aplicaciones no seguras # https://support.google.com/accounts/answer/6010255?hl=es messages.add_message(request, messages.SUCCESS, 'El usuario fue creado correctamente') return redirect('login')
def post(self, request, *args, **kwargs): form = self.form_class(request.POST) if form.is_valid(): data = form.cleaned_data["email_or_username"] if self.validate_email_address(data) is True: associated_users = User.objects.filter( Q(email=data) | Q(username=data)) if associated_users.exists(): for user in associated_users: c = { 'email': user.email, 'domain': request.META['HTTP_HOST'], 'site_name': 'SinComplique', 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'user': user, 'token': default_token_generator.make_token(user), 'protocol': 'http', } subject_template_name = 'users/password_reset_subject.txt' email_template_name = 'users/password_reset_subject.html' subject = 'Cambio de Contraseña' subject = ''.join(subject.splitlines()) email_txt = loader.render_to_string( subject_template_name, c) email_html = loader.render_to_string( email_template_name, c) send_mail(subject, email_html, settings.DEFAULT_FROM_EMAIL, [user.email]) result = self.form_valid(form) messages.success( request, 'An email has been sent to ' + data + ". Please check its inbox to continue reseting password.") return result result = self.form_invalid(form) messages.warning(request, 'No user is associated with this email address') return result else: associated_users = User.objects.filter(username=data) if associated_users.exists(): for user in associated_users: c = { 'email': user.email, 'domain': request.META['HTTP_HOST'], 'site_name': 'SinComplique', 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'user': user, 'token': default_token_generator.make_token(user), 'protocol': 'http', } subject_template_name = 'users/password_reset_subject.txt' email_template_name = 'users/password_reset_subject.html' subject = loader.render_to_string(subject_template_name, c) subject = ''.join(subject.splitlines()) email_txt = loader.render_to_string( subject_template_name, c) email_html = loader.render_to_string( email_template_name, c) send_mail(subject, email_html, settings.DEFAULT_FROM_EMAIL, [user.email]) result = self.form_valid(form) messages.success( request, 'Email has been sent to ' + data + "'s email address. Please check its inbox to continue reseting password." ) return result result = self.form_invalid(form) messages.error(request, 'This username does not exist in the system.') return result messages.error(request, 'Invalid Input') return self.form_invalid(form)
def login_user(request): mess_resetpwd_error = 'Email chưa đăng ký hoặc không hợp lệ' mess_resetpwd_ok = 'Hãy kiểm tra email của bạn để cập nhật lại mật khẩu' mess_register_error = 'Thông tin đăng ký không hợp lý' mess_register_ok = 'Hãy kiểm tra email của bạn để hoàn tất đăng ký' mess_login_error = 'Đăng nhập thất bại' if request.session.has_key('user') and (Agents.objects.get( username=request.session['user'])).status == 1: return redirect("/user") elif request.session.has_key('agent') and (Agents.objects.get( username=request.session['agent'])).status == 1: return redirect('/agent') elif request.session.has_key('admin') and (Agents.objects.get( username=request.session['admin'])).status == 1: return redirect('/admin') elif request.session.has_key('leader') and (Agents.objects.get( username=request.session['leader'])).status == 1: return redirect('/leader') else: if request.method == 'POST': # post form để User yêu cầu reset mật khẩu, gửi link về mail if 'uemail' in request.POST: form = UserResetForm(request.POST) if form.is_valid(): to_email = form.cleaned_data['uemail'] current_site = get_current_site(request) user = get_user_email(to_email) mail_subject = 'Reset password your account.' message = render_to_string( 'user/resetpwd.html', { 'user': user, 'domain': current_site.domain, 'uid': urlsafe_base64_encode(force_bytes( user.id)).decode(), 'token': account_activation_token.make_token(user), }) email = EmailMessage(mail_subject, message, to=[to_email]) thread = EmailThread(email) thread.start() return render(request, 'user/index.html', {'mess': mess_resetpwd_ok}) else: error = '' for field in form: error += field.errors return render(request, 'user/index.html', { 'mess': mess_resetpwd_error, 'error': error }) # Post form User đăng kí tài khoản, gửi link xác nhận về mail elif 'fullname' and 'email' and 'password2' in request.POST: form = RegistrationForm(request.POST) if form.is_valid(): current_site = get_current_site(request) user = form.save() mail_subject = 'Activate your blog account.' message = render_to_string( 'user/acc_active_email.html', { 'user': user, 'domain': current_site.domain, 'uid': urlsafe_base64_encode(force_bytes( user.id)).decode(), 'token': account_activation_token.make_token(user), }) to_email = form.cleaned_data['email'] email = EmailMessage(mail_subject, message, to=[to_email]) thread = EmailThread(email) thread.start() return render(request, 'user/index.html', {'mess': mess_register_ok}) else: error = '' for field in form: error += field.errors return render(request, 'user/index.html', { 'mess': mess_register_error, 'error': error }) # Agent đăng nhập, nếu là agent thường thì login bình thường, Maser-admin thì cần code xác thực elif 'agentname' and 'agentpass' in request.POST: form = AgentLoginForm(request.POST) if form.is_valid(): agentname = form.cleaned_data['agentname'] agentpass = form.cleaned_data['agentpass'] if authenticate_agent(agentname=agentname, agentpass=agentpass) is None: return render(request, 'user/index.html', {'mess': mess_login_error}) elif authenticate_agent(agentname=agentname, agentpass=agentpass) == 0: ag = get_agent(agentname) if ag.status == 1: request.session['user'] = agentname return redirect('/user') else: return render( request, 'user/index.html', {'mess': 'your account has been blocked'}) elif authenticate_agent(agentname=agentname, agentpass=agentpass) == 1: ag = Agents.objects.get(username=agentname) if ag.status == 1: request.session['agent'] = agentname return redirect('/agent') else: return render( request, 'user/index.html', {'mess': 'your account has been blocked'}) elif authenticate_agent(agentname=agentname, agentpass=agentpass) == 2: ag = Agents.objects.get(username=agentname) if ag.status == 1: request.session['leader'] = agentname return redirect('/leader') else: return render( request, 'user/index.html', {'mess': 'your account has been blocked'}) elif authenticate_agent(agentname=agentname, agentpass=agentpass) == 3: ag = Agents.objects.get(username=agentname) if ag.status == 1: request.session['admin'] = agentname return redirect('/admin') else: return render( request, 'user/index.html', {'mess': 'your account has been blocked'}) elif authenticate_agent(agentname=agentname, agentpass=agentpass) == 4: ag = Agents.objects.get(username=agentname) if ag.status == 1: request.session['leader'] = agentname return redirect('/leader') else: return render( request, 'user/index.html', {'mess': 'your account has been blocked'}) else: error = '' for field in form: error += field.errors return render(request, 'user/index.html', { 'mess': mess_login_error, 'error': error }) return render(request, 'user/index.html', {})
def encode_uuid_to_base64(uuid_) -> str: """Returns a urlsafe based64 encoded representation of a UUID object or UUID like string. """ return urlsafe_base64_encode(force_bytes(uuid_))
def encode(integer): return urlsafe_base64_encode(force_bytes(integer))
def make_uid(input): """ Small wrapper to generate a UID, usually used in URLs to allow for anonymous access """ return urlsafe_base64_encode(force_bytes(input))
def sign_up(request): form = SignUpForm() #form = SignUpForm() #print(form) if request.method == "POST": # data = {'first_name':'zhang', # 'last_name':'zhang', # 'email':'*****@*****.**', # 'password1':'111222333zzz', # 'password2':'111222333zzz', # 'county':'county_C', # 'facility':'Avalon Garden'} # form = SignUpForm(data) # print(form.is_valid()) form = SignUpForm(request.POST) # print(form['county']) # print(form['facility']) # print(request.POST.get('counties')) # print(request.POST.get('facilities')) #print(form.cleaned_data) if form.is_valid(): print("right here, valid") user = form.save(commit=False) #user.refresh_from_db() user = User.objects.create_user(form) # user.profile.first_name = form.cleaned_data.get('first_name') # user.profile.last_name = form.cleaned_data.get('last_name') # user.profile.county = form.cleaned_data.get('county') # user.profile.facility = form.cleaned_data.get('facility') user.profile.first_name = form.cleaned_data.get('first_name') user.profile.last_name = form.cleaned_data.get('last_name') user.profile.county = form.cleaned_data.get('county') user.profile.facility = form.cleaned_data.get('facility') user.email = form.cleaned_data.get('email') user.password = form.cleaned_data.get('password2') user.first_name = form.cleaned_data.get('first_name') user.last_name = form.cleaned_data.get('last_name') # user.profile.first_name = request.POST.get('first_name') # user.profile.last_name = request.POST.get('last_name') # user.profile.county = request.POST.get('counties') # user.profile.facility = request.POST.get('facilities') # user.first_name = request.POST.get('first_name') # user.last_name = request.POST.get('last_name') # user.email = request.POST.get('email') # user.password = request.POST.get('password2') # user can't login until link confirmed user.is_active = False user.username = None user.profile.save() user.save() current_site = get_current_site(request) subject = 'Activate Your Account' message = render_to_string( 'account_activation_email.html', { 'user': user, 'domain': current_site.domain, 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'token': account_activation_token.make_token(user), }) print(message) #user.email_user(subject, message) # to_email = form.cleaned_data.get('email') to_email = request.POST.get('email') email = EmailMessage(subject, message, to=[to_email]) email.send() return redirect('account_activation_sent') return render(request, 'signup3.html', {'form': form})
def test_urlsafe_base64_roundtrip(self): bytestring = b'foo' encoded = http.urlsafe_base64_encode(bytestring) decoded = http.urlsafe_base64_decode(encoded) self.assertEqual(bytestring, decoded)
def post(self, request, *args, **kwargs): try: try: user_exists = User.objects.get(email=request.data.get('email'), is_active=True) except: user_exists = None if not user_exists: fn = request.data.get('first_name').split() ln = request.data.get('last_name').split() name = ((fn[0] + ln[0]).lower()) + makeID(4) try: user = User.objects.get(email=request.data.get('email')) except: user = None if user: user.username = name user.first_name = request.data.get('first_name') user.last_name = request.data.get('last_name') user.set_password(request.data.get('password')) user.save() else: user = User.objects.create_user( username=name, email=request.data.get('email'), password=request.data.get('password'), first_name=request.data.get('first_name'), last_name=request.data.get('last_name'), ) user.is_active = False user.save() else: return Response({ 'status': 'error', 'msg': 'Email has already been used' }) except: return Response({ 'status': 'error', 'msg': 'Something went wrong. Please try again' }) current_site = get_current_site(self.request) mail_subject = 'Activate your Agrimart account' message = render_to_string( 'acc_active_email.html', { 'user': user, 'domain': current_site.domain, 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'token': account_activation_token.make_token(user), }) email = user.email send_mail(mail_subject, message, 'Quezon Agrimart <*****@*****.**>', [email], fail_silently=False) return Response({'status': 'okay'})
def base64_decode_id(id: int): """整数をBase64に変換""" return urlsafe_base64_encode(force_bytes(id))
def tutors(request): try: tutors = PostAnAd_tutor.objects.all().order_by("-id") except: tutors = None # tutors = PostAnAd_tutor.objects.all().order_by("-id") gender_query = request.GET.get('gender') subject_query = request.GET.get("subject") tuitionlevel_query = request.GET.get("tuition-level") if tutors: if gender_query != "" and gender_query is not None and gender_query != "Male/FeMale": for t in tutors: t.tutorUser.gender = t.tutorUser.gender.upper() t.tutorUser.save() tutors = tutors.filter(tutorUser__gender__startswith = gender_query.upper()) if subject_query != "" and subject_query is not None: tutors = tutors.filter(subject__icontains= subject_query) if tuitionlevel_query != "" and tuitionlevel_query is not None and tuitionlevel_query != "All Tuition Level": tutors = tutors.filter(tuition_level = tuitionlevel_query) tuts = [] if tutors != None: for t in tutors: if t.tutorUser.tutor.is_active: tuts.append(t) number = Tutor.objects.all().count() paginator = Paginator(tuts,16) page = request.GET.get('page') try: items = paginator.page(page) except PageNotAnInteger: items = paginator.page(1) except EmptyPage: items = paginator.page(paginator.num_pages) index = items.number - 1 max_index = len(paginator.page_range) start_index = index - 5 if index >= 5 else 0 end_index = index + 5 if index <= max_index - 5 else max_index page_range = paginator.page_range[start_index:end_index] group = None if request.user.groups.exists(): group = request.user.groups.all()[0].name form = StudentSignupForm() if request.method == "POST": form = StudentSignupForm(request.POST) if form.is_valid(): student = form.save() username = form.cleaned_data.get('username') email = form.cleaned_data.get('email') age = form.cleaned_data.get('age') city = form.cleaned_data.get('city') firstName = form.cleaned_data.get('first_name') lastName = form.cleaned_data.get('last_name') phone = form.cleaned_data.get("phone") group = Group.objects.get(name="students") student.groups.add(group) Student.objects.create( student=student, username= username, email = email, age =age, city = city, first_name = firstName, last_name = lastName, phone = phone ) student.is_active = False student.save() current_site = get_current_site(request) template = render_to_string("home/activate_invite_register.html", { "firstname": firstName, "lastname": lastName, "domain": current_site, "uid": urlsafe_base64_encode(force_bytes(student.pk)), "token": generate_token.make_token(student), "id":id }) registerEmail = EmailMessage( 'Account Activation', template, settings.EMAIL_HOST_USER, [email] ) registerEmail.fail_silently = False registerEmail.send() return render(request,"home/activation_sent.html",{}) context = { "tutor":tuts, "items": items, "page_range": page_range, "grp": group, "number":number, "form": form, "count": len(tuts), } return render(request, "home/all_tuts.html", context)
def signup_view(request): # GET SIGNUP FORM WITH VALIDATION u_form, p_form = UserForm(request.POST), UserProfileForm(request.POST) # IF METHOD IS POST PROCEED NEXT if request.method == 'POST': # CHECK FORM VALIDATIONS FROM COMBINATION if u_form.is_valid() and p_form.is_valid(): # SAVE BOTH FORMS AND ADD REQUIRED ATTRIBUTES user, profile = u_form.save(), p_form.save(commit=False) # SET AS NORMAL USER NOT ADMIN USER user.is_staff = True # ADD ATTRIBUTES TO PROFILE MODEL profile.user = user profile.email = u_form.cleaned_data.get('email') profile.signup_confirmation = False # SET ACTIVATION FIELD IN DJANGO AUTHENTICATION user.is_active = False #SAVE UPDATED TO FORM ABOVE user.save() profile.save() # RETURN SUCCESS SIGNUP messages.success( request, 'User Signup Successfully,Please Verify Using Email') # SEND VERIFICATION MAIL TO NEW USER emailSender(request_body=user.email, message='Account Activation', template_path='polls/activation_request.html', mail_obj={ 'user': user, "password": u_form.cleaned_data.get('password1'), 'domain': get_current_site(request), 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'token': account_activation_token.make_token(user), 'database_access': p_form.cleaned_data.get('database_access') }, subject='Please Activate Your Account & login') # REDIRECT RESPONSE TO DASHBOARD ONCE SUCCESS return HttpResponseRedirect('dashboard') else: # RETURN THE FORM ERROR FOR TEST print("u_form.errors : ", u_form.errors, "p_form.errors", p_form.errors) # RENDER SIGNUP FORM WITH VALIDATIONS return render(request, 'polls/signup.html', context={ 'u_form': u_form, 'p_form': p_form, 'f_validate': True })
def ads_detail(request, id): tutor = PostAnAd_tutor.objects.get(id = id) qual = AboutAndQualifications.objects.get(tutor__username = tutor.tutorUser.username) tutor.views += 1 tutor.save() tutors = PostAnAd_tutor.objects.filter(tutorUser__username = tutor.tutorUser.username).order_by("-id") try: registered = request.user.groups.all()[0].name except: registered = None form = StudentSignupForm() if request.method == "POST": form = StudentSignupForm(request.POST) if form.is_valid(): student = form.save() username = form.cleaned_data.get('username') email = form.cleaned_data.get('email') age = form.cleaned_data.get('age') city = form.cleaned_data.get('city') firstName = form.cleaned_data.get('first_name') lastName = form.cleaned_data.get('last_name') phone = form.cleaned_data.get("phone") group = Group.objects.get(name="students") student.groups.add(group) Student.objects.create( student=student, username= username, email = email, age =age, city = city, first_name = firstName, last_name = lastName, phone = phone ) student.is_active = False student.save() current_site = get_current_site(request) template = render_to_string("home/activate_invite_register.html", { "firstname": firstName, "lastname": lastName, "domain": current_site, "uid": urlsafe_base64_encode(force_bytes(student.pk)), "token": generate_token.make_token(student), "id":id }) registerEmail = EmailMessage( 'Account Activation', template, settings.EMAIL_HOST_USER, [email] ) registerEmail.fail_silently = False registerEmail.send() return render(request,"home/activation_sent.html",{}) group = None if request.user.groups.exists(): group = request.user.groups.all()[0].name context = { "tutor": tutor, "qual": qual, "tutors": tutors.exclude(id = id), "registered": registered, "form": form, "grp": group } return render (request,"home/ads_detail.html", context)
def handle(self, *args, **kwargs): self.json = kwargs.get("json", False) username = kwargs["username"].strip() if not username: self.exit_with_error("invalid username") email = kwargs["email"] superuser = kwargs.get("superuser", False) email_validator = EmailValidator() try: email_validator(email) except ValidationError: self.exit_with_error("invalid email address") user = None try: user = User.objects.get(username=username) except User.DoesNotExist: pass else: if user.email != email: self.exit_with_error( "user {} exists with a different email: {}".format( username, user.email)) try: user = User.objects.get(email=email) except User.DoesNotExist: pass else: if user.username != username: self.exit_with_error( "user with email {} exists with a different username: {}". format(email, user.username)) created = updated = False if not user: user = User.objects.create_user(username, email, password=get_random_string(1024), is_superuser=superuser) created = True if not self.json: print("Superuser" if superuser else "User", username, email, "created") else: if user.is_superuser != superuser: updated = True user.is_superuser = superuser user.save() if superuser and not self.json: print("Existing user", username, email, "promoted to superuser") elif not self.json: print("Existing superuser", username, email, "demoted") else: print("Superuser" if user.is_superuser else "User", username, email, "already exists") # API Token? if kwargs.get("with_api_token"): api_token, api_token_created = Token.objects.get_or_create( user=user) if not self.json: print("Created" if api_token_created else "Existing", "API token", api_token.key) else: api_token = None api_token_created = False # generate password reset URL uid = urlsafe_base64_encode(force_bytes(user.pk)) if isinstance(uid, bytes): uid = uid.decode("ascii") token = default_token_generator.make_token(user) password_reset_url = "{}{}".format( settings["api"]["tls_hostname"], reverse('password_reset_confirm', args=(uid, token))) if self.json: print( json.dumps( { "superuser": superuser, "username": user.username, "email": user.email, "created": created, "updated": updated, "api_token": api_token.key if api_token else None, "api_token_created": api_token_created, "password_reset_url": password_reset_url, }, indent=2)) else: print("Password reset:", password_reset_url)
def register(request): if request.method == 'POST': form1 = RegistrationForm(request.POST) form2 = AdditionalForm(request.POST) if form1.is_valid() and form2.is_valid(): recaptcha_response = request.POST.get('g-recaptcha-response') url = 'https://www.google.com/recaptcha/api/siteverify' values = { 'secret': settings.GOOGLE_RECAPTCHA_SECRET_KEY, 'response': recaptcha_response } data = urllib.parse.urlencode(values).encode() req = urllib.request.Request(url, data=data) response = urllib.request.urlopen(req) result = json.loads(response.read().decode()) if result['success']: model1 = form1.save( commit=False) #Required information of user model1.is_active = True #Set true for testing without email. model1.save() model2 = form2.save( commit=False) #Optional information of user model2.user = model1 model2.save() #Email user current_site = get_current_site(request) subject = 'Activate Your CAM2 Account' message = render_to_string( 'app/confirmation_email.html', { 'user': model1, 'domain': current_site.domain, 'uid': urlsafe_base64_encode(force_bytes(model1.pk)), 'token': account_activation_token.make_token(model1), }) model1.email_user(subject, message) return redirect('email_confirmation_sent') else: messages.error( request, 'Invalid reCAPTCHA. Please confirm you are not a robot and try again.' ) if 'test' in sys.argv: sitekey = os.environ['RECAPTCHA_TEST_SITE_KEY'] else: sitekey = os.environ['RECAPTCHA_SITE_KEY'] else: if 'test' in sys.argv: sitekey = os.environ['RECAPTCHA_TEST_SITE_KEY'] else: sitekey = os.environ['RECAPTCHA_SITE_KEY'] else: form1 = RegistrationForm() form2 = AdditionalForm() if 'test' in sys.argv: sitekey = os.environ['RECAPTCHA_TEST_SITE_KEY'] else: sitekey = os.environ['RECAPTCHA_SITE_KEY'] return render(request, 'app/register.html', { 'form1': form1, 'form2': form2, 'sitekey': sitekey })
def signup(request): if request.method == 'GET': if request.session.has_key('username'): return loggedinhome(request) if request.method == 'POST': if "email" in request.POST and "password" in request.POST and "Retype_password" in request.POST: # print("passed1") if request.POST["password"] == request.POST["Retype_password"]: if len(request.POST["phone_no"]) == 10: # print("passed2") if not check_user_exists(request, request.POST["email"] )[0]: #check unique user or not mail = request.POST["email"] password = encrypt_string(str( request.POST["password"])) if (request.POST["user_type"] == "consumer"): user = consumer( email=request.POST["email"], password=password, f_name=request.POST["f_name"], l_name=request.POST["l_name"], address=request.POST["address"], phone_no=request.POST["phone_no"], created_date=datetime.datetime.now(), location=[ float(request.POST['latitude']), float(request.POST['longitude']) ]) user.email_verified = False user.save() request.session['status'] = 0 elif (request.POST["user_type"] == "retailer"): user = retailer( email=request.POST["email"], password=password, f_name=request.POST["f_name"], l_name=request.POST["l_name"], address=request.POST["address"], phone_no=request.POST["phone_no"], created_date=datetime.datetime.now(), location=[ float(request.POST['latitude']), float(request.POST['longitude']) ]) user.email_verified = False user.save() request.session['status'] = 1 elif (request.POST["user_type"] == "farmer"): user = farmer(email=request.POST["email"], password=password, f_name=request.POST["f_name"], l_name=request.POST["l_name"], address=request.POST["address"], phone_no=request.POST["phone_no"], created_date=datetime.datetime.now(), location=[ float(request.POST['latitude']), float(request.POST['longitude']) ]) user.email_verified = False user.save() request.session['status'] = 2 request.session['username'] = request.POST["email"] #return loggedinhome(request) current_site = get_current_site(request) mail_subject = 'Activate your account.' message = render_to_string( 'actimail.html', { 'user': user, 'domain': current_site.domain, 'uid': urlsafe_base64_encode( force_bytes(user.pk)), 'token': account_activation_token.make_token(user), }) to_email = mail email = EmailMessage(mail_subject, message, to=[to_email]) email.send() return render(request, 'user_auth/verify.html') else: return render(request, 'user_auth/index.html', {'warning': "User already exists"}) else: return render(request, 'user_auth/index.html', {'warning': "Phone Number must be 10 digit"}) else: return render(request, 'user_auth/index.html', {'warning': "Password doesn't match"}) else: return render(request, 'user_auth/index.html', {'warning': "Fill all elements"}) else: return render(request, 'user_auth/index.html')
def post(self, request, *args, **kwargs): ''' A normal post request which takes input from field "email_or_username" (in ResetPasswordRequestForm). ''' form = self.form_class(request.POST) if form.is_valid(): data= form.cleaned_data["email_or_username"] if self.validate_email_address(data) is True: #uses the method written above ''' If the input is an valid email address, then the following code will lookup for users associated with that email address. If found then an email will be sent to the address, else an error message will be printed on the screen. ''' User = get_user_model() stu_det="" t_det="" try: stu_det=Student_Details.objects.filter(email=data) if not stu_det.exists(): t_det=Teacher_Details.objects.filter(email=data) except Student_Details.DoesNotExist: t_det=Teacher_Details.objects.filter(email=data) print("t_det",t_det) if stu_det: associated_users=User.objects.filter(sid=stu_det[0]) elif t_det: associated_users=User.objects.filter(sid=t_det[0]) else: associated_users=None if associated_users: if stu_det.exists(): c = { 'email': stu_det[0].email, 'domain': request.META['HTTP_HOST'], 'site_name': 'Attendr', 'uid': urlsafe_base64_encode(force_bytes(associated_users[0].pk)).decode(), 'user': associated_users[0], 'token': default_token_generator.make_token(associated_users[0]), 'protocol': 'http', } elif t_det.exists(): c = { 'email': t_det[0].email, 'domain': request.META['HTTP_HOST'], 'site_name': 'Attendr', 'uid': urlsafe_base64_encode(force_bytes(associated_users[0].pk)).decode(), 'user': associated_users[0], 'token': default_token_generator.make_token(associated_users[0]), 'protocol': 'http', } subject_template_name='registration/password_reset_subject.txt' # copied from django/contrib/admin/templates/registration/password_reset_subject.txt to templates directory email_template_name='registration/password_reset_email.html' # copied from django/contrib/admin/templates/registration/password_reset_email.html to templates directory subject = loader.render_to_string(subject_template_name, c) # Email subject *must not* contain newlines subject = ''.join(subject.splitlines()) email = loader.render_to_string(email_template_name, c) if stu_det: send_mail(subject, email, DEFAULT_FROM_EMAIL , [stu_det[0].email], fail_silently=False) elif t_det: send_mail(subject, email, DEFAULT_FROM_EMAIL , [t_det[0].email], fail_silently=False) result = self.form_valid(form) messages.success(request, 'An email has been sent to ' + data +". Please check its inbox to continue reseting password.") return result result = self.form_invalid(form) messages.error(request, 'No user is associated with this email address') return result else: ''' If the input is an username, then the following code will lookup for users associated with that user. If found then an email will be sent to the user's address, else an error message will be printed on the screen. ''' User = get_user_model() associated_users= User.objects.filter(sid=data) if associated_users: if not associated_users[0].is_staff: stu_det=Student_Details.objects.filter(st_id=associated_users[0].sid) t_det='' else: t_det=Teacher_Details.objects.filter(t_id=associated_users[0].sid) stu_det='' if stu_det: if not stu_det[0].email: result = self.form_invalid(form) messages.error(request, 'This username does does not have an email id.Please contact administrator.') return result c = { 'email': stu_det[0].email, 'domain': request.META['HTTP_HOST'], #or your domain 'site_name': 'Attendr', 'uid': urlsafe_base64_encode(force_bytes(associated_users[0].sid)).decode(), 'user': associated_users[0], 'token': default_token_generator.make_token(associated_users[0]), 'protocol': 'http', } subject_template_name='registration/password_reset_subject.txt' email_template_name='registration/password_reset_email.html' subject = loader.render_to_string(subject_template_name, c) # Email subject *must not* contain newlines subject = ''.join(subject.splitlines()) email = loader.render_to_string(email_template_name, c) send_mail(subject, email, DEFAULT_FROM_EMAIL , [stu_det[0].email], fail_silently=False) result = self.form_valid(form) messages.success(request, 'Email has been sent to ' + data +"'s email address. Please check its inbox to continue reseting password.") return result elif t_det: if not t_det[0].email: result = self.form_invalid(form) messages.error(request, 'This username does does not have an email id.Please contact administrator.') return result c = { 'email': t_det[0].email, 'domain': request.META['HTTP_HOST'], #or your domain 'site_name': 'Attendr', 'uid': urlsafe_base64_encode(force_bytes(associated_users[0].sid)).decode(), 'user': associated_users[0], 'token': default_token_generator.make_token(associated_users[0]), 'protocol': 'http', } subject_template_name='registration/password_reset_subject.txt' email_template_name='registration/password_reset_email.html' subject = loader.render_to_string(subject_template_name, c) # Email subject *must not* contain newlines subject = ''.join(subject.splitlines()) email = loader.render_to_string(email_template_name, c) send_mail(subject, email, DEFAULT_FROM_EMAIL , [t_det[0].email], fail_silently=False) result = self.form_valid(form) messages.success(request, 'Email has been sent to ' + data +"'s email address. Please check its inbox to continue reseting password.") return result result = self.form_invalid(form) messages.error(request, 'This username does not exist in the system.') return result messages.error(request, 'Invalid Input') return self.form_invalid(form)
def register_profile(request): if request.method == "GET": template = "profiles/register.html" form = AcademiaUserCreationForm context = {"form": form} return render(request, template, context) elif request.method == "POST": form = AcademiaUserCreationForm(request.POST) if form.is_valid(): new_user = form.save() logger.info("new_user: %s" % new_user.username) # Crear perfil de usuario new_profile = Profile.objects.create(user=new_user) logger.info("new_profile: %s" % new_profile) # Crear Accepted Cryptos por default bitcoin, created = CryptoCurrency.objects.get_or_create( name="Bitcoin", code="BTC") ether, created = CryptoCurrency.objects.get_or_create(name="Ether", code="ETH") monero, created = CryptoCurrency.objects.get_or_create( name="Monero", code="XMR") user_bitcoin = AcceptedCrypto.objects.create(user=new_user, crypto=bitcoin) user_ether = AcceptedCrypto.objects.create(user=new_user, crypto=ether) user_monero = AcceptedCrypto.objects.create(user=new_user, crypto=monero) logger.info("user_bitcoin: %s" % user_bitcoin) logger.info("user_ether: %s" % user_ether) logger.info("user_monero: %s" % user_monero) login(request, new_user) # Enviar email de confirmacion activation_token = PasswordResetTokenGenerator().make_token( new_user) logger.info("activation_token: %s" % activation_token) current_site = get_current_site(request) uid = urlsafe_base64_encode(force_bytes(new_user.pk)) logger.info("uid: %s" % uid) message = render_to_string( 'profiles/email_confirm_account.html', { 'username': new_user.username, 'uid': uid, 'token': activation_token, 'domain': current_site }) user_email = form.cleaned_data.get('email') send_email_message(subject="Activa tu cuenta", message=message, receiver_email=user_email) logger.debug("current_site: %s" % current_site) logger.debug("uid: %s" % uid) logger.debug("activation_token: %s" % activation_token) template = "profiles/profile_data.html" context = {'new_profile': new_profile} return render(request, template, context) else: template = "profiles/register.html" context = {"form": form} return render(request, template, context)
def register(request): if request.method == 'POST': fname = request.POST['fname'] Email = request.POST['email'] phone = request.POST['phone'] alt_phone = request.POST['alt_phone'] designation = request.POST['designation'] if (designation == "Other"): designation = request.POST['other'] address = request.POST['address'] role = "Referral Partner" mapped_to = "admin" mapped_to_nm = "admin" by_online = "yes" if CustomUser.objects.filter(email=Email).exists(): messages.info(request, 'Email Taken') return redirect('register') else: user = CustomUser.objects.create_user(username=Email, password="", email=Email, first_name=fname, phone=phone, alt_phone=alt_phone, designation=designation, address=address, role=role, mapped_to=mapped_to, mapped_to_name=mapped_to_nm, by_online=by_online) user.is_active = False user.save() ini = "" if user.designation == "Salaried": ini += "SAL" elif user.designation == "Self Employed": ini += "SE" elif user.designation == "Freelancer": ini += "FL" elif user.designation == "Student": ini += "ST" elif user.designation == "Home Maker": ini += "HM" elif user.designation == "DSA": ini += "DSA" elif user.designation == "Insurance Agent": ini += "IA" elif user.designation == "Chartered Accountant": ini += "CA" elif user.designation == "Tax Consultants": ini += "TC" elif user.designation == "Banker": ini += "BNK" elif user.designation == "Company Secretary": ini += "CS" elif user.designation == "Real Estate Agent": ini += "REA" elif user.designation == "Builder": ini += "BLD" else: ini += "O" if user.role == "Referral Partner": ini += "RP" num = '{:04d}'.format(user.id) newusername = ini + num user.username = newusername user.save() # if user.role == "Referral Partner": # ini = "ORP" # num = '{:03d}'.format(user.id) # newusername = ini+num # user.username = newusername # user.save() uidb64 = urlsafe_base64_encode(force_bytes(user.pk)) domain = get_current_site(request).domain link = reverse('activate', kwargs={ 'uidb64': uidb64, 'token': token_generator.make_token(user) }) activate_url = "http://" + domain + link email_body = 'Hi ' + user.first_name + ' Please use this link to verify your account\n' + activate_url email = EmailMessage( 'Activate your account', email_body, '*****@*****.**', [Email], ) email.send(fail_silently=False) template = get_template('account/Agreement.html') context = {"partner_name": user.first_name} html = template.render(context) pdf = render_to_pdf('account/Agreement.html', context) response = HttpResponse(pdf, content_type='application/pdf') filename = "Agreement_%s.pdf" % (user.username) content = "attachment; filename='%s'" % (filename) # response['Content-Disposition'] = content response[ 'Content-Disposition'] = 'attachment; filename="report.pdf"' user.agreement.save(filename, File(BytesIO(pdf.content))) message = "this is test mail" subject = "terms and conditions" mail_id = request.POST.get('email', '') # mail_id="*****@*****.**" email = EmailMessage(subject, message, EMAIL_HOST_USER, [ mail_id, ]) email.content_subtype = 'html' # file2=open("abcd.txt","r") # file=open("manage.py","r") # email.attach("abcd.txt",file2.read(),'text/plain') # email.attach("Agg.pdf",file.read(), 'text/plain') email.attach_file("media/agreements/Agreement_" + user.username + ".pdf") email.send() # return render(request, 'account/terms.html') #else: #messages.info(request, 'Password did not match') #return redirect('register') return redirect('email_ver_msg') #else: #messages.info(request, 'Password did not match') #return redirect('register') else: return render(request, 'account/register.html')
def checkout(request): x = 0 if request.user.is_authenticated: x = 1 books = "" cartlist = ShoppingCart.objects.filter(custid=request.user.id) booklist = Inventory.objects.all() for cart in cartlist: for book in booklist: if cart.invid == book.bookid: books += book.title + "(x" + str(cart.quantity) + "), " #########################Getting the correct order object################# try: order = Orders.objects.get(custid=request.user.id) order.ordertime = datetime.datetime.now() except: order = Orders.objects.create(custid=request.user.id, ordertime=datetime.datetime.now()) #################################getting the correct cart total########################## total = Decimal(0.00) cartlist = ShoppingCart.objects.filter(custid=request.user.id) booklist = Inventory.objects.all() for cart in cartlist: for book in booklist: if cart.invid == book.bookid: total = (cart.quantity * book.sell_price) + total ########################getting the promotion from the order promotion = Decimal(100) ######set to 100 for the case it doesnt exist if order.promotion: for promo in Promotions.objects.all(): if promo.promocode == order.promotion: promotion = Decimal(promo.percentage) total = total * (promotion / 100) order.orderdate = datetime.date.today() order.orderstatus = "in progress" order.totalprice = total total = order.totalprice total = format(total, '.2f') order.save() form = Checkout(request.POST, instance=request.user) if request.method == 'POST': if form.is_valid(): user = form.save(commit=False) user.save() current_site = get_current_site(request) mail_subject = 'Bookstore Order' message = render_to_string( 'order_email.html', { 'cartlist': cartlist, 'booklist': booklist, 'user': user, 'books': books, 'order': order, 'domain': current_site.domain, 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'token': account_activation_token.make_token(user), }) to_email = user.email email = EmailMessage(mail_subject, message, to=[to_email]) email.send() return redirect('/checkout/order_confirm') else: form = Checkout(instance=request.user) context = {'total': total, 'x': x, 'form': form, 'user': request.user} return render(request, "storefront/html/checkout.html", context)
def perform_create(self, serializer): data = self.request.data order_id = data.get("order") ingredients_in_baslet = IngredientsInBasket.objects.filter(session_key=self.request.session.session_key, is_active=True) for ingredient_in_baslet in ingredients_in_baslet: PizzaIngredientInOrder.objects.create(order_id=order_id, ingredient=ingredient_in_baslet.ingredient, nmb=ingredient_in_baslet.nmb) ingredient_in_baslet.order = Order.objects.get(id=order_id) ingredient_in_baslet.is_active = False ingredient_in_baslet.save(force_update=True) order = Order.objects.get(id=order_id) name = order.name phone = order.phone email = order.email comments = order.comments ingredients_in_order = PizzaIngredientInOrder.objects.filter(order=order) current_site = get_current_site(self.request) client_subject = 'Activate your pizza order.' client_message_html = loader.render_to_string('orders/client_message.html', { 'order': order, 'ingredients_in_order': ingredients_in_order, 'domain': current_site.domain, 'uid':urlsafe_base64_encode(force_bytes(order.pk)), 'token':order_activation_token.make_token(order), }) client_message = '%s thanks for your order! \nPlease click on the link to confirm your order' % name from_email = settings.EMAIL_HOST_USER to_client_email = [email] # Sync way to send email # send_mail( # client_subject, # client_message, # from_email, # to_client_email, # fail_silently=False, # html_message=client_message_html # ) # Async way to send email # async_send_mail.delay( # client_subject, # client_message, # from_email, # to_client_email, # fail_silently=False, # html_message=client_message_html # ) # Async way to send email using custom class Mailer mail = Mailer(from_email=settings.EMAIL_HOST_USER) mail.send_messages(subject=client_subject, template='orders/client_message.html', context={ 'order': order, 'ingredients_in_order': ingredients_in_order, 'domain': current_site.domain, 'uid': urlsafe_base64_encode(force_bytes(order.pk)), 'token': order_activation_token.make_token(order) }, to_emails=[email])
def encode_uid(pk): return force_str(urlsafe_base64_encode(force_bytes(pk)))
def encoded_path(self): return urlsafe_base64_encode(self.path.encode('utf-8', 'ignore'))
def rest_encode_user_pk(user): return urlsafe_base64_encode(force_bytes(user.pk))
def re_settings(request): if request.method == "POST": if request.user.is_authenticated: if request.is_ajax(): if request.POST.get('command', None) is None: return JsonResponse({'res': 2}) elif request.POST.get('command', None) == 'name': new_user_text_name = request.POST.get('name', None) if new_user_text_name is not None: user_text_name_failure = user_text_name_failure_validate( new_user_text_name) if user_text_name_failure: clue_message = None if user_text_name_failure is 1: clue_message = texts.USER_TEXT_NAME_LENGTH_PROBLEM return JsonResponse({ 'res': 0, 'message': clue_message }) try: with transaction.atomic(): user_text_name = request.user.usertextname user_text_name.name = new_user_text_name user_text_name.save() except Exception: return JsonResponse({ 'res': 0, 'message': texts.UNEXPECTED_ERROR }) return JsonResponse({ 'res': 1, 'message': texts.USER_TEXT_NAME_CHANGED, 'name': escape(new_user_text_name) }) elif request.POST.get('command', None) == 'username': new_user_username = request.POST.get('username', None) if new_user_username is not None: new_user_username = new_user_username.lower() user_username_exist = UserUsername.objects.filter( username=new_user_username).exists() if user_username_exist: return JsonResponse({ 'res': 0, 'message': texts.USERNAME_ALREADY_USED }) user_username_failure = user_username_failure_validate( new_user_username) if user_username_failure: clue_message = None if user_username_failure is 1: clue_message = texts.USERNAME_UNAVAILABLE elif user_username_failure is 2: clue_message = texts.USERNAME_LENGTH_PROBLEM elif user_username_failure is 3: clue_message = texts.USERNAME_8_CANNOT_DIGITS elif user_username_failure is 4: clue_message = texts.USERNAME_BANNED return JsonResponse({ 'res': 0, 'message': clue_message }) try: with transaction.atomic(): user_username = request.user.userusername user_username.username = new_user_username user_username.save() except Exception: return JsonResponse({ 'res': 0, 'message': texts.UNEXPECTED_ERROR }) return JsonResponse({ 'res': 1, 'message': texts.USERNAME_CHANGED, 'username': escape(new_user_username) }) elif request.POST.get('command', None) == 'email': new_user_primary_email = request.POST.get('email', None) if new_user_primary_email is not None: user_primary_email_exist = UserPrimaryEmail.objects.filter( email=new_user_primary_email).exists() if user_primary_email_exist: return JsonResponse({ 'res': 0, 'message': texts.EMAIL_ALREADY_USED }) user_primary_email_failure = user_primary_email_failure_validate( new_user_primary_email) if user_primary_email_failure: clue_message = None if user_primary_email_failure is 1: clue_message = texts.EMAIL_UNAVAILABLE elif user_primary_email_failure is 2: clue_message = texts.EMAIL_LENGTH_OVER_255 return JsonResponse({ 'res': 0, 'message': clue_message }) try: with transaction.atomic(): checker_while_loop = 0 counter_if_loop = 0 uid = urlsafe_base64_encode( force_bytes(request.user.pk)).decode() token = account_activation_token.make_token( request.user) while checker_while_loop is 0: if counter_if_loop <= 9: try: UserPrimaryEmailAuthToken.objects.create( user_primary_email=request. user.userprimaryemail, uid=uid, token=token, email=new_user_primary_email, ) except IntegrityError as e: if 'UNIQUE constraint' in str( e.args): counter_if_loop = counter_if_loop + 1 else: return JsonResponse({ 'res': 0, 'message': texts. EMAIL_CONFIRMATION_EXTRA_ERROR }) checker_while_loop = 1 subject = '[' + texts.SITE_NAME + ']' + texts.EMAIL_CONFIRMATION_SUBJECT message = render_to_string( 'authapp/_account_activation_email.html', { 'username': request.user.userusername.username, 'name': request.user.usertextname.name, 'email': new_user_primary_email, 'domain': texts.SITE_DOMAIN, 'site_name': texts.SITE_NAME, 'uid': uid, 'token': token, }) new_user_email_list = [new_user_primary_email] send_mail( subject=subject, message=message, from_email=options.DEFAULT_FROM_EMAIL, recipient_list=new_user_email_list) # End Transaction except Exception: return JsonResponse({ 'res': 0, 'message': texts.UNEXPECTED_ERROR }) return JsonResponse({ 'res': 1, 'email': texts.EMAIL_SENT + ': ' + new_user_primary_email }) elif request.POST.get('command', None) == 'email_resend': new_user_primary_email = request.user.userprimaryemail.email if new_user_primary_email is not None: try: with transaction.atomic(): checker_while_loop = 0 counter_if_loop = 0 uid = urlsafe_base64_encode( force_bytes(request.user.pk)).decode() token = account_activation_token.make_token( request.user) while checker_while_loop is 0: if counter_if_loop <= 9: try: UserPrimaryEmailAuthToken.objects.create( user_primary_email=request. user.userprimaryemail, uid=uid, token=token, email=new_user_primary_email, ) except IntegrityError as e: if 'UNIQUE constraint' in str( e.args): counter_if_loop = counter_if_loop + 1 else: return JsonResponse({ 'res': 0, 'message': texts. EMAIL_CONFIRMATION_EXTRA_ERROR }) checker_while_loop = 1 subject = '[' + texts.SITE_NAME + ']' + texts.EMAIL_CONFIRMATION_SUBJECT message = render_to_string( 'authapp/_account_activation_email.html', { 'username': request.user.userusername.username, 'name': request.user.usertextname.name, 'email': new_user_primary_email, 'domain': texts.SITE_DOMAIN, 'site_name': texts.SITE_NAME, 'uid': uid, 'token': token, }) new_user_email_list = [new_user_primary_email] send_mail( subject=subject, message=message, from_email=options.DEFAULT_FROM_EMAIL, recipient_list=new_user_email_list) # End Transaction except Exception: return JsonResponse({ 'res': 0, 'message': texts.UNEXPECTED_ERROR }) return JsonResponse({ 'res': 1, 'email': texts.EMAIL_SENT + ': ' + new_user_primary_email }) return JsonResponse({'res': 2})
def test_put_user_profile(self): """ Ensure we can update a user profile avatar """ # create a dummy image image = Image.new('RGB', (100, 100), (255, 0, 0)) # get a temp container tmp_file = NamedTemporaryFile(suffix=self.extension) # save the image into the container image.save(tmp_file) # do the update trick url = reverse('user-profile-put', kwargs={'pk': self.test_user.id}) response = self.client.put(url, {'avatar': tmp_file}, format='multipart') self.uploaded_file_path = os.path.join(AVATARS_PATH, urlsafe_base64_encode(self.test_user.username) + '-' + urlsafe_base64_encode(str(self.test_user.id)) + self.extension) # if this passes it's we sure have a working image_upload code self.assertEqual(status.HTTP_200_OK, response.status_code) self.assertTrue(self.uploaded_file_path in response.data.get('avatar', '')) file_on_disk = os.path.join(settings.MEDIA_ROOT, self.uploaded_file_path) self.assertTrue(os.path.isfile(file_on_disk))