def get(self, request, job_id):
user = request.user
receive_resume_query = ReceiveResume.objects.filter(
hr_user=user,
id=job_id,
action='send',
company_action='waiting',
).select_related(
'job',
'resume',
)
if receive_resume_query:
with transaction.atomic():
receive_resume = receive_resume_query[0]
receive_resume.company_action = 'unfit'
receive_resume.save()
NotifyUtils.company_notify(receive_resume, 'fail')
return JsonResponse({
'status': 'ok',
'msg': '操作成功',
})
def post(self, request, vip_id):
user_vip_query = UserVip.objects.select_related('user', ).filter(
id=vip_id, )
if not user_vip_query:
raise Http404
expire_time = datetime.datetime.now()
user_vip = user_vip_query[0]
user = user_vip.user
user_vip.expire_time = expire_time
user_vip.save()
SelfServiceUtils.set_experience_user(user)
return JsonResponse({
'result': 'success',
'new_data': {
'offline_pay': u'操作成功'
},
'new_html': {
'offline_pay': u'操作成功'
},
})
def get(self, request):
today = get_today()
time_limit = today + datetime.timedelta(days=-2)
if time_limit < MARK_TIME:
has_mark = False
else:
user = request.user
need_mark_query = ResumeBuyRecord.objects.filter(
user=user,
status='LookUp',
finished_time__gt=MARK_TIME,
finished_time__lte=time_limit,
).exclude(
resume_mark__current_mark__end_status=True,
resume_mark__accu_status__in=(0, 1, 2),
)
has_mark = True if need_mark_query else False
return JsonResponse({
'status': 'ok',
'has_mark': has_mark,
'redirect_url': '/transaction/unmark_resume/',
'msg': 'ok',
})
def get(self, request):
task_query = Task.objects.all()
task_status_query = TaskFinishedStatus.objects.filter(
user=request.user
).values(
'task',
'current_process',
'finished_status',
'reward_status',
)
task_status_dict = self.task_status_dict_mapper(task_status_query)
task_status = self.add_task_finished_status(task_query, task_status_dict)
task_status = self.check_once_task_is_finished(request.user, task_status)
recent_reward_detail = self.get_recently_reward_records()
task_status = self.order_status_list(task_status)
all_task = {
'status': 'ok',
'task_count': len(task_status),
'data': task_status,
'recent': recent_reward_detail,
}
return JsonResponse(all_task)
def post(self, request, feed_id):
feed_id = get_oid(feed_id)
username = request.user.username
now = datetime.datetime.now()
update_data = json_util.loads(request.body)
for r in update_data.get('remarks', []):
if not r.get('username'):
r['username'] = username
if not r.get('op_time'):
r['op_time'] = now
r['necessary_keywords'] = r.get(
'necessary_keywords', '').split() if r.get(
'necessary_keywords', '') else []
r['exclude_job_keywords'] = r.get(
'exclude_job_keywords', '').split() if r.get(
'exclude_job_keywords', '') else []
r['latent_semantic_keywords'] = r.get(
'latent_semantic_keywords', '').split() if r.get(
'latent_semantic_keywords', '') else []
feed_query = Feed2.objects.filter(id=feed_id, )
if feed_query:
feed = feed_query[0]
update_feed = update_document(
feed,
ignored=update_data.get('ignored', False),
remarks=update_data.get('remarks'),
)
update_feed.save()
return JsonResponse({
'status': 'ok',
'msg': '保存成功',
})
def get(self, request):
gift_pool = cache.get(self.gift_pool_key, {})
return JsonResponse(gift_pool)
def post(self, request):
data = request.POST
user = request.user
task_data = data.get('task_data')
task_times, task_code = task_data.split('_', 1)
task_times = int(task_times)
task = Task.objects.filter(
task_code=task_code,
task_count=task_times
)
if not task:
return JsonResponse({
'status': 'error',
'msg': 'error task_code',
})
task = task[0]
if self.check_weixin_is_required(user, task):
return JsonResponse({
'status': 'error',
'msg': 'weixin bind required',
})
if self.is_address_add(user, task):
return JsonResponse({
'status': 'error',
'msg': 'address required'
})
if task.task_level in [1, 2, 3]:
not_receive_num = TaskFinishedStatus.objects.filter(
user=request.user,
task=task,
finished_status=2,
task_times=task_times,
reward_status=1,
).update(
reward_status=2,
reward_time=datetime.now()
)
elif task.task_level == 4:
not_receive_num = TaskFinishedStatus.objects.filter(
user=request.user,
task=task,
finished_status=2,
task_times=task_times,
reward_status=1,
).update(
reward_status=1,
finished_status=1,
)
elif task.task_level == 5:
not_receive_num = TaskFinishedStatus.objects.filter(
user=request.user,
task=task,
finished_status=2,
task_times=task_times,
reward_status=1,
).update(
reward_status=1,
finished_status=1,
current_process=0,
reward_time=None,
)
self.check_user_nofity_status(user)
if not_receive_num == 0:
return JsonResponse({
'status': 'error',
'msg': 'task_code error or reward_status is due'
})
self.reward_provide(task, user)
return JsonResponse({
'status': 'ok',
'msg': 'success',
})
def post(self, request):
client_id = get_int(request.POST.get('client_id'))
CRMClientInfo.objects.filter(client__id=client_id).update(admin=None)
return JsonResponse({'status': 'ok', 'msg': '取消成功'})
def get(self, request):
'''
兼容接口请求和页面请求
'''
ajax_request = request.is_ajax()
all_feed = self.get_all_feed()
has_rest_feed = self.has_rest_feed()
if not all_feed:
if ajax_request:
return JsonResponse({
'status': 'no_feed',
'msg': '没有定制',
})
return render(
request,
'feed_home_page.html',
{},
)
all_feed_dict = [{
'feed': {
'id': str(f.feed.id),
'keywords': f.feed.keywords,
'salary_min': f.feed.salary_min,
'salary_max': f.feed.salary_max,
'expect_area': f.feed.expect_area,
'talent_level': f.feed.talent_level,
'feed_type': f.feed.feed_type,
'unread_count': f.feed.unread_count,
'expire_status': f.feed.expire_status,
'has_expire': f.feed.has_expire,
'start_time': f.feed.start_time,
'partner_feed': f.feed.partner_feed,
'job_type': f.feed.job_type,
'title': f.feed.title,
'last_click_time': f.feed.last_click_time,
'calced': f.feed.calced,
},
} for f in all_feed]
current_vip = VipRoleUtils.get_current_vip(request.user)
data = {
'all_feed': all_feed_dict,
'has_rest_feed': has_rest_feed,
'vip_user': True if current_vip else False,
}
if ajax_request:
return JsonResponse({
'status': 'ok',
'data': data,
'msg': 'ok',
})
data_json = json.dumps(data, default=json_util.default)
return render(
request,
self.template_name,
{
'data': data_json,
'all_feed': all_feed,
'has_rest_feed': has_rest_feed,
},
)
def post(self, request):
if self.malice_ip():
return JsonResponse({
'status': 'error',
'msg': '错误次数太多，请稍后再试',
'errors': {
"username": ['错误次数太多，请稍后再试']
}
})
post_data = request.JSON
username = post_data.get('username')
password = post_data.get('password')
next_url = post_data.get('next', reverse('special-feed-page'))
if not error_phone(username) and not PinbotAccount.is_phone_bind(
mobile=username):
return JsonResponse({
'status': 'error',
'msg': '手机号未绑定,不能登录',
'errors': {
"username": ['手机号未绑定,不能登录']
}
})
user = authenticate(username=username, password=password)
if not user:
return JsonResponse({
'status': 'error',
'msg': '登陆失败，用户名或密码错误',
'errors': {
"username": ['登陆失败，用户名或密码错误']
}
})
if not hasattr(user, 'userprofile'):
return JsonResponse({
'status': 'error',
'msg': '请使用新的企业邮箱重新注册聘宝企业端',
'errors': {
"username": [
'请使用新的企业邮箱重新注册聘宝企业端',
]
}
})
redirect_url = get_valid_next_url(next_url)
login(request, user)
self.clean_malice()
industrys = user.company_set.all().values_list(
'category__industry__code_name', flat=True)
user_industry = industrys[0] if len(industrys) > 0 else ''
if user_industry == 'medicine':
redirect_url = reverse('new_field_attent')
return JsonResponse({
'status': 'ok',
'msg': '登陆成功',
'username': user.username,
'redirect_url': redirect_url,
'user_industry': user_industry
})
def post(self, request):
feed = json.loads(request.body)
feed = self.api_post_data(feed)
result = ParseUtils.parse_related(feed)
return JsonResponse(result)
def post(self, request):
feed = json.loads(request.body)
result = ParseUtils.parse_num(feed)
return JsonResponse(result)
def post(self, request):
post_data = json.loads(request.body)
post_data = self.strip_post_data(post_data)
feed_id = post_data.get('feed_id', '')
self.user = request.user
feed = get_object_or_none(
Feed,
feed_obj_id=feed_id,
user=self.user,
)
if feed_id and not feed:
return JsonResponse({
'status': 'feed_error',
'msg': '定制数据有误',
})
form = self.get_form(feed)
self.form = form(post_data, post_data=post_data) if not feed else form(
post_data, post_data=post_data, instance=feed)
if not self.form.is_valid():
return JsonResponse({
'status': 'form_error',
'msg': self.form.get_first_errors(),
'errors': self.form.errors,
})
user = request.user
self.data = self.form.cleaned_data
self.company = get_object_or_none(Company, user=user)
if not feed:
if not self.has_rest_feed():
return JsonResponse({
'status': 'no_feed',
'msg': '没有剩余订制可用',
})
feed = self.create_feed()
self.send_feed_email(feed)
result = {
'status': 'ok',
'msg': '添加成功',
'show_mission': False,
'mission_time': None,
'username': user.username,
'redirect_url': '/feed',
'feed_id': feed.feed_obj_id,
}
else:
feed = self.update_feed()
result = {
'status': 'ok',
'msg': '保存成功',
'redirect_url': '/feed',
'feed_id': feed.feed_obj_id,
}
FeedParserUtils.save_feed_parser(
feed.feed_obj_id,
post_data.get('keywords', '').split(','),
post_data.get('block_keywords', '').split(','),
post_data.get('analyze_titles', '').split(','),
post_data.get('block_titles', '').split(','),
)
CeleryUtils.user_feed_task(feed.feed_obj_id)
return JsonResponse(result)
def get(self, request, feed_id=''):
'''
兼容接口请求和页面请求
'''
ajax_request = request.is_ajax()
user = request.user
feed_query = Feed.objects.prefetch_related(
'job_domain',
'company_prefer',
).filter(
feed_obj_id=feed_id,
user=user,
deleted=False,
)
feed_error = feed_id and not feed_query
if feed_error:
if not ajax_request:
return redirect('payment-my-account')
return JsonResponse({
'status': 'feed_error',
'msg': '请选择正确的定制',
})
no_rest_feed = not feed_query and not feed_id and not self.has_rest_feed(
)
if no_rest_feed:
if not ajax_request:
return redirect('payment-my-account')
return JsonResponse({
'status': 'no_rest_feed',
'msg': '没有剩余定制数，无法添加定制',
})
feed_dict = self.get_feed_dict(feed_query)
company_dict = self.get_company_dict()
expect_area = list(City.objects.all().values_list('name', flat=True))
company_prefer = list(CompanyCategoryPrefer.objects.all().order_by(
'-sort', ).values(
'id',
'name',
))
job_welfare = list(CompanyWelfare.objects.all().order_by(
'-sort', ).values_list(
'name',
flat=True,
))
data = {
'company': company_dict,
'feed': feed_dict,
'expect_area': expect_area,
'company_prefer': company_prefer,
'job_welfare': job_welfare,
}
if not ajax_request:
response = render(
request,
self.template_name,
{'data': json.dumps(data, ensure_ascii=False)},
)
else:
response = JsonResponse({
'status': 'ok',
'msg': 'ok',
'data': data
},
ensure_ascii=False)
return response
