def create(self, request, *args, **kwargs):
"""rewrite method create"""
if User.objects.filter(username=request.data['username']).exists():
return Response(
{
'error': 'LOGIN',
'message': 'User was NOT created, because LOGIN is exists'
},
status=status.HTTP_409_CONFLICT)
if User.objects.filter(email=request.data['email']).exists():
return Response(
{
'error': 'EMAIL',
'message': 'User was NOT created, because EMAIL is exists',
},
status=status.HTTP_409_CONFLICT)
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
email_confirm_token_send(user, self.get_token(user=user))
log.info(msg='User {} was registered'.format(user.username))
request.session.flush()
return Response(status=status.HTTP_201_CREATED, headers=headers)
def update(self, request, *args, **kwargs):
department_data = Departments.objects.get(id=int(request.data.get('id')))
department_data.name = request.data['name']
department_data.questions.set(request.data['questions'])
department_data.save()
serializer = DepartmentsSerializer(department_data)
log.info('Department {} was updated by {}'.format(serializer.data['name'],
request.user.username))
return Response(serializer.data, status=status.HTTP_201_CREATED)
def post(self, request, role):
request.data['role'] = role
candidate = PasswordlessRegistration(data=request.data)
candidate.is_valid(raise_exception=True)
registered = candidate.create(candidate.validated_data)
log.info(
'New {role} successfully registered as {username} by {recruiter}'.
format(role=role.title(),
username=registered.username,
recruiter=request.user.username))
email_confirm_token_send(registered, self.get_token(user=registered))
return Response(registered.id, status=status.HTTP_201_CREATED)
def login(request):
username = request.data.get("username")
password = request.data.get("password")
if username is None or password is None:
log.debug('username or password is none')
return Response({'error': 'Please provide both username and password'},
status=HTTP_400_BAD_REQUEST)
user = authenticate(request, username=username, password=password)
if not user:
log.debug('Server refused credentials')
return Response({'error': 'Invalid Credentials'},
status=HTTP_404_NOT_FOUND)
if user.is_active:
log.info('User {} sign in'. format(user.get_username()))
auth_login(request, user)
return Response(status=HTTP_200_OK)
def create(self, request, *args, **kwargs):
query_list = []
for comment in request.data:
try:
query_list.append(Comments(comment=comment.get('comment') if comment.get('comment') != '' else None,
f_grade_id=comment.get('grade'),
f_interview_id=comment.get('interview'),
f_question_id=comment.get('question')))
except Answers.DoesNotExist as error:
log.error(error)
return Response('Grades does not exist', status=status.HTTP_400_BAD_REQUEST)
serializer = CommentsSerializer(data=Comments.objects.bulk_create(query_list), many=True)
serializer.is_valid()
log.info('{} was validate candidate\'s answers'.format(request.user.username))
log.debug('{} comments was saved'.format(len(query_list)))
return Response(serializer.data, status=status.HTTP_201_CREATED)
def create(self, request, *args, **kwargs):
query_list = []
for question in request.data:
try:
query_list.append(
Answers(answer_like=question.get('answer_like'),
f_grade_id=question.get('grades'),
f_question_id=question.get('questions'),
f_interview_id=question.get('interviews')))
except Answers.DoesNotExist as error:
log.error(error)
return Response('Grades does not exist',
status=status.HTTP_400_BAD_REQUEST)
serializer = AnswersSerializer(
data=Answers.objects.bulk_create(query_list), many=True)
serializer.is_valid()
log.info('{} answered for poll'.format(request.user.username))
log.debug('{} answers was saved'.format(len(query_list)))
return Response(serializer.data, status=status.HTTP_201_CREATED)
def password_reset_token_created(sender, reset_password_token, *args,
**kwargs):
"""password_reset_token_created function"""
context = {
'current_user':
reset_password_token.user,
'username':
reset_password_token.user.username,
'email':
reset_password_token.user.email,
'reset_password_url':
"{SITE_URL}/password_reset/confirm/{}".format(
reset_password_token.key, SITE_URL=settings.SITE_URL)
}
subject = 'Contact Form Received'
from_email = settings.DEFAULT_FROM_EMAIL
to_email = [reset_password_token.user.email]
log.info('User {} requested password reset'.format(
reset_password_token.user.username))
email_html_message = get_template('mail_send.html').render(context)
is_email_sent = send_mail(subject, email_html_message, from_email,
to_email)
if is_email_sent:
log.info('Email was sent to {}'.format(
reset_password_token.user.email))
else:
log.info('Email was\'t sent')
return is_email_sent
def create(self, request, *args, **kwargs):
"""Get name from 'section', serialize it and get full JSON"""
try:
ser = SectionsSerializer(
Sections.objects.get(id=request.data['section']))
except Sections.DoesNotExist as error:
log.error(error)
return Response('Section does not exist',
status=status.HTTP_400_BAD_REQUEST)
request.data['section'] = ser.data
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
log.info('Stage {} was created by {}'.format(serializer.data['name'],
request.user.username))
return Response(serializer.data,
status=status.HTTP_201_CREATED,
headers=headers)
def create(self, request, *args, **kwargs):
try:
recruiter = UserDataSerializer(UserData.objects.get(f_auth_id=self.request.user.id))
candidate = UserDataSerializer(UserData.objects.get(f_auth_id=request.data['candidate']))
expert = UserDataSerializer(UserData.objects.get(f_auth_id=request.data['expert']))
department = DepartmentsSerializer(Departments.objects
.get(id=request.data['department']))
department.to_representation = department.original_representation
if recruiter.data['auth']['id'] == candidate.data['auth']['id'] or \
recruiter.data['auth']['id'] == expert.data['auth']['id'] or \
candidate.data['auth']['id'] == expert.data['auth']['id']:
return Response('Users can not be the same!', status=status.HTTP_400_BAD_REQUEST)
if recruiter.data['role']['name'] != 'recruiter':
log.error('User {} with role {} tries to create interview'
.format(request.user.username, recruiter.data['role']['name']))
return Response('You aren\'t recruiter!', status=status.HTTP_400_BAD_REQUEST)
except UserData.DoesNotExist as error:
log.error(error)
return Response('User does not exist!', status=status.HTTP_400_BAD_REQUEST)
except Departments.DoesNotExist as error:
log.error(error)
return Response('Department does not exist!', status=status.HTTP_400_BAD_REQUEST)
request.data['recruiter'] = recruiter.data
request.data['candidate'] = candidate.data
request.data['expert'] = expert.data
request.data['department'] = department.data
request.data['created_date'] = datetime.date.today()
request.data['status'] = 'scheduled'
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
log.info(self.perform_create(serializer))
return Response(serializer.data, status=status.HTTP_201_CREATED)
def create(self, request, *args, **kwargs):
"""Get name from 'departments', serialize it and get full JSON"""
list_questions = []
for i in request.data['questions']:
try:
ser = QuestionsSerializer(Questions.objects.get(id=i))
list_questions.append(ser.data)
except Questions.DoesNotExist:
log.error('Question with id={} doesn\'t exist'.format(i))
return Response('question does not exist',
status=status.HTTP_400_BAD_REQUEST)
request.data['questions'] = list_questions
serializer = DepartmentsSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
log.info('Department {} was created by {}'.format(serializer.data.get('name'),
request.user.username))
log.debug('Department was created with {} questions'.format(len(list_questions)))
return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
def get(self, request, token, *args, **kwargs):
if token:
try:
decoded = jwt.decode(token,
settings.SECRET_KEY,
algorithms=['HS256'])
user = User.objects.get(id=decoded['id'])
user.is_active = True
user.save()
log.info('Email {} verified!'.format(user.email))
auth_login(request,
user,
backend='django.contrib.auth.backends.ModelBackend')
return redirect('/home/')
except Exception as exp:
log.error(exp)
raise exp
except jwt.ExpiredSignatureError:
return Response('User was NOT confirm, because time went out ',
status=status.HTTP_409_CONFLICT)
def update(self, request, *args, **kwargs):
log.info('Stage {} was updated by {}'.format(request.data['name'],
request.user.username))
return super().update(request, *args, **kwargs)
def create(self, request, *args, **kwargs):
log.info('Section {} was created by {}'.format(request.data['name'],
request.user.username))
return super().create(request, *args, **kwargs)
def post(self, request, *args, **kwargs):
thread = super().post(request, *args, **kwargs)
log.info('User {} changed the password'.format(request.user.username))
return thread
def create(self, request, *args, **kwargs):
log.info('New grade was created by {}'.format(request.user.username))
return super().create(request, *args, **kwargs)
def update(self, request, *args, **kwargs):
log.info('Grade with id: {} was updated by {}'.format(
request.data.get('id'), request.user.username))
return super().update(request, *args, **kwargs)
