def post(self, request):
user = request.data.get('user', {})
# The create serializer, validate serializer, save serializer pattern
# below is common.
serializer = self.serializer_class(data=user)
serializer.is_valid(raise_exception=True)
serializer.save()
user = User.objects.get(email=serializer.data['email'])
current_site = get_current_site(request)
print(current_site)
mail_subject = 'Activate your Vconnect account.'
message = render_to_string(
'acc_active_email.html', {
'user': user,
'domain': current_site,
'uid': urlsafe_base64_encode(force_bytes(user.pk)).decode(),
'token': account_activation_token.make_token(user),
})
print(message)
to_email = serializer.data['email']
email = EmailMessage(mail_subject, message, to=[to_email])
print(email, to_email)
email.send()
serializer.data['is_active'] = False
return Response(serializer.data, status=status.HTTP_201_CREATED)
def signup(request):
if request.method == 'POST':
form = SignUpForm(request.POST)
if form.is_valid():
# if Captcha.is_valid():
user = form.save(commit=False)
user.user_type = form.cleaned_data.get('user_type')
user.is_active = False
user.save()
current_site = get_current_site(request)
mail_subject = 'Activate your blog 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),
})
to_email = form.cleaned_data.get('email')
email = EmailMessage(mail_subject, message, to=[to_email])
email.send()
return HttpResponse(
'Please confirm your email address to complete the registration'
)
else:
form = SignUpForm()
return render(request, 'registration/signup.html', {'form': form})
def initial_user_profile(sender, instance, created, **kwargs):
if created:
profile_obj = Profile.objects.create(
user = instance,
agen = instance
)
Wallet.objects.create(
profile = profile_obj
)
# Sending Email
domain = 'http://www.warungid.com/activate/{}/{}/'.format(
urlsafe_base64_encode(force_bytes(instance.pk)),
account_activation_token.make_token(instance)
)
subject = 'Warungid Account Activation'
message = render_to_string('core/account_activation_email.html', {
'user': instance,
'domain': domain,
# 'uid': urlsafe_base64_encode(force_bytes(instance.pk)),
# 'token': account_activation_token.make_token(instance),
})
send_mail(subject, message, '*****@*****.**', [instance.email])
def sign_up_email_confirmation(**kwargs):
"""
Send email from html file
"""
user_id = kwargs.get('user_id')
email = kwargs.get('email')
domain = kwargs.get('domain')
user = get_model_by_id(User, user_id)
uid = urlsafe_base64_encode(force_bytes(user.pk))
# Token for mail
num = random.randint(1, 101)
token_seed = TokenAux(user=user, counter=num)
token_seed.save()
token = account_activation_token.make_token(user)
link = f'{domain}activate/account/{uid}/{token}'
# Sending email
mail_data = {
'from_email': getattr(settings, 'DEFAULT_FROM_EMAIL'),
'to_email': email,
'subject': CONFIRM_EMAIL,
'email_template_name': 'email/account/register_successfully.html',
'html_email_template_name': 'email/account/register_successfully.html',
'context': {
'user': user,
'link': link,
},
}
send_mail(**mail_data)
def signup(request):
if request.method == 'POST':
form = SignUpForm(request.POST)
if form.is_valid():
user = form.save(commit=False)
user.is_active = False
user.save()
current_site = get_current_site(request)
subject = 'Activate Your MySite 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),
})
# mail = EmailMessage(subject, messages, user.email)
# mail.send()
user.email_user(subject, message)
messages.success(
request,
('Please Confirm your email to complete registration.'))
return redirect('login')
else:
form = SignUpForm()
return render(request, 'signup.html', {'form': form})
def signup_view(request):
if request.method == 'POST':
form = SignUpForm(request.POST)
if form.is_valid():
user = form.save()
user.refresh_from_db()
# Profile fields
user.profile.first_name = form.cleaned_data.get('first_name')
user.profile.last_name = form.cleaned_data.get('last_name')
user.profile.room_no = form.cleaned_data.get('room_no')
user.profile.department = form.cleaned_data.get('department')
user.profile.hall = form.cleaned_data.get('hall')
user.profile.level = form.cleaned_data.get('level')
user.is_active = False
user.save()
current_site = get_current_site(request)
subject = 'Activate Your Raffle 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),
})
user.email_user(subject, message)
return redirect('account_activation_sent')
else:
pass
# TODO: Invalid form
else:
form = SignUpForm()
return render(request, 'core/signup.html', {'form': form})
def post(self, request, *args, **kwargs):
form = self.form_class(request.POST)
if form.is_valid():
user = form.save(commit=False)
user.is_active = False # Deactivate account till it is confirmed
user.save()
current_site = get_current_site(request)
subject = 'Activate Your MySite Account'
message = render_to_string(
'emails/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),
})
user.email_user(subject, message)
messages.success(
request,
('Please Confirm your email to complete registration.'))
return redirect('login')
return render(request, self.template_name, {'form': form})
def signup(request):
if request.method == 'POST':
form2 = ProfileForm(request.POST)
form1 = SignUpForm(request.POST)
if form1.is_valid() and form2.is_valid():
# form1.save()
# user = form1.save()
# form2 = form2.save(commit=False)
# form2.user = user
# form2.save()
user = form1.save(commit=False)
user.is_active = False # Deactivate account till it is confirmed
user.save()
form2 = form2.save(commit=False)
form2.user = user
form2.save()
current_site = get_current_site(request)
mail_subject = 'Activate your Ergo Life Account.'
message = render_to_string(
'account/email_confirmation_message.html', {
'user': user,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'token': account_activation_token.make_token(user),
})
to_email = form1.cleaned_data.get('email')
email = EmailMessage(mail_subject, message, to=[to_email])
email.send()
messages.success(request, (
'Please Confirm your email to complete registration. You are able to login once your email gets verified'
))
# return HttpResponse('Please confirm your email address to complete the registration')
return redirect('/')
# current_site = get_current_site(request)
# subject = 'Activate Your ErgoLife Account'
# message = render_to_string('account/email_confirmation_message.html', {
# 'user': user,
# 'domain': current_site.domain,
# 'uid': urlsafe_base64_encode(force_bytes(user.pk)),
# 'token': account_activation_token.make_token(user),
# })
# user.email_user(subject, message)
# form2.save()
# messages.success(request, ('Please Confirm your email to complete registration.'))
# messages.success(request, f'Registration complete! You may log in!')
# username = form1.cleaned_data.get('username')
# raw_password = form1.cleaned_data.get('password1')
# user = authenticate(username=username, password=raw_password)
# login(request, user)
# return redirect('home')
# return redirect('/')
else:
form2 = ProfileForm()
form1 = SignUpForm()
return render(request, 'signup.html', {'form1': form1, 'form2': form2})
def notify(request, user):
current_site = get_current_site(request)
context_dict = {
'name': '{0} {1}'.format(user.last_name, user.first_name),
'user': user,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'token': account_activation_token.make_token(user),
}
txt_message = render_to_string('account_activation_email.txt',
context_dict)
html_message = render_to_string('account_activation_email.html',
context_dict)
subject, from_email, to = 'Grade-X: Verification Required', '*****@*****.**', user.email
msg = EmailMultiAlternatives(subject, txt_message, from_email, [to])
msg.attach_alternative(html_message, "text/html")
try:
msg.send()
messages.info(request,
'Check your email for a link to activate your account.')
return HttpResponseRedirect(reverse('account_activation_sent'))
except: #I activate the user if I can't send email and log.
user.is_active = True
user.save()
if user is not None:
login(request, user)
messages.success(request, 'Your account is now active')
return HttpResponseRedirect(reverse('dashboard'))
def signup(request):
'''
View for handling signup:
- creates user and set the active status as false
- sends email on console
'''
if request.method == 'POST':
form = SignUpForm(request.POST)
if form.is_valid():
user = form.save(commit=False)
user.is_active = False
user.save()
current_site = get_current_site(request)
subject = 'Activate Your MySite 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),
})
user.email_user(subject, message)
return redirect('account_activation_sent')
else:
form = SignUpForm()
return render(request, 'signup.html', {'form': form})
def send_mail(request, user, register=True):
current_site = get_current_site(request)
subject = 'Подтверждение почты'
if register:
token = account_activation_token.make_token(user)
template = 'users/activate-message.html'
to_email = user.username
else:
token = change_email_token.make_token(user)
template = 'users/change-email-message.html'
to_email = user.new_email
message = render_to_string(
template, {
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'token': token,
})
from_email = MailFromString.objects.first().host_user
email = EmailMessage(subject,
message,
from_email=from_email,
to=[to_email])
email.send()
def create(self, validated_data):
user = User.objects.create_user(**validated_data)
user.is_active = False
subject = "Email de confirmação | Confirme seu cadastro na plataforma EducomML"
message = render_to_string(
'email_template.html', {
'user': user,
'domain': 'educomml-back.herokuapp.com',
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'token': account_activation_token.make_token(user),
})
user.email_user(subject, message)
return user
def signup(request):
if request.method == 'POST':
form = SignUpForm(request.POST)
if form.is_valid():
user = form.save(commit=False)
user.is_active = False
user.save()
current_site = get_current_site(request)
subject = 'Activate Your MySite Account'
tokenVal = account_activation_token.make_token(user)
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)
return redirect('account_activation_sent')
else:
form = SignUpForm()
return render(request, 'signup.html', {'form': form})
def registration_borrower(request):
"""
Registration as borrower.
:param request: request object
:return: registration done page or borrower registration page
"""
if request.method == 'POST':
borrower_form = BorrowerForm(request.POST)
if borrower_form.is_valid():
user_data = {
'first_name': borrower_form.cleaned_data.get('first_name'),
'last_name': borrower_form.cleaned_data.get('last_name'),
'email': borrower_form.cleaned_data.get('email'),
'username': borrower_form.cleaned_data.get('username'),
'password': borrower_form.cleaned_data.get('password1')}
user = User.objects.create_user(**user_data)
user.first_name = user_data['first_name']
user.last_name = user_data['last_name']
user.save()
borrower_data = {
'phone_number': borrower_form.cleaned_data.get('phone_number'),
'phone_number_mobile': borrower_form.cleaned_data.get('phone_number_mobile')
}
borrower = Borrower.objects.create(user=user, **borrower_data)
borrower.user.is_active = False
borrower.user.save()
current_site = get_current_site(request)
subject = 'Aktivieren Sie Ihren Account beim Ressourcenpool'
message = render_to_string('accounts/registration/account_activation_email.jinja', {
'user': user,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(user.pk)).decode(),
'token': account_activation_token.make_token(user),
})
user.email_user(subject, message)
return redirect('accounts:registration_done')
else:
print(borrower_form.errors)
return render(request, 'accounts/registration/registration_borrower.jinja',
{'borrower_form': borrower_form,
'title': 'Registrierung: Leiher'})
else:
return render(request, 'accounts/registration/registration_borrower.jinja',
{'borrower_form': BorrowerForm(),
'title': 'Registrierung: Leiher'})
def sendmail_activation(request, user):
subject = 'FineFine :: Activación de cuenta'
current_site = get_current_site(request)
message = render_to_string(
'accounts/signup_email.html', {
'domain': current_site.domain,
'user': user,
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'token': account_activation_token.make_token(user),
})
#-- sendmail
user.email_user(subject, message)
return True
def send_mail(request, user):
current_site = get_current_site(request)
mail_subject = 'Подтверждение почты'
message = render_to_string(
'users/activate-message.html', {
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'token': account_activation_token.make_token(user),
})
to_email = user.email
from_email = MailFromString.objects.first().host_user
email = EmailMessage(mail_subject,
message,
from_email=from_email,
to=[to_email])
email.send()
def ResetPassword(request):
email = request.data.get('email')
response = Response()
try:
user = User.objects.get(email=email)
subject = "Redefinição de senha | EducomML"
message = render_to_string('reset_password.html', {
'user': user,
'domain': 'https://educomml-back.herokuapp.com',
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'token': account_activation_token.make_token(user),
})
user.email_user(subject, message)
response.data = {
'status': 1, 'message': 'Email para redefinição de senha enviado com sucesso! Verifique sua caixa de emails.'}
except:
response.data = {'status': 0, 'message': 'Email não cadastrado'}
return response
def reset(request):
if request.method == "POST":
email = request.POST.get('user_email')
user = User.objects.get(email=email)
if user:
current_site = get_current_site(request).domain
subject = "Redefinição de senha enviada!"
token = account_activation_token.make_token(user)
reset_confirm_reverse = reverse('reset_confirm', kwargs={ "token": token, "pk": user.pk })
url = "{}{}".format(current_site, reset_confirm_reverse)
message = url
send_mail(subject, message, '*****@*****.**', [email], fail_silently=False)
return redirect('reset_done')
return render(request, "registration/reset.html", context={})
def signup(request):
serializer = UserSerializer(data=request.data)
if request.method == 'POST':
if serializer.is_valid():
user = serializer.save(is_active=False)
#user.is_active = False # Deactivate account till it is confirmed
current_site = get_current_site(request)
subject = 'Activate Your Account'
message = render_to_string(
'emails/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),
})
user.email_user(subject, message)
messages.success(
request,
('Please Confirm your email to complete registration.'))
return Response(serializer.initial_data)
def post(self, request, *args, **kwargs):
form = self.form_class(request.POST)
if form.is_valid():
user = form.save(commit=False)
user.is_active = False
user.save()
current_site = get_current_site(request)
subject = 'Activate your City issue tracker account'
message = render_to_string('accounts/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),
})
user.email_user(subject, message, from_email=settings.EMAIL_HOST_USER)
messages.success(request, 'Please, confirm your email to complete registration.')
return redirect('login')
return render(request, self.template_name, {'form': form})
def post(self, request):
serializer = PersonSerializer(data=request.data)
if serializer.is_valid():
instance = serializer.validated_data
person = Person(email=instance.get('email'),
first_name=instance.get('first_name'),
last_name=instance.get('last_name'),
cpf=instance.get('cpf'),
birthday=instance.get('birthday'),
phone=instance.get('phone'),
cell_phone=instance.get('cell_phone'),
neighborhood=instance.get('neighborhood'),
street=instance.get('street'),
number=instance.get('number'),
cep=instance.get("cep"),
uf=instance.get("uf"),
city=instance.get("city"),
complement=instance.get("complement"))
with transaction.atomic():
person.set_password(instance.get('password'))
person.photo = request.FILES.get('photo')
person.save()
subject = "Ative sua conta"
context = {}
context['user'] = person
context['domain'] = get_current_site(request).domain
context['uid'] = urlsafe_base64_encode(force_bytes(
person.pk)).decode()
context['token'] = account_activation_token.make_token(person)
context['protocol'] = 'https' if request.is_secure(
) else 'http'
send_mail_template(subject, "emails/activate_email.html",
context, [instance.get('email')])
return Response(
serializer.data,
status=status.HTTP_201_CREATED,
)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def registration_lender(request):
"""
Registration as lender.
:param request: request object
:return: registration done page or lender registration page
"""
if request.method == 'POST':
lender_form = LenderForm(request.POST, request.FILES)
if lender_form.is_valid():
user_data = {
'first_name': lender_form.cleaned_data.get('first_name'),
'last_name': lender_form.cleaned_data.get('last_name'),
'email': lender_form.cleaned_data.get('email'),
'username': lender_form.cleaned_data.get('username'),
'password': lender_form.cleaned_data.get('password1')}
user = User.objects.create_user(**user_data)
user.first_name = user_data['first_name']
user.last_name = user_data['last_name']
user.save()
lender_data = {
'phone_number': lender_form.cleaned_data.get('phone_number'),
'phone_number_mobile': lender_form.cleaned_data.get('phone_number_mobile'),
'type': lender_form.cleaned_data.get('type'),
'description': lender_form.cleaned_data.get('description'),
'default_loan_agreement': lender_form.cleaned_data.get('loan_agreement'),
'website': lender_form.cleaned_data.get('website')
}
location, _ = Location.objects.get_or_create(title=lender_form.cleaned_data['location_title'],
street=lender_form.cleaned_data['location_street'],
house_number=lender_form.cleaned_data['location_house_number'],
city=lender_form.cleaned_data['location_city'],
latitude=lender_form.cleaned_data['location_latitude'],
longitude=lender_form.cleaned_data['location_longitude'])
lender_data['location'] = location
lender = Lender.objects.create(user=user, **lender_data)
lender.user.is_active = False
lender.user.save()
current_site = get_current_site(request)
subject = 'Aktivieren Sie Ihren Account beim Ressourcenpool'
message = render_to_string('accounts/registration/account_activation_email.jinja', {
'user': user,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(user.pk)).decode(),
'token': account_activation_token.make_token(user),
})
user.email_user(subject, message)
return redirect('accounts:registration_done')
else:
return render(request, 'accounts/registration/registration_lender.jinja',
{'lender_form': lender_form,
'title': 'Registrierung als Verleiher',
})
else:
return render(request, 'accounts/registration/registration_lender.jinja',
{'lender_form': LenderForm(),
'title': 'Registrierung als Verleiher'
})
def post(self, request):
from core.models import User, Employee
from employee_dashboard.models.Employee_Extra_Info import Employee_Extra_Info
from dateutil.parser import parse
from django.core.exceptions import ValidationError
from employee_dashboard.models.Section import Section
from django.contrib.sites.shortcuts import get_current_site
from django.template.loader import render_to_string
from django.utils.http import urlsafe_base64_encode
from django.utils.encoding import force_bytes
from core.tokens import account_activation_token
data = request.data
user = User()
user.email = data['email']
user.first_name = data['first_name']
user.last_name = data['last_name']
user.date_joined = data['hiring_date']
user.username = data['username']
user.position = data['position']
user.national_id = data['national_id']
user.phone_number = data['phone_number']
user.office_phone = data['office_number']
user.date_of_birth = data['date_of_birth']
user.is_employee = True
employee = Employee()
employee.employer = request.user.employer
employee.user = user
employee_extra = Employee_Extra_Info()
employee_extra.employee = employee
employee_extra.nationality = data['nationality']
employee_extra.job_title = data['job_title']
try:
employee_extra.direct_manager = Employee.objects.get(
user__email=data.get('direct_manager')) if data.get(
'direct_manager') else None
employee_extra.supervisor = Employee.objects.get(
user__email=data.get('supervisor')) if data.get(
'supervisor') else None
except Employee.DoesNotExist:
return Response({
'success':
False,
'message':
'Supervisor or Direct Manager Does Not Exist'
})
try:
employee_extra.section = Section.objects.get(
name=data.get('section')) if data.get('section') else None
except Section.DoesNotExist:
return Response({
'success':
False,
'message':
'The Section {} Does Not Exist'.format(data['section'])
})
employee_extra.birth_date = data['date_of_birth']
employee_extra.hiring_date = data['hiring_date']
employee_extra.end_of_contract = data['end_of_contract']
employee_extra.end_of_probation = data['end_of_probation']
employee_extra.marital_status = data['marital_status']
employee_extra.branch = data['branch']
employee_extra.sick_day_balance = 30
employee_extra.base_salary = data['base_salary']
employee_extra.GOSI_salary = data['GOSI_salary']
employee_extra.available_annual_vacation_balance = 30
employee_extra.gender = data['gender']
employee_extra.salutation = data['salutation']
employee_extra.status = 'Active'
try:
with transaction.atomic():
user.save()
employee.save()
employee_extra.save()
except ValidationError as e:
return Response({'success': False, 'message': e.message})
except IntegrityError:
return Response({
'success': False,
'message': 'Email or Username Already Exist'
})
current_site = get_current_site(request)
subject = 'Activate Employee Account'
message = render_to_string(
'core/account_activation_email.html', {
'user': employee,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(employee.pk)),
'token': account_activation_token.make_token(user)
})
user.email_user(subject, message, from_email='*****@*****.**')
return Response({'success': True})
