def post(self, request):
field_id_list = request.POST.getlist('field_id_list[]', '')
fields = [
get_object_or_none(CompanyCategory, id=t, brick_display=True)
for t in field_id_list
]
if not fields or None in fields:
return JsonResponse({
'status': 'form_error',
'msg': '请选择正确的标签',
'data': {
'field_id_list': field_id_list,
},
})
resume = self.get_user_resume()
with transaction.atomic():
ResumePreferField.objects.filter(resume=resume).delete()
for f in fields:
resume_fields = ResumePreferField(
resume=resume,
category=f,
)
resume_fields.save()
return JsonResponse({
'status': 'ok',
'msg': 'ok',
'data': {
'prefer_fields': field_id_list,
},
})
def get(self, request, card_id):
user = request.user
card_job = get_object_or_none(
CompanyCardJob,
user=user,
id=card_id,
)
if card_job:
card_job.status = self.action
try:
JobUtils.card_feedback(card_job, self.action)
except CompanyCardInterestExeception:
logger.error(
'company card interst error',
exc_info=True,
extra={
'request': request,
}
)
return JsonResponse({
'status': 'exception',
'msg': '网络错误, 请稍后再试'
})
card_job.save()
NotifyUtils.card_job_notify(card_job, self.action)
return JsonResponse({
'status': 'ok',
'msg': self.msg,
})
def post(self, request):
category = request.POST.get('category')
position_category = get_object_or_none(
PositionCategory,
id=category,
)
if not position_category:
return JsonResponse({
'status': 'form_error',
'msg': '请选择正确的职位类别',
'data': {
'category': category,
}
})
resume = self.get_user_resume()
with transaction.atomic():
resume.job_category = position_category
resume.save()
resume.position_tags.filter(~Q(
position_tag__category=position_category)).delete()
return JsonResponse({
'status': 'ok',
'msg': 'ok',
'data': {
'category': category,
}
})
def post(self, request):
city_list = request.POST.getlist('city[]', [])
resume = self.get_user_resume()
city = [get_object_or_none(City, id=get_int(c)) for c in city_list]
if not city or None in city:
return JsonResponse({
'status': 'form_error',
'msg': '请选择正确的城市',
'data': {
'city': city_list,
}
})
with transaction.atomic():
ResumeTargetCity.objects.filter(resume=resume).delete()
for c in city:
target_city = ResumeTargetCity(
resume=resume,
city=c,
)
target_city.save()
return JsonResponse({
'status': 'ok',
'msg': 'ok',
'data': {
'city': city_list,
}
})
def post(self, request):
category = request.POST.get('category', '0')
position_category = get_object_or_none(
PositionCategory,
id=category,
)
if not position_category:
return JsonResponse({
'status': 'form_error',
'msg': '请选择正确的职位类别',
'data': {
'category': category,
}
})
category_tag = request.POST.getlist('tag[]', '')
tag = [
get_object_or_none(PositionCategoryTag,
id=t,
category=position_category)
for t in category_tag
]
tag = [t for t in tag if t]
if not tag:
return JsonResponse({
'status': 'form_error',
'msg': '请选择正确的标签',
'data': {
'category_tag': category_tag,
},
})
resume = self.get_user_resume()
with transaction.atomic():
resume.job_category = position_category
resume.save()
resume.position_tags.filter().delete()
code_name_list = []
for t in tag:
if t.name in code_name_list:
continue
resume_tag = ResumePositionTag(
resume=resume,
position_tag=t,
)
resume_tag.save()
code_name_list.append(t.name)
return JsonResponse({
'status': 'ok',
'msg': '修改成功',
})
def get(self, request, tag_id):
resume = self.get_user_resume()
resume.position_tags.filter(id=tag_id).delete()
return JsonResponse({
'status': 'ok',
'msg': '删除成功',
})
def post(self, request):
resume = self.get_user_resume()
update_obj = self.get_update_obj(resume)
if update_obj:
obj = update_obj[0]
form = self.form(request.POST, instance=obj)
else:
form = self.form(request.POST)
if form.is_valid():
save_obj = form.save(commit=False)
save_obj.resume = resume
save_obj.save()
asyn_sync_resume.delay(self.request.user)
result = {
'status': 'ok',
'msg': 'ok',
'data': {
'update_id': save_obj.id
}
}
else:
result = {
'status': 'form_error',
'msg': '表单错误',
'data': {
'errors': form.errors,
}
}
return JsonResponse(result)
def get(self, request):
category = request.GET.get('category', '0')
position_category = get_object_or_none(
PositionCategory,
id=category,
)
if not position_category:
return JsonResponse({
'status': 'form_error',
'msg': '请选择正确的职位类别',
'data': {
'category': category,
}
})
resume = self.get_user_resume()
resume_tag = resume.position_tags.filter().values('position_tag__id', )
category_tag_query = PositionCategoryTag.objects.filter(
category=position_category,
parent=None,
).prefetch_related('child_tags', )
category_tag = [{
'id':
c.id,
'name':
c.name,
'child': [{
'id': ct.id,
'name': ct.name,
} for ct in list(c.child_tags.all())],
} for c in list(category_tag_query)]
return JsonResponse({
'status': 'ok',
'msg': 'ok',
'data': {
'resume_tag': list(resume_tag),
'category_tag': list(category_tag),
'previous_tag': {
'id': position_category.id,
'name': position_category.name,
'level': 1,
},
}
})
def post(self, request):
gender = request.POST.get('gender')
if gender not in ('male', 'female'):
return JsonResponse({
'status': 'form_error',
'msg': '请选择正确的性别',
})
resume = self.get_user_resume()
resume.gender = gender
resume.save()
return JsonResponse({
'status': 'ok',
'msg': '选择成功',
'data': {
'gender': gender,
}
})
def get(self, request):
data = {}
return JsonResponse({
'status': 'ok',
'msg': 'ok',
'data': data,
})
def post(self, request, chat_id):
msg = self.request.POST.get('msg', '')
if not msg:
return JsonResponse({
'status': 'msg_error',
'msg': u'不能为空',
})
chat_id = self.kwargs['chat_id']
user = self.request.user
chat_query = Chat.objects.filter(
id=chat_id).filter(Q(hr=user) | Q(job_hunter=user))
if not chat_query:
return JsonResponse({
'status': 'data_error',
'msg': u'数据有误',
})
if self.malice_ip():
return JsonResponse({
'status': 'malice_ip',
'msg': '注册太频繁了，请稍后再试',
})
chat = chat_query[0]
if user == chat.hr:
receiver = chat.job_hunter
else:
receiver = chat.hr
chat_message = ChatMessage(
chat=chat,
sender=user,
receiver=receiver,
msg=msg,
)
chat_message.save()
return JsonResponse({
'status': 'ok',
'msg': u'发送成功',
'data': {
'send_time':
chat_message.send_time.strftime('%Y-%m-%d %H:%M:%S'),
'id': chat_message.id,
},
})
def get(self, request):
resume = self.get_user_resume()
job_category = resume.job_category
if not job_category:
return JsonResponse({
'status': 'data_error',
'msg': 'no job category',
})
category_tag_query = PositionCategoryTag.objects.filter(
category=job_category, ).values(
'name',
'id',
)
return JsonResponse({
'status': 'ok',
'msg': 'ok',
'data': list(category_tag_query),
})
def post(self, request):
resume = self.get_user_resume()
form = self.form(request.POST, instance=resume)
if form.is_valid():
form.save()
asyn_sync_resume.delay(self.request.user)
return JsonResponse({
'status': 'ok',
'msg': 'ok',
})
else:
return JsonResponse({
'status': 'form_error',
'msg': '表单错误',
'data': {
'errors': form.errors,
}
})
def get(self, request, job_id):
user = self.request.user
now = datetime.datetime.now()
recommend_job = get_object_or_none(
RecommendJob,
id=job_id,
user=user,
)
if not recommend_job:
return JsonResponse({
'status': 'data_error',
'msg': u'数据有误',
})
if self.action == 'send':
resume = ResumeUtils.get_resume(user)
if not SyncResume.is_valid_resume(resume):
return JsonResponse({
'status': 'valid_resume',
'msg': '简历不全',
'redirect_url': '%s?send=True' % reverse('resume-show-resume'),
'operation': self.action,
})
job = recommend_job.job
with transaction.atomic():
need_add_times = (recommend_job.read_status == 'unread')
recommend_job.read_status = 'read'
recommend_job.action = self.action
recommend_job.action_time = now
recommend_job.company_action_time = now
recommend_job.save()
self.extra_operation(job, recommend_job)
if need_add_times:
self.add_reco_times()
return JsonResponse({
'status': 'ok',
'msg': self.msg,
'operation': self.action,
})
def get(self, request):
resume = self.get_user_resume()
gender = resume.gender
return JsonResponse({
'status': 'ok',
'msg': 'ok',
'data': {
'gender': gender,
}
})
def get(self, request):
resume = self.get_user_resume()
salary_lowest = resume.salary_lowest
return JsonResponse({
'status': 'ok',
'msg': '成功',
'data': {
'salary_lowest': salary_lowest,
},
})
def post(self, request):
work_years = get_int(request.POST.get('work_years'))
if work_years not in self.work_year_meta:
return JsonResponse({
'status': 'form_error',
'msg': '请选择正确的工作年限',
'data': {
'work_years': work_years,
}
})
resume = self.get_user_resume()
resume.work_years = work_years
resume.save()
return JsonResponse({
'status': 'ok',
'msg': 'ok',
'data': {
'work_years': work_years,
}
})
def get(self, request):
resume = self.get_user_resume()
job_category = resume.job_category
if not job_category:
return JsonResponse({
'status': 'no_category',
'msg': '没有选择职位类别',
'data': {},
})
resume_tag = resume.position_tags.filter().values('position_tag__id', )
category_tag_query = PositionCategoryTag.objects.select_related(
'child_tags').filter(
category=job_category,
parent=None,
)
category_tag = [{
'id':
c.id,
'name':
c.name,
'child':
list(c.child_tags.all().values(
'id',
'name',
)),
} for c in category_tag_query]
return JsonResponse({
'status': 'ok',
'msg': 'ok',
'data': {
'resume_tag': list(resume_tag),
'category_tag': list(category_tag),
'previous_tag': {
'id': job_category.id,
'name': job_category.name,
'level': 1,
},
}
})
def get(self, request, card_id):
user = self.request.user
CompanyCardJob.objects.filter(
user=user,
id=card_id,
).update(
delete=self.action
)
return JsonResponse({
'status': 'ok',
'msg': self.msg,
})
def get(self, request):
resume = self.get_user_resume()
degree = resume.degree
return JsonResponse({
'status': 'ok',
'msg': 'ok',
'data': {
'degree': degree,
'degree_meta': self.degree_meta,
}
})
def post(self, request):
degree = request.POST.get('degree')
if degree not in self.degree_keys:
return JsonResponse({
'status': 'form_error',
'msg': '选择正确的学历',
'data': {
'degree': degree,
}
})
resume = self.get_user_resume()
resume.degree = degree
resume.save()
return JsonResponse({
'status': 'ok',
'msg': 'ok',
'data': {
'degree': degree,
}
})
def get(self, request):
resume = self.get_user_resume()
work_years = resume.work_years
return JsonResponse({
'status': 'ok',
'msg': 'ok',
'data': {
'work_years': work_years,
'work_year_meta': self.work_year_meta,
}
})
def post(self, request):
salary_lowest_str = request.POST.get('salary_lowest', '0')
salary_lowest = get_int(salary_lowest_str)
if salary_lowest > self.SALARY_MAX or salary_lowest < self.SALARY_MIN:
return JsonResponse({
'status':
'form_error',
'msg':
'最低薪资范围必须在%s-%s之间' % (self.SALARY_MIN, self.SALARY_MAX),
'data': {
'salary_lowest': salary_lowest
}
})
resume = self.get_user_resume()
resume.salary_lowest = salary_lowest
resume.save()
return JsonResponse({
'status': 'ok',
'msg': '保存成功',
})
def get(self, request, company_id):
company = get_object_or_none(
Company,
id=company_id,
)
if not company:
return JsonResponse({
'status': 'data_error',
'msg': '数据有误',
})
user = request.user
fav_record = UserFavourCompany.objects.filter(
company=company,
user=user,
)
if fav_record:
fav_record.delete()
company.favour_count -= 1
action = 'cancel'
else:
fav_record = UserFavourCompany(
company=company,
user=user,
)
fav_record.save()
company.favour_count += 1
action = 'favour'
company.save()
return JsonResponse({
'status': 'ok',
'msg': '操作成功',
'data': {
'action': action,
}
})
def get(self, request):
resume = self.get_user_resume()
expectation_area = resume.expectation_area.filter().values(
'city__id', )
city = City.objects.filter().values('id', 'name')
return JsonResponse({
'status': 'ok',
'msg': 'ok',
'data': {
'city': list(city),
'expectation_area': list(expectation_area),
}
})
def get(self, request, job_id):
user = request.user
with transaction.atomic():
RecommendJob.objects.filter(
user=user,
id=job_id,
company_action__in=['no_reply', 'unfit'],
).update(
delete=True,
)
return JsonResponse({
'status': 'ok',
'msg': '删除成功',
})
def get(self, request):
from ws4redis.publisher import RedisPublisher
from ws4redis.redis_store import RedisMessage
redis_publisher = RedisPublisher(
facility='notify',
users=('*****@*****.**', ),
)
message = RedisMessage('Hello World')
redis_publisher.publish_message(message)
return JsonResponse({
'status': 'ok',
})
def post(self, request, page_type):
form = SocialPageForm(request.POST)
if form.is_valid():
data = form.cleaned_data
url = data['url']
resume = self.get_user_resume()
social_page = self.get_social_page(resume)
social_page.__dict__[page_type] = url
social_page.save()
return JsonResponse({
'status': 'ok',
'msg': '保存成功',
})
else:
return JsonResponse({
'status': 'form_error',
'msg': '表单错误',
'data': {
'errors': form.errors,
}
})
def get(self, request, obj_id):
resume = self.get_user_resume()
self.model.objects.filter(
resume=resume,
id=obj_id,
).delete()
return JsonResponse({
'status': 'ok',
'msg': 'ok',
'data': {
'obj_id': obj_id,
},
})
def post(self, request):
tag_id = request.POST.get('tag_id', '0')
tag = get_object_or_none(
PositionCategoryTag,
id=tag_id,
)
if not tag:
return JsonResponse({
'status': 'form_error',
'msg': '请选择正确的标签',
})
resume = self.get_user_resume()
job_category = resume.job_category
if not job_category:
return JsonResponse({
'status': 'data_error',
'msg': 'no job category',
})
has_tag = resume.position_tags.filter(position_tag__name=tag.name)
if not has_tag:
resume_tag = ResumePositionTag(
resume=resume,
position_tag=tag,
)
resume_tag.save()
return JsonResponse({
'status':
'ok',
'msg':
'添加成功',
'data': [{
'name': t.position_tag.name,
'id': t.id,
} for t in resume.position_tags.all()],
})
