def downvote(request, blog_pk):
body = request.data
if 'recaptcha_token' in body and utils.verify_recaptcha(
None, body['recaptcha_token'],
'blog_stats') == ResponseCodes.verify_recaptcha_failed:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.verify_recaptcha_failed),
safe=False)
try:
blog = models.Blog.objects.get(pk=blog_pk)
vote = models.Vote.objects.filter(user=request.user, blog=blog)
if len(vote) == 0:
vote = models.Vote(user=request.user, blog=blog, vote_type=False)
else:
vote = vote[0]
vote.vote_type = False
vote.save()
return JsonResponse(create_response(data=BlogSnippetSerializer(
instance=blog, many=False, context={
'user': request.user
}).data),
safe=False)
except Exception as e:
log(e, 'e')
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.blog_couldnt_found),
safe=False)
def auth_social_user(request):
body = JSONParser().parse(request)
if 'recaptcha_token' in body and utils.verify_recaptcha(
None, body['recaptcha_token'],
'signin') == ResponseCodes.verify_recaptcha_failed:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.verify_recaptcha_failed),
safe=False)
post_data = {
'client_id': body['client_id'],
'client_secret': body['client_secret'],
'grant_type': 'convert_token'
}
provider = body['provider']
post_data['backend'] = provider
if provider == 'linkedin-oauth2':
post_data['token'] = get_access_token_with_code(body['token'])
else:
post_data['token'] = body['token']
response = requests.post('http://localhost:8000/auth/convert-token',
data=json.dumps(post_data),
headers={'content-type': 'application/json'})
json_res = json.loads(response.text)
log(json_res, 'e')
if 'error' in json_res:
success = False
code = ResponseCodes.invalid_credentials
else:
success = True
code = ResponseCodes.success
user = AccessToken.objects.get(token=json_res['access_token']).user
if 'first_name' in body:
user.first_name = body['first_name']
if 'last_name' in body:
user.first_name = body['last_name']
if 'photo_url' in body:
utils.save_image_file_to_user(body['photo_url'], user)
if 'user_type' in body:
user.user_type = UserType.objects.get(pk=body['user_type'])
elif user.user_type is None:
user.user_type = UserType.objects.get(name__iexact='Undefined')
user.signup_flow_completed = True
json_res['user_type'] = UserTypeSerializer(instance=user.user_type,
many=False).data
json_res['signup_flow_completed'] = user.signup_flow_completed
user.approved = True
user.last_login = timezone.now()
LoginLog.objects.create(user=user)
user.save()
if provider == 'google-oauth2':
user.is_gmail_read_ok = True
user.save()
schedule_fetcher(user.id)
return JsonResponse(create_response(data=json_res,
success=success,
error_code=code),
safe=False)
def do_action(request, blog_pk, type):
body = request.data
if 'recaptcha_token' in body and utils.verify_recaptcha(
None, body['recaptcha_token'],
'blog_stats') == ResponseCodes.verify_recaptcha_failed:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.verify_recaptcha_failed),
safe=False)
blog = Blog.objects.get(pk=blog_pk)
if type == ActionType.view:
blog.view_count = blog.view_count + 1
blog.save()
else:
if type == ActionType.none:
Vote.objects.filter(user=request.user, blog=blog).delete()
else:
vote, new = Vote.objects.get_or_create(user=request.user,
blog=blog)
if type == ActionType.upvote:
vote.vote_type = True
elif type == ActionType.downvote:
vote.vote_type = False
vote.save()
return JsonResponse(create_response(data=None))
def login(request):
body = JSONParser().parse(request)
post_data = {
'client_id': body['client_id'],
'client_secret': body['client_secret'],
'grant_type': 'password',
'username': body['username'],
'password': body['password']
}
user = authenticate(username=body['username'], password=body['password'])
if user is None:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.invalid_credentials),
safe=False)
# if not user.approved:
# return JsonResponse(create_response(data=None, success=False, error_code=ResponseCodes.email_verification_required), safe=False)
if 'recaptcha_token' in body and utils.verify_recaptcha(
user.email, body['recaptcha_token'],
'signin') == ResponseCodes.verify_recaptcha_failed:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.verify_recaptcha_failed),
safe=False)
response = requests.post('http://localhost:8000/auth/token',
data=json.dumps(post_data),
headers={'content-type': 'application/json'})
json_res = json.loads(response.text)
if 'error' in json_res:
success = False
code = ResponseCodes.couldnt_login
else:
success = True
code = ResponseCodes.success
json_res['user_type'] = UserTypeSerializer(instance=user.user_type,
many=False).data
json_res['signup_flow_completed'] = user.signup_flow_completed
user = AccessToken.objects.get(token=json_res['access_token']).user
user.last_login = timezone.now()
user.save()
LoginLog.objects.create(user=user)
return JsonResponse(create_response(data=json_res,
success=success,
error_code=code),
safe=False)
def auth_social_user(request):
body = JSONParser().parse(request)
if 'recaptcha_token' in body and utils.verify_recaptcha(
None, body['recaptcha_token'],
'signin') == ResponseCodes.verify_recaptcha_failed:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.verify_recaptcha_failed),
safe=False)
post_data = {
'client_id': body['client_id'],
'client_secret': body['client_secret'],
'grant_type': 'convert_token'
}
provider = body['provider']
post_data['backend'] = provider
if provider == 'linkedin-oauth2':
post_data['token'] = get_access_token_with_code(body['token'])
else:
post_data['token'] = body['token']
response = requests.post('http://localhost:8000/auth/convert-token',
data=json.dumps(post_data),
headers={'content-type': 'application/json'})
json_res = json.loads(response.text)
log(json_res, 'e')
if 'error' in json_res:
success = False
code = ResponseCodes.invalid_credentials
else:
success = True
code = ResponseCodes.success
user = AccessToken.objects.get(token=json_res['access_token']).user
json_res['user_type'] = user.user_type
user.save()
user.approved = True
user.save()
if provider == 'google-oauth2':
user.is_gmail_read_ok = True
user.save()
schedule_fetcher(user.id)
return JsonResponse(create_response(data=json_res,
success=success,
error_code=code),
safe=False)
def feedback(request):
body = request.data
if 'recaptcha_token' in body and utils.verify_recaptcha(
request.user.email, body['recaptcha_token'],
'feedback') == ResponseCodes.verify_recaptcha_failed:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.verify_recaptcha_failed),
safe=False)
text = body['text']
star = body['star']
user = request.user
Feedback.objects.create(user=user, text=text, star=star)
send_notification_email_to_admins('feedback')
return JsonResponse(create_response(data=None), safe=False)
def verify_recaptcha(request):
body = request.data
if 'recaptcha_token' not in body or 'action' not in body:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.verify_recaptcha_failed),
safe=False)
elif utils.verify_recaptcha(
request.user.email, body['recaptcha_token'],
body['action']) == ResponseCodes.verify_recaptcha_failed:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.verify_recaptcha_failed),
safe=False)
else:
return JsonResponse(create_response(data=None, success=True),
safe=False)
def login(request):
body = JSONParser().parse(request)
post_data = {
'client_id': body['client_id'],
'client_secret': body['client_secret'],
'grant_type': 'password',
'username': body['username'],
'password': body['password']
}
user = authenticate(username=body['username'], password=body['password'])
if user is None:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.invalid_credentials),
safe=False)
# if not user.approved:
# return JsonResponse(create_response(data=None, success=False, error_code=ResponseCodes.email_verification_required), safe=False)
if 'recaptcha_token' in body and utils.verify_recaptcha(
user.email, body['recaptcha_token'],
'signin') == ResponseCodes.verify_recaptcha_failed:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.verify_recaptcha_failed),
safe=False)
response = requests.post('http://localhost:8000/auth/token',
data=json.dumps(post_data),
headers={'content-type': 'application/json'})
json_res = json.loads(response.text)
if 'error' in json_res:
success = False
code = ResponseCodes.couldnt_login
else:
success = True
code = ResponseCodes.success
json_res['user_type'] = user.user_type
return JsonResponse(create_response(data=json_res,
success=success,
error_code=code),
safe=False)
def view(request, blog_pk):
body = request.data
if 'recaptcha_token' in body and utils.verify_recaptcha(
None, body['recaptcha_token'],
'blog_stats') == ResponseCodes.verify_recaptcha_failed:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.verify_recaptcha_failed),
safe=False)
try:
blog = models.Blog.objects.get(pk=blog_pk)
blog.view_count = blog.view_count + 1
blog.save()
return JsonResponse(create_response(data=None), safe=False)
except:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.blog_couldnt_found),
safe=False)
def forgot_password(request):
body = JSONParser().parse(request)
if 'recaptcha_token' in body and utils.verify_recaptcha(
None, body['recaptcha_token'],
'forgot_password') == ResponseCodes.verify_recaptcha_failed:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.verify_recaptcha_failed),
safe=False)
username = body['username']
try:
user = User.objects.get(
Q(username__iexact=username) | Q(email__iexact=username))
activation_key, expiration_time = utils.generate_activation_key_and_expiredate(
user.username)
user.forgot_password_key = activation_key
user.forgot_password_key_expires = expiration_time
user.save()
utils.send_email(user.email, activation_key, 'validateForgotPassword')
except Exception as e:
log(traceback.format_exception(None, e, e.__traceback__), 'e')
return JsonResponse(create_response(data=None, success=True), safe=False)
def feedback(request):
body = request.data
if 'recaptcha_token' in body and utils.verify_recaptcha(
request.user.email, body['recaptcha_token'],
'feedback') == ResponseCodes.verify_recaptcha_failed:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.verify_recaptcha_failed),
safe=False)
text = body['text']
star = body['star']
user = request.user
if user.username.startswith('demo'):
from_demo_account = True
else:
from_demo_account = False
Feedback.objects.create(user=user,
text=text,
star=star,
from_demo_account=from_demo_account)
send_notification_email_to_admins('feedback', feedback.user.college.id)
return JsonResponse(create_response(data=None), safe=False)
def notes(request, pos_app_pk):
body = request.data
if 'recaptcha_token' in body and utils.verify_recaptcha(
None, body['recaptcha_token'],
'jobapp_note') == ResponseCodes.verify_recaptcha_failed:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.verify_recaptcha_failed),
safe=False)
if request.method == "GET":
if pos_app_pk is None:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.invalid_parameters),
safe=False)
else:
notes_list = PositionApplicationNote.objects.filter(
pos_app__pk=pos_app_pk).order_by('-updated_date',
'-created_date')
notes_list = PositionApplicationNoteSerializer(instance=notes_list,
many=True).data
return JsonResponse(create_response(
data=notes_list,
success=True,
error_code=ResponseCodes.success),
safe=False)
elif request.method == "POST":
description = body['description']
if pos_app_pk is None or description is None:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.invalid_parameters),
safe=False)
else:
user_job_app = PositionApplication.objects.get(pk=pos_app_pk)
if user_job_app.user == request.user:
note = PositionApplicationNote(pos_app=user_job_app,
description=description)
note.save()
data = PositionApplicationNoteSerializer(instance=note,
many=False).data
return JsonResponse(create_response(
data=data, success=True, error_code=ResponseCodes.success),
safe=False)
else:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.record_not_found),
safe=False)
elif request.method == "PUT":
jobapp_note_id = body['jobapp_note_id']
description = body['description']
if jobapp_note_id is None:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.invalid_parameters),
safe=False)
else:
note = PositionApplicationNote.objects.get(pk=jobapp_note_id)
if note.pos_app.user == request.user:
note.description = description
note.updated_date = timezone.now()
note.save()
data = PositionApplicationNoteSerializer(instance=note,
many=False).data
return JsonResponse(create_response(
data=data, success=True, error_code=ResponseCodes.success),
safe=False)
else:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.record_not_found),
safe=False)
elif request.method == "DELETE":
jobapp_note_id = body['jobapp_note_id']
if jobapp_note_id is None:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.invalid_parameters),
safe=False)
else:
user_job_app_note = PositionApplicationNote.objects.get(
pk=jobapp_note_id)
if user_job_app_note.pos_app.user == request.user:
user_job_app_note.delete()
return JsonResponse(create_response(
data=None, success=True, error_code=ResponseCodes.success),
safe=False)
else:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.record_not_found),
safe=False)
def link_social_account(request):
body = request.data
if 'recaptcha_token' in body and utils.verify_recaptcha(
None, body['recaptcha_token'],
'signin') == ResponseCodes.verify_recaptcha_failed:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.verify_recaptcha_failed),
safe=False)
post_data = {
'client_id': body['client_id'],
'client_secret': body['client_secret'],
'grant_type': 'convert_token'
}
provider = body['provider']
post_data['backend'] = provider
if provider == 'linkedin-oauth2':
if request.user.social_auth.filter(
provider='linkedin-oauth2').count() == 0:
post_data['token'] = get_access_token_with_code(body['token'])
else:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.account_already_linked),
safe=False)
else:
if request.user.social_auth.filter(
provider='google-oauth2').count() == 0:
post_data['token'] = body['token']
else:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.account_already_linked),
safe=False)
response = requests.post('http://localhost:8001/auth/convert-token',
data=json.dumps(post_data),
headers={'content-type': 'application/json'})
json_res = json.loads(response.text)
log(json_res, 'e')
if 'error' in json_res:
success = False
code = ResponseCodes.invalid_credentials
else:
social_user = UserSocialAuth.objects.get(
extra_data__icontains=post_data['token'])
if social_user.user.email != request.user.email:
social_user.user.delete()
social_user.user = request.user
social_user.save()
post_data = {
'token': json_res['access_token'],
'client_id': body['client_id'],
'client_secret': body['client_secret']
}
headers = {'content-type': 'application/json'}
response = requests.post('http://localhost:8001/auth/revoke-token',
data=json.dumps(post_data),
headers=headers)
log(str(response), 'e')
if provider == 'google-oauth2':
request.user.is_gmail_read_ok = True
request.user.save()
return JsonResponse(create_response(
data=ProfileSerializer(instance=request.user, many=False).data),
safe=False)
return JsonResponse(create_response(data=None,
success=success,
error_code=code),
safe=False)
def update_profile(request):
body = request.data
if 'recaptcha_token' in body and utils.verify_recaptcha(
request.user.email, body['recaptcha_token'],
'update_profile') == ResponseCodes.verify_recaptcha_failed:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.verify_recaptcha_failed),
safe=False)
user = request.user
if 'password' in body:
user.set_password(body['password'])
if 'username' in body:
if User.objects.filter(username=body['username']).exists():
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.username_exists),
safe=False)
user.username = body['username']
if 'first_name' in body:
user.first_name = body['first_name']
if 'last_name' in body:
user.last_name = body['last_name']
if 'gender' in body:
user.gender = body['gender']
if 'dob' in body:
user.dob = datetime.strptime(body['dob'], "%Y-%m-%d").date()
if 'student_email' in body:
user.student_email = body['student_email']
if 'is_email_public' in body:
user.is_email_public = body['is_email_public']
if 'phone_number' in body:
user.phone_number = body['phone_number']
if 'emp_status_id' in body:
if EmploymentStatus.objects.filter(
pk=body['emp_status_id']).count() > 0:
user.emp_status = EmploymentStatus.objects.get(
pk=body['emp_status_id'])
user_type, new = UserType.objects.get_or_create(name__iexact='Employer')
if 'college_id' in body:
if College.objects.filter(pk=body['college_id']).count() > 0:
user.college = College.objects.get(pk=body['college_id'])
if 'major' in body:
user.major = insert_or_update_major(body['major'])
if 'grad_year' in body:
user.grad_year = body['grad_year']
if 'job_title' in body:
job_title = body['job_title']
user.job_position = get_or_insert_position(job_title)
if 'company' in body:
company = body['company']
user.company = get_or_create_company(company)
if 'country_id' in body and 'state_id' in body:
state = State.objects.get(pk=body['state_id'])
if state.country.id != body['country_id']:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.invalid_parameters),
safe=False)
country = Country.objects.get(pk=body['country_id'])
user.country = country
user.state = state
user.signup_flow_completed = True
user.save()
return JsonResponse(create_response(
data=ProfileSerializer(instance=user, many=False).data),
safe=False)
def register(request):
# Get form values
body = JSONParser().parse(request)
if 'recaptcha_token' in body and utils.verify_recaptcha(
None, body['recaptcha_token'],
'signup') == ResponseCodes.verify_recaptcha_failed:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.verify_recaptcha_failed),
safe=False)
first_name = ''
last_name = ''
linkedin_auth_code = None
google_access_token = None
if 'first_name' in body:
first_name = body['first_name']
if 'last_name' in body:
last_name = body['last_name']
if 'linkedin_auth_code' in body:
linkedin_auth_code = body['linkedin_auth_code']
if 'google_access_token' in body:
google_access_token = body['google_access_token']
user_type, new = UserType.objects.get_or_create(name__iexact='Employer')
username = body['username']
email = body['email']
password = body['password']
password2 = body['password2']
if '@' in username:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.invalid_username),
safe=False)
# Check if passwords match
if password == password2:
# Check username
if User.objects.filter(username__iexact=username).exists():
success = False
code = ResponseCodes.username_exists
else:
if User.objects.filter(email__iexact=email).exists():
success = False
code = ResponseCodes.email_exists
else:
# Looks good
user = User.objects.create_user(username=username,
password=password,
email=email,
first_name=first_name,
user_type=user_type,
last_name=last_name,
approved=False,
activation_key=None,
key_expires=None)
user.save()
if linkedin_auth_code is None and google_access_token is None:
activation_key, expiration_time = utils.generate_activation_key_and_expiredate(
body['username'])
user.activation_key = activation_key
user.key_expires = expiration_time
user.save()
utils.send_email(user.email, activation_key, 'activate')
post_data = {
'client_id': body['client_id'],
'client_secret': body['client_secret'],
'grant_type': 'password',
'username': username,
'password': password
}
response = requests.post(
'http://localhost:8001/auth/token',
data=json.dumps(post_data),
headers={'content-type': 'application/json'})
json_res = json.loads(response.text)
if 'error' in json_res:
success = False
code = ResponseCodes.couldnt_login
else:
success = True
code = ResponseCodes.success
json_res['user_type'] = UserTypeSerializer(
instance=user.user_type, many=False).data
json_res[
'signup_flow_completed'] = user.signup_flow_completed
return JsonResponse(create_response(data=json_res,
success=success,
error_code=code),
safe=False)
else:
post_data = {
'client_id': body['client_id'],
'client_secret': body['client_secret'],
'grant_type': 'convert_token'
}
if linkedin_auth_code is not None:
post_data['backend'] = 'linkedin-oauth2'
post_data['token'] = get_access_token_with_code(
body['linkedin_auth_code'])
else:
post_data['backend'] = 'google-oauth2'
post_data['token'] = body['google_access_token']
response = requests.post(
'http://localhost:8001/auth/convert-token',
data=json.dumps(post_data),
headers={'content-type': 'application/json'})
jsonres = json.loads(response.text)
log(jsonres, 'e')
if 'error' in jsonres:
success = False
code = ResponseCodes.invalid_credentials
else:
social_user = UserSocialAuth.objects.get(
extra_data__icontains=post_data['token'])
if social_user.user.email != user.email:
social_user.user.delete()
social_user.user = user
social_user.save()
success = True
code = ResponseCodes.success
user = AccessToken.objects.get(
token=jsonres['access_token']).user
jsonres['user_type'] = UserTypeSerializer(
instance=user.user_type, many=False).data
jsonres[
'signup_flow_completed'] = user.signup_flow_completed
user.approved = True
user.save()
return JsonResponse(create_response(data=jsonres,
success=success,
error_code=code),
safe=False)
else:
success = False
code = ResponseCodes.passwords_do_not_match
return JsonResponse(create_response(data=None,
success=success,
error_code=code),
safe=False)
def job_applications(request):
body = request.data
if 'recaptcha_token' in body and utils.verify_recaptcha(
None, body['recaptcha_token'],
'add_job') == ResponseCodes.verify_recaptcha_failed:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.verify_recaptcha_failed),
safe=False)
if request.method == "GET":
timestamp = request.GET.get('timestamp')
if timestamp is not None:
timestamp = int(timestamp) / 1000
if timestamp is None:
return JsonResponse(
create_response(
data=None,
success=False,
error_code=ResponseCodes.invalid_parameters))
profile = request.user
time = datetime.fromtimestamp(int(timestamp))
user_job_apps = JobApplication.objects.filter(created__gte=time)
job_application_list = JobApplicationSerializer(
instance=user_job_apps,
many=True,
context={
'user': request.user
}).data
response = {
'data': job_application_list,
'synching': profile.synching
}
return JsonResponse(create_response(data=response), safe=False)
status_id = request.GET.get('status_id')
if status_id is not None:
user_job_apps = JobApplication.objects.filter(
application_status__id=status_id,
user__id=request.user.id,
is_deleted=False).order_by('-apply_date')
else:
user_job_apps = JobApplication.objects.filter(
user_id=request.user.id,
is_deleted=False).order_by('-apply_date')
job_applications_list = JobApplicationSerializer(
instance=user_job_apps, many=True, context={
'user': request.user
}).data
return JsonResponse(create_response(data=job_applications_list),
safe=False)
elif request.method == "POST":
job_title = body['job_title']
company = body['company']
application_date = body['application_date']
status = int(body['status_id'])
source = body['source']
jt = get_or_insert_position(job_title)
jc = get_or_create_company(company)
if Source.objects.filter(value__iexact=source).count() == 0:
source = Source.objects.create(value=source)
else:
source = Source.objects.get(value__iexact=source)
job_application = JobApplication(position=jt,
company_object=jc,
apply_date=application_date,
msg_id='',
app_source=source,
user=request.user)
job_application.application_status = ApplicationStatus.objects.get(
pk=status)
job_application.save()
return JsonResponse(create_response(
data=JobApplicationSerializer(instance=job_application,
many=False,
context={
'user': request.user
}).data),
safe=False)
elif request.method == "PUT":
status_id = body.get('status_id')
rejected = body.get('rejected')
job_application_ids = []
if 'jobapp_ids' in body:
job_application_ids = body['jobapp_ids']
if 'jobapp_id' in body:
job_application_ids.append(body['jobapp_id'])
if len(job_application_ids) == 0:
return JsonResponse(create_response(
success=False, error_code=ResponseCodes.record_not_found),
safe=False)
elif rejected is None and status_id is None:
return JsonResponse(create_response(
success=False, error_code=ResponseCodes.record_not_found),
safe=False)
else:
user_job_apps = JobApplication.objects.filter(
pk__in=job_application_ids)
if user_job_apps.count() == 0:
return JsonResponse(create_response(
success=False, error_code=ResponseCodes.record_not_found),
safe=False)
else:
for user_job_app in user_job_apps:
if user_job_app.user == request.user:
if status_id is None:
user_job_app.is_rejected = rejected
else:
new_status = ApplicationStatus.objects.filter(
pk=status_id)
if new_status.count() == 0:
return JsonResponse(
create_response(data=None,
success=False,
error_code=ResponseCodes.
invalid_parameters),
safe=False)
else:
if rejected is None:
user_job_app.application_status = new_status[
0]
else:
user_job_app.application_status = new_status[
0]
user_job_app.is_rejected = rejected
status_history = StatusHistory(
job_post=user_job_app,
application_status=new_status[0])
status_history.save()
if rejected is not None:
user_job_app.rejected_date = datetime.now()
user_job_app.updated_date = datetime.now()
user_job_app.save()
return JsonResponse(create_response(data=None), safe=False)
elif request.method == "PATCH":
job_app_id = body.get('jobapp_id')
if job_app_id is None:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.record_not_found),
safe=False)
user_job_app = JobApplication.objects.get(pk=job_app_id)
if user_job_app.user != request.user:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.record_not_found),
safe=False)
if user_job_app.msg_id is not None and user_job_app.msg_id != '':
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.record_not_found),
safe=False)
job_title = body.get('job_title')
company = body.get('company')
application_date = body.get('application_date')
source = body.get('source')
if application_date is not None:
user_job_app.apply_date = application_date
if job_title is not None:
user_job_app.position = get_or_insert_position(job_title)
if company is not None:
user_job_app.company_object = get_or_create_company(company)
if source is not None:
if Source.objects.filter(value__iexact=source).count() == 0:
source = Source.objects.create(value=source)
else:
source = Source.objects.get(value__iexact=source)
user_job_app.app_source = source
user_job_app.updated_date = datetime.now()
user_job_app.save()
return JsonResponse(create_response(data=JobApplicationSerializer(
instance=user_job_app, many=False, context={
'user': request.user
}).data),
safe=False)
elif request.method == "DELETE":
job_application_ids = []
if 'jobapp_ids' in body:
job_application_ids = body['jobapp_ids']
if 'jobapp_id' in body:
job_application_ids.append(body['jobapp_id'])
if len(job_application_ids) == 0 or JobApplication.objects.filter(
pk__in=job_application_ids).count() == 0:
return JsonResponse(create_response(
success=False, error_code=ResponseCodes.record_not_found),
safe=False)
else:
user_job_apps = JobApplication.objects.filter(
pk__in=job_application_ids)
for user_job_app in user_job_apps:
if user_job_app.user == request.user:
user_job_app.deleted_date = datetime.now()
user_job_app.is_deleted = True
user_job_app.save()
return JsonResponse(create_response(data=None), safe=False)
def position_applications(request):
body = request.data
if 'recaptcha_token' in body and utils.verify_recaptcha(
None, body['recaptcha_token'],
'add_job') == ResponseCodes.verify_recaptcha_failed:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.verify_recaptcha_failed),
safe=False)
if request.method == "GET":
status_id = request.GET.get('status_id')
if status_id is not None:
user_job_apps = PositionApplication.objects.filter(
Q(user__id=request.user.id)
| Q(position__company=request.user.company),
application_status__id=status_id,
is_deleted=False).order_by('-apply_date')
else:
user_job_apps = PositionApplication.objects.filter(
Q(user__id=request.user.id)
| Q(position__company=request.user.company),
is_deleted=False).order_by('-apply_date')
job_applications_list = PositionApplicationSerializer(
instance=user_job_apps, many=True, context={
'user': request.user
}).data
return JsonResponse(create_response(data=job_applications_list),
safe=False)
elif request.method == "POST":
position_id = body['position_id']
company = body['company']
application_date = body['application_date']
status = int(body['status_id'])
first_name = body['first_name']
last_name = body['last_name']
jt = PositionDetail.objects.get(pk=position_id)
jc = get_or_create_company(company)
job_application = PositionApplication(position=jt,
company_object=jc,
first_name=first_name,
last_name=last_name,
apply_date=application_date,
user=request.user)
job_application.application_status = ApplicationStatus.objects.get(
pk=status)
job_application.save()
return JsonResponse(create_response(
data=PositionApplicationSerializer(instance=job_application,
many=False,
context={
'user': request.user
}).data),
safe=False)
elif request.method == "PUT":
status_id = body.get('status_id')
rejected = body.get('rejected')
job_application_ids = []
if 'jobapp_ids' in body:
job_application_ids = body['jobapp_ids']
if 'jobapp_id' in body:
job_application_ids.append(body['jobapp_id'])
if len(job_application_ids) == 0:
return JsonResponse(create_response(
success=False, error_code=ResponseCodes.record_not_found),
safe=False)
elif rejected is None and status_id is None:
return JsonResponse(create_response(
success=False, error_code=ResponseCodes.record_not_found),
safe=False)
else:
user_job_apps = PositionApplication.objects.filter(
pk__in=job_application_ids)
if user_job_apps.count() == 0:
return JsonResponse(create_response(
success=False, error_code=ResponseCodes.record_not_found),
safe=False)
else:
for user_job_app in user_job_apps:
if user_job_app.user == request.user:
if status_id is None:
user_job_app.is_rejected = rejected
else:
new_status = ApplicationStatus.objects.filter(
pk=status_id)
if new_status.count() == 0:
return JsonResponse(
create_response(data=None,
success=False,
error_code=ResponseCodes.
invalid_parameters),
safe=False)
else:
if rejected is None:
user_job_app.application_status = new_status[
0]
else:
user_job_app.application_status = new_status[
0]
user_job_app.is_rejected = rejected
status_history = StatusHistory(
pos_app=user_job_app,
application_status=new_status[0])
status_history.save()
if rejected is not None:
user_job_app.rejected_date = timezone.now()
user_job_app.updated_date = timezone.now()
user_job_app.save()
return JsonResponse(create_response(data=None), safe=False)
elif request.method == "PATCH":
job_app_id = body.get('jobapp_id')
if job_app_id is None:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.record_not_found),
safe=False)
user_job_app = PositionApplication.objects.get(pk=job_app_id)
if user_job_app.user != request.user:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.record_not_found),
safe=False)
job_title = body.get('job_title')
company = body.get('company')
application_date = body.get('application_date')
source = body.get('source')
if application_date is not None:
user_job_app.apply_date = application_date
if job_title is not None:
user_job_app.position = get_or_insert_position(job_title)
if company is not None:
user_job_app.company_object = get_or_create_company(company)
user_job_app.updated_date = timezone.now()
user_job_app.save()
return JsonResponse(create_response(data=PositionApplicationSerializer(
instance=user_job_app, many=False, context={
'user': request.user
}).data),
safe=False)
elif request.method == "DELETE":
job_application_ids = []
if 'jobapp_ids' in body:
job_application_ids = body['jobapp_ids']
if 'jobapp_id' in body:
job_application_ids.append(body['jobapp_id'])
if len(job_application_ids) == 0 or PositionApplication.objects.filter(
pk__in=job_application_ids).count() == 0:
return JsonResponse(create_response(
success=False, error_code=ResponseCodes.record_not_found),
safe=False)
else:
user_job_apps = PositionApplication.objects.filter(
pk__in=job_application_ids)
for user_job_app in user_job_apps:
if user_job_app.user == request.user:
user_job_app.deleted_date = timezone.now()
user_job_app.is_deleted = True
user_job_app.save()
return JsonResponse(create_response(data=None), safe=False)
def reviews(request):
body = request.data
user = request.user
if 'recaptcha_token' in body and utils.verify_recaptcha(
user, body['recaptcha_token'],
'review') == ResponseCodes.verify_recaptcha_failed:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.verify_recaptcha_failed),
safe=False)
if request.method == "GET" and user.user_type.name == 'Career Service':
reviews_list = Review.objects.filter(is_published=False,
is_rejected=False,
user__college=user.college)
return JsonResponse(create_response(
data=ReviewSerializer(instance=reviews_list, many=True).data),
safe=False)
elif request.method == "PATCH":
if request.user.user_type.name == 'Career Service':
body = request.data
review = Review.objects.get(pk=body['review_id'])
approved = body['approved']
review.is_published = approved
review.is_rejected = not approved
review.save()
return JsonResponse(create_response(data=None), safe=False)
else:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.not_supported_user),
safe=False)
elif request.method == "GET":
company_id = request.GET.get('company_id')
position_id = request.GET.get('position_id')
all_reviews = get_boolean_from_request(request, 'all_reviews')
review_id = request.GET.get('review_id')
if review_id is not None:
reviews_list = Review.objects.filter(pk=review_id,
user=request.user)
if reviews_list.count() == 0:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.record_not_found),
safe=False)
return JsonResponse(create_response(data=ReviewSerializer(
instance=reviews_list[0], many=False).data),
safe=False)
elif company_id is None and position_id is None:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.invalid_parameters),
safe=False)
if company_id is None:
reviews_list = Review.objects.filter(Q(is_published=True)
| Q(user=request.user),
position__pk=position_id)
elif position_id is None:
reviews_list = Review.objects.filter(Q(is_published=True)
| Q(user=request.user),
company__pk=company_id)
else:
if all_reviews:
reviews_list = Review.objects.filter(is_published=True,
position__pk=position_id,
company__pk=company_id)
else:
reviews_list = Review.objects.filter(user=request.user,
position__pk=position_id,
company__pk=company_id)
if reviews_list.count() > 0:
return JsonResponse(create_response(data=ReviewSerializer(
instance=reviews_list[0], many=False).data),
safe=False)
else:
return JsonResponse(create_response(data=None), safe=False)
return JsonResponse(create_response(
data=ReviewSerializer(instance=reviews_list, many=True).data),
safe=False)
else:
if 'company_id' not in body or 'position_id' not in body:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.invalid_parameters),
safe=False)
company = Company.objects.get(pk=body['company_id'])
position = JobPosition.objects.get(pk=body['position_id'])
if request.method == "PUT":
review = Review.objects.get(pk=body['review_id'])
if review.user.pk != user.pk:
return JsonResponse(create_response(
data=None,
success=False,
error_code=ResponseCodes.record_not_found),
safe=False)
review.update_date = timezone.now()
elif request.method == "POST":
review = Review()
review.company = company
review.position = position
review.user = request.user
if 'pros' in body:
review.pros = body['pros']
if 'cons' in body:
review.cons = body['cons']
if 'interview_notes' in body:
review.interview_notes = body['interview_notes']
if 'overall_company_experience' in body:
review.overall_company_experience = body[
'overall_company_experience']
if 'interview_difficulty' in body:
review.interview_difficulty = body['interview_difficulty']
if 'overall_interview_experience' in body:
review.overall_interview_experience = body[
'overall_interview_experience']
if 'anonymous' in body:
review.anonymous = body['anonymous']
if 'emp_auths' in body:
for a in body['emp_auths']:
if 'value' in a:
auth = EmploymentAuth.objects.get(pk=a['id'])
review.save()
if CompanyEmploymentAuth.objects.filter(
review=review, employment_auth=auth).count() == 0:
c_auth = CompanyEmploymentAuth(review=review,
employment_auth=auth,
value=a['value'])
c_auth.save()
else:
c_auth = CompanyEmploymentAuth.objects.get(
review=review, employment_auth=auth)
c_auth.value = a['value']
c_auth.save()
if 'emp_status_id' in body:
review.emp_status = EmploymentStatus.objects.get(
pk=body['emp_status_id'])
if 'source_type_id' in body:
review.source_type = SourceType.objects.get(
pk=body['source_type_id'])
# publish review if there is no content to approve
if 'pros' not in body and 'cons' not in body and 'interview_notes' not in body:
review.is_published = True
else:
review.is_published = False
send_notification_email_to_admins('review', review.user.college.id)
review.save()
response = {
'review':
ReviewSerializer(instance=review, many=False).data,
'company':
CompanySerializer(instance=company,
many=False,
context={
'user': request.user,
'position': position
}).data
}
return JsonResponse(create_response(data=response), safe=False)
