def contact(request):
if request.user.is_authenticated:
userCartStatus, created = UserCartStatus.objects.get_or_create(
user_id=request.user, complete=False)
else:
userCartStatus = {}
if request.method == "POST":
# sending email
template = render_to_string(
'frontend/msgsample.html', {
'msg': request.POST['msg'],
'email': request.POST['email'],
'phone': request.POST['phone'],
'name': request.POST['name']
})
email = EmailMessage(
'DIY Eplatform',
template,
settings.EMAIL_HOST_USER,
['*****@*****.**'],
)
email.fail_silently = False
email.send()
context = {'userCartStatus': userCartStatus}
messages.success(request, 'We Will Contact You Soon!!')
return redirect("Frontend:contact")
context = {'userCartStatus': userCartStatus}
return render(request, 'frontend/contact.html', context)
def rejectInvite(request, id):
invite = TutorInvitaions.objects.get(id = id)
student = Student.objects.get(username = request.user.username)
tutor = Tutor.objects.get(username = invite.inivitaion_by_tutor.username)
if request.method == "POST":
invite.delete()
student.invitations_recieved_rejected += 1
student.save()
tutor.invitations_sent_rejected += 1
tutor.save()
template = render_to_string("home/rejectEmail.html", {
"firstname": request.user.student.first_name,
"lastname": request.user.student.last_name,
"student_email": request.user.email
})
registerEmail = EmailMessage(
'Invitation Rejected',
template,
settings.EMAIL_HOST_USER,
[invite.inivitaion_by_tutor.email]
)
registerEmail.fail_silently = False
registerEmail.send()
messages.warning(request, f'Rejected Invite From {tutor.first_name} {tutor.last_name}')
return redirect("invitations_student")
context = {
"invite": invite
}
return render(request,'students/reject_invitation.html', context)
def create_meeting(request):
topic = request.POST['topic']
host = request.POST['host']
start = request.POST['start']
end = request.POST['end']
attendee = request.POST['attendee']
room = request.POST['room']
meeting = Meeting(
topic=topic,
host=host,
start=start,
end=end,
attendee=attendee,
room=room,
)
meeting.save()
attendee_list = attendee.split(",")
for i in attendee_list:
user = User.objects.get(last_name=i)
gmail = EmailMessage(
'您已被邀請至會議 ' + topic, # 電子郵件標題
'會議時間為：' + start + '\n會議地點為：NTUST TR ' + room, # 電子郵件內容
settings.EMAIL_HOST_USER, # 寄件者
[user.email] # 收件者
)
gmail.fail_silently = False
gmail.send()
return JsonResponse({"result": 1}, safe=False)
meeting = Meeting.objects.filter(topic=topic,
host=host,
start=start,
end=end)[0]
return JsonResponse({"result": 0, 'id': meeting.pk}, safe=False)
def contactView(request):
data = cartData(request)
cartItems = data['cartItems']
user_id = request.user.id
if request.method == 'POST':
if user_id == None:
template = render_to_string(
'shop/email_template.html', {
'name': request.POST['name'],
'email': request.POST['email'],
'message': request.POST['message'],
})
else:
user = request.user
template = render_to_string(
'shop/email_template.html', {
'name': user.customer.name,
'email': user.email,
'message': request.POST['message'],
})
email = EmailMessage(request.POST['subject'], template,
settings.EMAIL_HOST_USER, ['*****@*****.**'])
email.fail_silently = False
email.send()
return redirect('success')
return render(request, 'shop/contact.html', {'cartItems': cartItems})
def emailManager(request):
# getting email of a user related to manager group
group = Group.objects.get(name="manager")
usersList = group.user_set.all()
emails = []
for user in usersList:
emails.append(user.email)
# getting message from form input
message = request.POST.get('message')
# sending email
for email in emails:
template = render_to_string('store/frontend/emailbody.html',
{'message': message})
email = EmailMessage(
'Amart-message',
template,
settings.EMAIL_HOST_USER,
[email],
)
email.fail_silently = False
email.send()
return redirect('contact_manager')
def signup_view(response, is_business):
if response.method == "POST":
form = SignupForm(response.POST)
if form.is_valid():
user = form.save()
user.is_active = False
user.save()
if (is_business >= 1):
b = Business(user=user)
b.save()
elif (is_business <= 0):
f = Freelancer(user=user)
f.save()
current_site = get_current_site(response)
emailBody = render_to_string(
'confirmationmail/confirmationmail.html', {
'user': user.username,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'token': generate_token.make_token(user)
})
email = EmailMessage('HandsOnIT Account Activation', emailBody,
settings.EMAIL_HOST_USER, [user.email])
email.fail_silently = False
email.send()
return render(response, "signup/user_created.html",
{}) #TODO: redirect to profile page
else:
form = SignupForm()
return render(response, "signup/signup.html", {"form": form})
def api_email_verification(request, email):
try:
_user = User.objects.get(email=email)
token = resetToken.objects.get(myUser=_user)
token.delete()
except User.DoesNotExist:
return Response({"message": "user doesn't exist!"})
except resetToken.DoesNotExist:
pass
finally:
token = resetToken.objects.create(myUser=_user)
print(token.resetToken)
url = 'http://localhost:8000/api/update_password/'+_user.username
# send email with redirect link
email_form = EmailMessage(
'Rucksack: Here is the verification link.',
'click this link to update your password: '+url,
settings.EMAIL_HOST_USER,
[email],
)
email_form.fail_silently = False
email_form.send()
return Response({"message": "Email is successfully sent!"})
def sendmail(request, email, name):
name = request.session.get('name')
template = render_to_string('Prayer/email.html', {'name': name})
emailed = EmailMessage('The Prayer Partners', template,
settings.EMAIL_HOST_USER, [email])
emailed.fail_silently = False
emailed.send()
def register(request):
# If we get a POST request, we instantiate a user creation form with that POST data.
if request.user.is_authenticated:
alert = "You are alrd signed in!"
return redirect('users:index')
if request.method == 'POST':
form = UserRegisterForm(request.POST, request.FILES)
if form.is_valid():
# Creates the user in our database (Check admin page to confirm)
form.save()
username = form.cleaned_data.get('username')
to = form.cleaned_data.get('email')
name = form.cleaned_data.get('first_name')
status = ChallengeStatus(user=User.objects.get(username=username))
status.save()
# Create an alert to tell users that their account has been succesfully created
messages.success(
request,
f'You account has been created! Please log in to continue')
email = EmailMessage(
'Registration Confirmation',
f'Hi {name}! Thank you for registering for Creation 2021',
settings.EMAIL_HOST_USER,
[to],
)
email.fail_silently = False
email.send()
return redirect('login')
# Anything that isn't a POST request, we just create a blank form.
else:
form = UserRegisterForm
return render(request, 'users/backend/register.html', {'form': form})
def post(self, request):
form = Singupform(request.POST)
if form.is_valid():
user = form.save(commit=False)
print(User.objects.filter(username__exact=user.username))
print(User.objects.filter(username__exact=user.username).exists())
if not User.objects.filter(username__exact=user.username).exists() and \
not User.objects.filter(email__exact=user.email).exists():
user.is_active = False
user.save()
current_site = get_current_site(request)
subject = 'Active Your Account'
message = render_to_string(
'User/account_activation_email.html', {
'user': user,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'token': account_activate_token.make_token(user),
})
email = EmailMessage(
subject,
message,
settings.EMAIL_HOST_USER,
[user.email],
)
email.fail_silently = False
email.send()
return redirect('/user/account_active_sent/')
else:
return HttpResponse('Tai khoan da ton tai!')
else:
return HttpResponse('Nhap sai khi dang ky!')
def signup_statement_3(request):
if request.method == 'POST':
current_user = User.objects.get(username=request.user.username)
if hasattr(current_user, 'challengestatus'):
status = ChallengeStatus.objects.get(user=current_user)
status.register3 = True
status.save()
else:
status = ChallengeStatus(user=current_user, register3=True)
status.save()
to = current_user.email
email = EmailMessage(
'Challenge Statement Registration Confirmation',
'Succesfully registered for challenge statement 3',
settings.EMAIL_HOST_USER,
[to],
)
email.fail_silently = False
email.send()
conn = boto.connect_s3(config('AWS_ACCESS_KEY_ID'),
config('AWS_SECRET_ACCESS_KEY'))
bucket = conn.get_bucket('creation-2021')
pdf_file_path = bucket.get_key(
'assets/statement3.pdf'
) # remember to change back to respective pdf
pdf_url = pdf_file_path.generate_url(expires_in=600)
return render(request, "users/frontend/statement3.html",
{"pdf_url": pdf_url})
return render(request, "users/frontend/signup3.html")
def Register(request):
""" The registration view """
if request.method == 'POST':
form = UserRegisterForm(request.POST)
if form.is_valid():
#username = request.POST['username']
this_email = request.POST['email']
password = form.cleaned_data.get('password1')
password2 = form.cleaned_data.get('password2')
username = form.cleaned_data.get('username')
first_name = form.cleaned_data.get('first_name')
last_name = form.cleaned_data.get('last_name')
form.save()
#ENVOI AUTOMATIQUE DU MAIL
template = render_to_string('email.html', {'name': username})
#user_form.username = user_form.cleaned_data.get('username')
email = EmailMessage(
'Bienvenue chez UrbanStreet !',
template,
'*****@*****.**',
[this_email],
)
email.fail_silently = False
email.send()
messages.success(request, f'Compte pour {username} créé!')
return redirect('login')
else:
form = UserRegisterForm()
return render(request, 'userRegister.html', {'form': form})
def register(request):
form = RegisterUser()
if request.method == 'POST':
form = RegisterUser(request.POST)
if form.is_valid():
form.save()
email = form.cleaned_data.get('email')
username = form.cleaned_data.get('username')
site = str(get_current_site(request)) + '/verifyEmail/' + username
template = render_to_string('email.html', {
'user': username,
'site': site
})
email = EmailMessage(
'Confirm Email for KillMyURl',
template,
settings.EMAIL_HOST_USER,
[email],
)
email.fail_silently = False
email.send()
return redirect('loginU')
else:
print(form.cleaned_data)
messages.add_message(request, messages.ERROR, form.errors)
print('something went wrong with register form')
return render(request, 'register.html', context={'form': form})
def post(self, request, *args, **kwargs):
form=self.form_class(request.POST)
try:
email=request.POST['email']
emails=SubscribeEmail.objects.get(email=email)
except:
emails=None
if emails:
messages.error(request, "Bu email obuna bo'lingan!")
return redirect('/')
else:
if form.is_valid():
form.save(commit=False)
to=[form.cleaned_data.get('email')]
try:
send_message=EmailMessage(
"Mufaqqiyatli obuna bo'lindi!",
"Mufaqqiyatli obuna bo'ldingiz, bu sizga eng so'ngi e'lonlardan habardor bo'lasiz!",
settings.EMAIL_HOST_USER,
to,
)
send_message.fail_silently=False
send_message.send()
except:
messages.error(request, "server bilan bog'liq xatolik iltimos boshqattan urinib ko'ring!")
return redirect('/')
form.save()
messages.success(request,"Mufaqqiyatli obuna bo'lindi!")
return redirect('/')
messages.error(request, "Mufaqqiyatli obuna bo'linmadi iltimos tekshirib qayta urinib ko'ring !")
return redirect('/')
def register(request):
if request.method == 'POST':
form = UserRegisterForm(request.POST)
if form.is_valid():
form.save()
username = form.cleaned_data.get('username')
email = form.cleaned_data.get('email')
messages.success(
request,
f'{username} Account has been created. Now you are able to login'
)
email_subject = "Email confirmation"
email_body = 'Thank you for registering to TraWell !! Happy travelling.'
email = EmailMessage(
email_subject,
email_body,
settings.EMAIL_HOST_USER,
[email],
)
email.fail_silently = False
email.send()
return redirect('login')
else:
form = UserRegisterForm()
return render(request, 'Users/register.html', {'form': form})
def home(request):
group = None
tutors = Tutor.objects.all().count()
students = Student.objects.all().count()
if request.method == "POST":
name = request.POST.get('name')
email = request.POST.get('email')
message = request.POST.get('message')
template = render_to_string("home/contact.html", {
"name": name,
"email": email,
"message": message
})
registerEmail = EmailMessage(
'User Contact',
template,
settings.EMAIL_HOST_USER,
[settings.EMAIL_HOST_USER]
)
registerEmail.fail_silently = False
registerEmail.send()
return redirect("home_page")
if request.user.groups.exists():
group = request.user.groups.all()[0].name
context = {
'grp': group,
"page":"home",
"tutors": tutors,
"students": students
}
return render(request, 'home/index_page.html' , context)
def sanitize(request, pk):
if request.method == 'POST':
name = request.POST.get('Name')
email = request.POST.get('email')
locations = Locations.objects.filter(pk=pk)[0]
locations.sanitizer_mail = email
locations.sanitized = "Under Sanitization"
locations.save()
#email to locator
template_locator = render_to_string(
'Email_templates/email_to_locator.html', {
'name': name,
'email': email,
'Key': locations.pk
})
email_locator = EmailMessage(
name + ' , Has Claimed to Sanitize',
template_locator,
settings.EMAIL_HOST_USER,
[locations.locator_mail],
)
email_locator.fail_silently = False
email_locator.send()
# satu = int(locations[0].saturation)
context = {
"locations": locations,
# "satu":satu
}
return render(request, "sanitize.html", context)
else:
return HttpResponseRedirect('/')
def contractdelete(request, iod):
if request.user.is_authenticated:
obj = contractor.objects.get(id=iod)
context = {'obj': obj}
if not request.user == obj.user:
return HttpResponse(
'<h1>You cannot delete it as it was not registered by you,only {} can delete it</h1>'
.format(obj.user))
else:
if request.method == 'POST':
sendmail = EmailMessage(
'Your Contract is deleted}',
'Your contract with Reduct Nepal Pvt Limited as a {} ,which started at {} is deleted,'
.format(obj.role, obj.start_date),
settings.EMAIL_HOST_USER,
[obj.email],
)
sendmail.fail_silently = False
sendmail.send()
obj.delete()
return redirect('showcontract')
else:
return render(request, 'reductcontract/contractdelete.html',
context)
else:
return HttpResponse('<h1>You need to login first</h1>')
def register(request):
if request.method == 'POST':
form = UserAdminCreationForm(request.POST)
if form.is_valid():
user = form.save(commit=False)
user.is_active = False
user.save()
current_site = get_current_site(request)
mail_subject = 'Активация аккаунта'
message = render_to_string(
'main/mail_body.html', {
'user': user,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'token': account_activation_token.make_token(user),
})
to_email = form.cleaned_data.get('email')
email = EmailMessage(mail_subject,
message,
settings.EMAIL_HOST_USER,
to=[to_email])
email.fail_silently = False
email.send()
return render(request, 'main/confirm_email_alert.html')
else:
form = UserAdminCreationForm()
return render(request, 'main/register.html', {'form': form})
def register_view(request):
register_form = RegisterForm()
if request.method == "POST": # check method
register_form = RegisterForm(request.POST)
# Create a user that is not active
if register_form.is_valid():
user = register_form.save(commit=False)
user.is_active = False
register_form.save()
# Set up context for email message
current_site = get_current_site(request)
username = register_form.cleaned_data.get('username')
to_email = register_form.cleaned_data.get('email')
email_context = {
'name': username,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'token': account_activation_token.make_token(user)
}
email_message = render_to_string(
'accounts/emails/email_template.html', email_context)
email = EmailMessage('Thank You For Registering!', email_message,
settings.EMAIL_HOST_USER, [to_email])
email.fail_silently = False
email.send()
messages.success(
request, f"Account was created for {username}. "
f"Please check your email for an activation link")
return redirect("login")
context = {"form": register_form}
return render(request, 'accounts/register.html', context)
def contact(request):
if request.method == 'POST':
first_name = request.POST['first_name']
last_name = request.POST['last_name']
email = request.POST['email']
phone = request.POST['phone']
comments = request.POST['comments']
context = {
'first_name': first_name,
'last_name': last_name,
'email': email,
'phone': phone,
'comments': comments
}
template = render_to_string('pages/email_template.html', context)
email = EmailMessage(
'Inquiry on your website from ' + first_name + ' ' + last_name,
template,
settings.EMAIL_HOST_USER,
['*****@*****.**', '*****@*****.**', '*****@*****.**'],
)
email.fail_silently = False
email.send()
messages.success(request,
': Your enquiry has been made successfully')
return render(request, 'pages/contact.html')
def allow (request):
data={
'allows':hospital.objects.all().filter(allowed=0).order_by('-id')
}
if request.method=='POST':
username=request.POST['username']
email=request.POST['email']
hospital_id=request.POST['hospital_id']
hospital_name=request.POST['hospital_name']
hospital_update=hospital.objects.filter(id=hospital_id)
hospital_update.update(allowed=1)
mail_subject='Requested Hospital Allowed.'
current_site=get_current_site(request)
message = render_to_string('hand/superuser/allow_email.html', {
'website':current_site,
'user': username,
'hospital':hospital_name
})
email_activate = EmailMessage(
mail_subject,
message,
settings.EMAIL_HOST_USER,
[email]
)
email_activate.fail_silently=False
email_activate.send()
return render (request, 'hand/superuser/allow.html',data)
return render(request,'hand/superuser/allow.html',data)
def send(self, template_name, from_email, recipient_list, context, cc=None,
bcc=None, fail_silently=False, headers=None, template_prefix=None,
template_suffix=None, template_dir=None, file_extension=None,
**kwargs):
msg = EmailMessage(from_email=from_email, to=recipient_list)
msg.template_name = template_name
msg.global_merge_vars = context
msg.fail_silently = fail_silently
if cc:
msg.cc = cc
if bcc:
msg.bcc = bcc
msg.use_template_subject = kwargs.get('use_template_subject', True)
msg.use_template_from = kwargs.get('use_template_from', True)
msg.async = kwargs.get('async', True)
try:
msg.send()
except Exception as e:
if not fail_silently:
raise
return msg.extra_headers.get('Message-Id', None)
def meeting_update_view(request):
meeting = Meeting.objects.get(pk=request.POST['id'])
attendee_list1 = meeting.attendee.split(",")
meeting.topic = request.POST["topic"]
topic = request.POST["topic"]
meeting.host = request.POST["host"]
meeting.start = request.POST["start"]
start = request.POST["start"]
meeting.end = request.POST["end"]
meeting.attendee = request.POST["attendee"]
meeting.room = request.POST["room"]
room = request.POST["room"]
meeting.save()
attendee_list2 = meeting.attendee.split(",")
for i in attendee_list1:
ex = 0
for j in attendee_list2:
if (i == j):
ex = 1
if (ex == 0):
user = User.objects.get(last_name=i)
gmail = EmailMessage(
'您已被取消邀請' + topic, # 電子郵件標題
'會議時間為：' + start + '\n會議地點為：NTUST TR ' + room, # 電子郵件內容
settings.EMAIL_HOST_USER, # 寄件者
[user.email] # 收件者
)
gmail.fail_silently = False
gmail.send()
return JsonResponse({'result': 0})
def sign_up(request):
form = RegisterForm()
if request.method == "POST":
form = RegisterForm(request.POST)
if form.is_valid():
form.save()
# 電子郵件內容樣板
email_template = render_to_string(
'accounts/signup_success_email.html',
{'username': request.user.username})
email = EmailMessage(
'註冊成功通知信', # 電子郵件標題
email_template, # 電子郵件內容
settings.EMAIL_HOST_USER, # 寄件者
['*****@*****.**'] # 收件者
)
email.fail_silently = False
email.send()
return redirect('/login')
context = {'form': form}
return render(request, 'accounts/register.html', context)
def post(self, request, *args, **kwargs):
print(request.data)
data = request.data
user_profile_obj = Profile.objects.get(user=self.request.user)
thisBorrower = Borrower.objects.get(user=user_profile_obj)
message = data.get('message')
amount = data.get('amount')
LoanRequests.objects.create(
borrower=thisBorrower,
amount=amount,
request_status='Still Processing',
duration_figure=int(data.get('durationFigure')),
duration=data.get('durationPeriod'),
repayment_interval=data.get('repaymentInterval'),
slug=slugify("{borrower}-{amount}-{primaryKey}".format(
borrower=thisBorrower,
amount=data.get('amount'),
primaryKey=random_string_generator(6))))
# Send an Email Saying Loan Application Was Made By A User
html_ = "The User ({loanUser}), just applied for a loan, validate user account and process loan application".format(
loanUser=thisBorrower)
subject = 'New Loan Application From {loanUser}'.format(
loanUser=thisBorrower)
from_email = email_settings.EMAIL_HOST_USER
recipient_list = ['*****@*****.**']
from django.core.mail import EmailMessage
message = EmailMessage(subject, html_, from_email, recipient_list)
message.fail_silently = False
message.send()
return Response({'message': 'Loan Request Application Was Successful'},
status=201)
def RegisterPage(request):
# if request.user.is_authenticated:
# retrun home page
# above two lines no need but just keep in mind if you need to restrict any page with out autherisation
form = createuserform()
if request.method == "POST":
form = createuserform(request.POST)
if form.is_valid():
form.save()
user = form.cleaned_data.get('username')
email1 = form.cleaned_data.get('email')
messages.success(request,
'Account created successfully for : ' + user)
template = render_to_string('user/registeremailtemplate.html',
{'user': user})
email = EmailMessage(
'Thank you. Account Confirmation!',
template,
settings.EMAIL_HOST_USER,
[email1],
)
email.fail_silently = False
email.send()
return redirect('User:login')
context = {'form': form}
return render(request, 'user/register.html', context)
def send_email_and_get_code(request):
list_for_code = 'abcdefghijklmnopuwxyz'
random_string = '' #for future password
email_of_user = '' #email of user
email_is_sent = None
email_password_for_check = '' #check password from email
for i in range(6):
a = random.choice(list_for_code)
random_string = random_string + a
password_for_first_factor = random_string
Dictionary_of_data['PasswordForFirstFactor'] = password_for_first_factor
message = "Your password:"******"POST":
email_of_user = request.POST['email_entrance']
email = EmailMessage(
'First factor of Authrization',
message, #content of message
settings.EMAIL_HOST_USER,
[email_of_user], #email of user for sending
)
email.fail_silently = False
email.send()
return redirect('password_code/')
return render(request, 'main/emailcheck.html', {
'email': email_of_user,
'email_is_sent': email_is_sent
})
def cartsuccesspage(request, id):
profile = Profile.objects.filter(user__id=id)
customer = request.user
order, created = Order.objects.get_or_create(user1=customer,
complete=False)
items = order.orderitem_set.all()
template = render_to_string('user/cartemailtemplate.html', {
'items': items,
'profile': profile,
'order': order
})
email = EmailMessage(
'Thank you. Confirmation of order!',
template,
settings.EMAIL_HOST_USER,
[request.user.email],
)
email.fail_silently = False
email.send()
for item in items:
item.delete()
cartitems = order.get_cart_items
context = {'cartitems': cartitems}
return render(request, 'user/success.html', context)
def activate_view(request, uidb64, token):
try:
uid = force_text(urlsafe_base64_decode(uidb64))
student = User.objects.get(pk = uid)
except:
student = None
if student is not None and generate_token.check_token(student, token):
student.is_active = True
student.save()
template = render_to_string("home/registerEmail.html", {
"firstname": student.first_name,
"lastname": student.last_name,
"register_as" : "student"
})
registerEmail = EmailMessage(
'Registration Successful',
template,
settings.EMAIL_HOST_USER,
[student.email]
)
registerEmail.fail_silently = False
registerEmail.send()
messages.success(request,'account was created for ' + student.username)
return redirect("sign_in")
return render(request, 'students/activate_failed.html', status=401)
def register(request: WSGIRequest) -> HttpResponse:
if request.method == 'POST':
employee_form = EmployeeRegisterForm(request.POST)
if employee_form.is_valid():
cd: Dict = employee_form.cleaned_data
if NewEmployee.objects.filter(email=cd['email']).exists():
user = User.objects.create_user(
username=create_username_from_email(cd),
email=cd["email"],
password=cd["password"],
first_name=cd["first_name"],
last_name=cd["last_name"])
Employee.objects.create(employee=user, shop=cd['shop'])
NewEmployee.objects.get(email=cd['email']).delete()
template = render_to_string(
'shop/employee/email_template.html',
context={'name': user.first_name})
email = EmailMessage('Registration success', template,
settings.EMAIL_HOST_USER, [user.email])
email.fail_silently = False
email.send()
return render(request,
'shop/employee/register_done.html', {'form': cd},
status=HTTPStatus.OK)
return render(request,
'errors/register_error.html',
status=HTTPStatus.NOT_FOUND)
else:
employee_form = EmployeeRegisterForm()
return render(request,
'shop/employee/register.html', {'form': employee_form},
status=HTTPStatus.OK)
