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