def check_wenda_link(request):
response = pub.BaseResponse()
token = request.GET.get("token")
user_objs = models.UserProfile.objects.filter(token=token,
token__isnull=False,
is_delete=False)
if user_objs:
if request.method == "GET":
objs = models.WendaLink.objects.filter(status=1)
if objs:
response.data = {'tid': objs.last().id, 'url': objs.last().url}
response.status = True
else:
response.status = False
response.message = "无任务"
else:
status = request.POST.get('status')
tid = request.POST.get('tid')
obj = models.WendaLink.objects.get(id=tid)
obj.status = status
obj.check_date = datetime.datetime.now()
obj.save()
response.status = True
response.message = "提交成功"
else:
response.status = False
response.message = "请求异常"
return JsonResponse(response.__dict__)
def according_geturl(request):
response = pub.BaseResponse()
url = request.GET.get('url')
# url = 'https://zhidao.baidu.com/question/1674396040757875467.html'
# objs = models.WendaRobotTask.objects.filter(wenda_url=url)
objs = models.RobotAccountLog.objects.filter(
wenda_robot_task__wenda_url=url)
if objs:
data_list = []
print('objs = = >', objs)
for obj in objs:
phone = obj.phone_num
status = obj.get_status_display()
# print('obj ----- > ',phone)
data_list.append({'phone': phone, 'statu': status})
# print('data_list = = >',data_list)
response.code = 200
response.status = True
response.data = data_list
response.message = '查询成功'
# return HttpResponse('查询成功')
else:
response.code = 200
response.status = False
response.data = ''
response.message = '链接不存在'
# return HttpResponse('链接不存在')
return JsonResponse(response.__dict__)
def check_ipaddr(request):
response = pub.BaseResponse()
if request.method == "GET":
token = request.GET.get("token")
user_objs = models.UserProfile.objects.filter(token=token,
token__isnull=False,
is_delete=False)
if user_objs:
ipaddr = request.GET.get("ipaddr")
up_hours_time = datetime.datetime.now() - datetime.timedelta(
days=1)
robot_account_log_obj = models.RobotAccountLog.objects.filter(
ipaddr=ipaddr, create_date__lt=up_hours_time)
if robot_account_log_obj:
response.status = False
response.message = "该ip不能使用"
else:
response.status = True
response.message = "该ip可以使用"
else:
response.status = False
response.message = "请求异常"
return JsonResponse(response.__dict__)
def login(request):
if request.method == "POST":
response = pub.BaseResponse()
form_obj = account.LoginForm(request.POST)
if form_obj.is_valid():
print(dict(request.session))
if request.POST.get("check_code").lower() != request.session['code_CheckCode'].lower(): # 判断输入的验证码是否正确
response.status = False
response.error['check_code'] = "验证码不正确"
else:
user_profile_objs = models.UserProfile.objects.filter(
username=form_obj.cleaned_data["username"],
password=form_obj.cleaned_data["password"],
is_delete=False
)
if user_profile_objs:
user_profile_obj = user_profile_objs[0]
if user_profile_obj.status == 1:
response.status = True
request.session['username'] = user_profile_obj.username
request.session['user_id'] = user_profile_obj.id
request.session['role_id'] = user_profile_obj.role.id
request.session['is_login'] = True
access_date = datetime.datetime.now()
user_profile_obj.last_login_date = access_date
user_profile_obj.save()
models.account_log.objects.create(
date=access_date,
ipaddress=pub.get_ip(request),
user_id=user_profile_obj.id
)
else:
response.status = False
response.error['check_code'] = "该用户状态异常, 请联系营销顾问"
else:
response.status = False
response.error['check_code'] = "账号或密码不正确"
else:
response.status = False
for i in ["check_code", "username", "password"]:
if i in form_obj.errors:
response.error[i] = json.loads(form_obj.errors.as_json())[i][0]["message"]
break
return JsonResponse(response.__dict__)
return render(request, 'login.html', locals())
def financial_center_oper(request, oper_type, o_id):
user_id = request.session["user_id"]
user_profile_obj = models.UserProfile.objects.get(id=user_id)
if request.method == "POST":
response = pub.BaseResponse()
tixian_moeny = request.POST["tixian_moeny"] # 提现金额
tixian_name = request.POST["tixian_name"] # 提现姓名
tixian_zhanghao = request.POST["tixian_zhanghao"] # 提现账户
if not tixian_moeny or not tixian_moeny.isdigit():
response.status = False
response.message = "提现金额有误"
elif user_profile_obj.balance == 0:
response.status = False
response.message = "无可提现金额"
elif int(tixian_moeny) > user_profile_obj.balance:
response.status = False
response.message = "提现金额已超出可提现金额"
if response.status and not tixian_name:
response.status = False
response.message = "支付宝姓名不能为空"
if response.status and not tixian_zhanghao:
response.status = False
response.message = "提现账户不能为空"
if response.status:
user_profile_obj.tixian_name = tixian_name
user_profile_obj.tixian_zhanghao = tixian_zhanghao
user_profile_obj.save()
models.TiXian.objects.create(
user_id=user_id,
money=tixian_moeny,
)
response.status = True
response.message = "提现申请已提交"
return JsonResponse(response.__dict__)
else:
if oper_type == "tixian":
tixian_objs = models.TiXian.objects.filter(user_id=user_id, status=1)
return render(request, 'wenda/financial_center/financial_center_modal_tixian.html', locals())
def tixian_management_oper(request, oper_type, o_id):
user_id = request.session["user_id"]
response = pub.BaseResponse()
if request.method == "POST":
# 确认打款
if oper_type == "dakuan_confirm":
remark = request.POST["remark"]
if not remark:
response.status = False
response.message = "打款信息不能为空"
else:
tixian_obj = models.TiXian.objects.select_related('user').get(id=o_id)
tixian_obj.remark = remark
tixian_obj.status = 2
tixian_obj.complete_date = datetime.datetime.now()
tixian_obj.save()
message = "提现金额 {moeny} 已成功支付,请注意查收".format(
moeny=tixian_obj.money,
)
AddMessage(request, tixian_obj.user.id, message)
# 记录消费明细
models.BalanceDetail.objects.create(
user=tixian_obj.user,
account_type=4,
money=tixian_obj.money,
oper_user_id=user_id,
remark=remark
)
user_profile_obj = models.UserProfile.objects.get(id=tixian_obj.user.id)
user_profile_obj.balance -= tixian_obj.money
user_profile_obj.save()
response.status = True
response.message = "提交成功"
return JsonResponse(response.__dict__)
else:
# 确认打款
if oper_type == "dakuan_confirm":
tixian_obj = models.TiXian.objects.get(id=o_id)
return render(request, 'myadmin/tixian_management/tixian_management_modal_dakuan_confirm.html', locals())
def rank_data_oper(request, oper_type, o_id):
user_id = request.session["user_id"]
response = pub.BaseResponse()
if request.method == "POST":
if oper_type == "download":
user_id = request.POST.get("user_id")
if not user_id:
response.status = False
response.message = "请选择导出用户名称"
else:
file_name = os.path.join(
"statics", "upload_files",
str(int(time.time() * 1000)) + ".xlsx")
search_objs = models.SearchKeywordsRank.objects.select_related(
'client_user').filter(client_user_id=user_id)
data_list = []
for obj in search_objs:
for i in obj.searchkeywordsranklog_set.select_related(
'keywords').exclude(task_type=2):
data_list.append({
"username": obj.client_user.username,
"create_date": i.create_date,
"task_type": i.get_task_type_display(),
"keywords": i.keywords.keywords,
"rank": i.rank,
"type": i.keywords.get_type_display()
})
tasks.rank_data_generate_excel.delay(file_name, data_list)
response.status = True
response.message = "导出成功"
response.download_url = "/" + file_name
return JsonResponse(response.__dict__)
else:
if oper_type == "download":
wenda_type_choices = models.WendaRobotTask.wenda_type_choices
wendaClientUserObjs = models.UserProfile.objects.filter(
is_delete=False, status=1, role_id=5).values('id', 'username')
return render(request,
"wenda/rank_data/rank_data_modal_download.html",
locals())
def account_oper(request, oper_type, o_id):
response = pub.BaseResponse()
if request.method == "POST":
pass
else:
# 将消息改为已读
if oper_type == "select":
message_obj = models.Message.objects.get(id=o_id)
message_obj.status = 2
message_obj.save()
response.status = True
response.data = ShowMessageCount(request)
return JsonResponse(response.__dict__)
def img_upLoad(request):
response = pub.BaseResponse()
imgBase = request.POST.get('imgBase')
imgFormat = request.POST.get('imgFormat')
lookIndex = request.POST.get('lookIndex')
imgdata = base64.b64decode(imgBase.split(',')[1])
img_name = str(int(time.time() * 1000000)) + '.' + imgFormat
img_abs_name = os.path.join("statics/upload_images", img_name)
with open(img_abs_name, "wb") as f:
f.write(imgdata)
response.status = True
response.ind = lookIndex
response.img_url = '/' + img_abs_name
return JsonResponse(response.__dict__)
def message_oper(request, oper_type, o_id):
user_id = request.session["user_id"]
response = pub.BaseResponse()
if request.method == "POST":
# 设置消息为已读状态
if oper_type == "read":
response.status = True
response.message = "修改成功"
models.Message.objects.filter(id=o_id).update(
status=2,
update_at=datetime.now()
)
# 批量设置消息为已读状态
if oper_type == "batch_read":
response.status = True
response.message = "修改成功"
batch_read_ids = request.POST.get('batch_read_ids')
if len(batch_read_ids.split(',')):
print(batch_read_ids.split(','))
batch_read_ids = [int(i) for i in batch_read_ids.split(',')]
models.Message.objects.filter(id__in=batch_read_ids).update(
status=2,
update_at=datetime.now()
)
else:
response.status = False
response.message = "未勾选需要修改状态的消息"
return JsonResponse(response.__dict__)
else:
# 设置消息为已读
if oper_type == "read":
return render(request, 'wenda/message/message_modal_update.html', locals())
elif oper_type == "batch_read":
batch_read_ids = request.GET.get('batch_read_ids')
print(batch_read_ids)
return render(request, 'wenda/message/message_modal_batch_read.html', locals())
def update_password(request):
user_id = request.session['user_id']
response = pub.BaseResponse()
if request.method == "POST":
oldPwd = request.POST.get('oldPwd')
newPwd = request.POST.get('newPwd')
old_password = pub.str_encrypt(oldPwd)
user_profile_objs = models.UserProfile.objects.filter(id=user_id, password=old_password, is_delete=False)
if user_profile_objs:
user_profile_obj = user_profile_objs[0]
user_profile_obj.password = pub.str_encrypt(newPwd)
user_profile_obj.save()
response.status = True
response.message = "修改成功"
else:
response.status = False
response.message = "旧密码不正确"
return JsonResponse(response.__dict__)
def global_settings(request):
if request.method == "POST":
response = pub.BaseResponse()
if request.GET["oper_type"] == "update":
form_obj = GlobalSettingsForm(request.POST)
if form_obj.is_valid():
response.status = True
response.message = "保存成功"
models.GlobalSettings.objects.update(**form_obj.cleaned_data)
else:
response.status = False
for i in [
"new_wenda_money", "old_wenda_money",
"xie_wenda_money", "fa_wenda_money"
]:
if i in form_obj.errors:
response.message = form_obj.errors[i]
break
return JsonResponse(response.__dict__)
else:
global_settings_obj = models.GlobalSettings.objects.all()[0]
obj = models.GlobalSettings.objects.values(
'fugaibaobiao_shengcheng_moshi', 'bianji_shifou_dianji_add_map')
obj_status = obj[0]['fugaibaobiao_shengcheng_moshi']
print('obj - -- >', obj[0])
bianji_shifou_dianji_add_map = obj[0]['bianji_shifou_dianji_add_map']
if "_pjax" in request.GET:
return render(request,
'myadmin/global_settings/global_settings_pjax.html',
locals())
return render(request, 'myadmin/global_settings/global_settings.html',
locals())
def case_library_oper(request, oper_type, o_id):
user_id = request.session["user_id"]
role_id = request.session.get("role_id")
response = pub.BaseResponse()
if request.method == "GET":
# 保存答案
if oper_type == "save_content":
content = request.GET.get("content").strip()
obj = models.ZhidaoWenda.objects.get(id=o_id)
wenda_robot_task_obj = models.WendaRobotTask.objects.create(
title=obj.title,
content=content,
wenda_url=obj.url,
release_platform=1,
wenda_type=1,
status=2,
next_date=datetime.datetime.now(),
)
obj.content = content
obj.update_date = datetime.datetime.now()
obj.status = 2
obj.run_task = wenda_robot_task_obj
obj.oper_user = models.UserProfile.objects.get(id=user_id)
obj.save()
response.status = True
response.message = "保存成功"
# 删除问答
elif oper_type == "delete":
models.ZhidaoWenda.objects.filter(id=o_id).delete()
print(o_id)
response.status = True
response.message = "删除成功"
return JsonResponse(response.__dict__)
def hospital_information_oper(request, oper_type, o_id):
user_id = request.session["user_id"]
response = pub.BaseResponse()
if request.method == "POST":
# 添加
if oper_type == "update":
response.status = True
response.message = "保存成功"
form_obj = HospitalInformationForm(
data={
"name": request.POST.get("name"),
"department_id": request.POST.get("department_id"),
"web_site": request.POST.get("web_site"),
"content_direction": request.POST.getlist("content_direction"),
"reply_role": request.POST.getlist("reply_role"),
"content_direction_custom": request.POST.get("content_direction_custom"),
}
)
if form_obj.is_valid():
print(form_obj.cleaned_data)
hospital_information_objs = models.HospitalInformation.objects.filter(user_id=user_id)
if not hospital_information_objs:
models.HospitalInformation.objects.create(user_id=user_id, **form_obj.cleaned_data)
else:
hospital_information_objs.update(**form_obj.cleaned_data)
else:
response.status = False
for i in ["name", "department_id", "web_site", "content_direction", "reply_role"]:
if i in form_obj.errors:
response.message = form_obj.errors[i]
response.key = i
break
return JsonResponse(response.__dict__)
def edit_content_management_oper(request, oper_type, o_id):
user_id = request.session["user_id"]
response = pub.BaseResponse()
status_choices = models.EditContentManagement.status_choices
if request.method == "POST":
# 任务分配
if oper_type == "task_allotment":
print(request.POST)
task_obj = models.EditContentManagement.objects.get(id=o_id)
panduan_map = request.POST.get('panduan_map')
if panduan_map:
# obj = models.EditContentManagement.objects.filter(id=o_id)
# obj[0].task.add_map = True
# obj[0].save()
obj = models.Task.objects.get(id=task_obj.task_id)
obj.add_map = True
obj.save()
flag = True
task_allotment_data = {}
total = 0
for i in dict(request.POST):
if i.startswith("bianji"):
pub_num = request.POST.get(i)
if (pub_num.isdigit() and int(pub_num) >= 0
) or not pub_num: # 如果是整数类型并且大于等于0 或者为空
if pub_num:
total += int(pub_num)
else:
flag = False
task_allotment_data[int(i.replace(
"bianji_", ""))] = request.POST.get(i)
if not flag or total != task_obj.number:
response.status = False
response.message = "分配任务有误"
else:
user_id_str = ""
for edit_user_id, number in task_allotment_data.items():
if int(number) == 0:
continue
print(task_allotment_data, task_allotment_data.values())
models.EditTaskManagement.objects.create(
task=task_obj,
edit_user_id=edit_user_id,
number=number,
status=1,
)
# 将需要接收微信通知的用户的微信号统计出来
user_obj = models.UserProfile.objects.get(id=edit_user_id)
weixin_id = user_obj.weixin_id
if not weixin_id: # 如果没有填写微信id 则告知 zhangcong
# 发送微信通知
now_datetime = datetime.datetime.now().strftime(
"%Y-%m-%d %H:%M:%S")
text = "通知时间: {now_datetime} \n通知平台:诸葛问答\n用户 {username} 未设置微信id".format(
now_datetime=now_datetime,
username=user_obj.username)
tasks.send_msg.delay("zhangcong", text)
continue
if user_id_str:
user_id_str = user_id_str + "|" + weixin_id
else:
user_id_str = weixin_id
# 发送微信通知
now_datetime = datetime.datetime.now().strftime(
"%Y-%m-%d %H:%M:%S")
text = "通知时间: {now_datetime} \n您有新的口碑任务等待编写,请前往口碑后台 - 我的任务-编辑 功能中查看"
tasks.send_msg.delay(user_id_str, text)
task_obj.status = 2
task_obj.save()
response.status = True
response.message = "分配成功"
# 进入发布队列
elif oper_type == "robot_pub":
edit_content_management_obj = models.EditContentManagement.objects.get(
id=o_id)
task_obj = models.Task.objects.get(
id=edit_content_management_obj.task.id)
file_name = task_obj.name + '.' + "xls"
file_save_path = "/".join(
["statics", "task_excel", "result", file_name])
tasks.edit_content_management_create_excel.delay(
o_id, os.path.join(os.getcwd(), file_save_path),
task_obj.wenda_type)
# 编辑提交任务结果
models.TaskProcessLog.objects.create(task=task_obj,
status=3,
oper_user_id=user_id)
if task_obj.wenda_type == 2: # 老问答
task_obj.status = 6
task_obj.publish_user_id = 8
message1 = "您的任务 {task_name} 已经被平台派单员 [{paidan_name}] 指定编辑进行完成".format(
task_name=task_obj.name,
paidan_name=models.UserProfile.objects.get(
id=user_id).username,
bianji_name="小明")
message2 = "平台派单员 [{paidan_name}] 分配给您新的任务 [{task_name}] , 请注意查看".format(
paidan_name=models.UserProfile.objects.get(
id=user_id).username,
task_name=task_obj.name,
)
AddMessage(request, task_obj.release_user.id, message1)
AddMessage(request, 8, message2)
# 分配任务日志
models.TaskProcessLog.objects.create(task=task_obj,
status=2,
oper_user_id=user_id,
remark="任务分配给: %s" % "小明")
response.message = "开始发布!"
else:
task_obj.status = 3
message = "您的任务 [{task_name}] 编辑已经提交结果,请前去查看,并审核".format(
task_name=task_obj.name, )
AddMessage(request, task_obj.release_user.id, message)
response.message = "进入发布队列成功!"
task_obj.task_result_file_path = file_save_path
task_obj.update_date = datetime.datetime.now()
task_obj.save()
edit_content_management_obj.status = 4
edit_content_management_obj.save()
response.status = True
# 任务说明
elif oper_type == 'task_shuoming':
renwushuoming = request.POST.get('renwushuoming')
print('renwushuoming -0 -- - -> ', renwushuoming)
response.status = True
response.message = '修改成功'
obj = models.EditContentManagement.objects.filter(id=o_id).update(
remark=renwushuoming)
return JsonResponse(response.__dict__)
else:
roles_dict = models.Role.objects.all().values("id", "name")
# 任务分配
if oper_type == "task_allotment":
user_objs = models.UserProfile.objects.filter(is_delete=False,
role_id=13).values(
'id', 'username')
task_obj = models.EditContentManagement.objects.get(id=o_id)
map_status = task_obj.task.add_map
return render(
request,
'wenda/edit_content_management/edit_content_management_modal_task_allotment.html',
locals())
# 任务分配详情
elif oper_type == "task_allotment_detail":
detail_objs = models.EditTaskManagement.objects.select_related(
'edit_user').filter(task_id=o_id)
return render(
request,
'wenda/edit_content_management/edit_content_management_modal_task_allotment_detail.html',
locals())
# 机器人发布
elif oper_type == "robot_pub":
detail_objs = models.EditContentManagement.objects.get(id=o_id)
return render(
request,
'wenda/edit_content_management/edit_content_management_modal_robot_pub.html',
locals())
# 查看编辑编写的问题和答案的详细情况
elif oper_type == "task_edit_detail":
objs = models.EditPublickTaskManagement.objects.select_related(
'task__edit_user').filter(task__task_id=o_id)
return render(
request,
'wenda/edit_content_management/edit_content_management_modal_task_edit_detail.html',
locals())
# 任务说明
elif oper_type == 'task_shuoming':
print('o_ido_id -- > ', o_id)
shuoming_obj = models.EditContentManagement.objects.select_related(
'task').filter(id=o_id)
obj_remark = shuoming_obj[0].remark
return render(
request,
'wenda/edit_content_management/edit_content_management_modal_renwushuoming.html',
locals())
def set_keywords_oper(request, oper_type, o_id):
user_id = request.session["user_id"]
response = pub.BaseResponse()
if request.method == "POST":
# 添加
if oper_type == "create":
keywords = request.POST.get("keywords")
keywords__client_user_id = request.POST.get(
"keywords__client_user_id")
if not keywords:
response.status = False
response.message = "关键词不能为空"
if not keywords__client_user_id:
response.status = False
response.message = "请选择客户名称"
if response.status:
keywords_list = keywords.strip().split()
query = []
for keyword in keywords_list:
keyword = keyword.strip()
obj = models.SearchKeywordsRank.objects.filter(
client_user_id=keywords__client_user_id,
keywords=keyword,
is_delete=False)
if not obj:
models.SearchKeywordsRank.objects.create(
client_user_id=keywords__client_user_id,
type=1,
oper_user_id=user_id,
keywords=keyword)
response.status = True
response.message = "添加成功"
# 修改
elif oper_type == "update":
response.status = True
response.message = "修改成功"
print(request.POST.get("id"))
shouyi_role_ids = [8, 9, 6]
uid = request.POST.get("id")
role_id = models.UserProfile.objects.select_related('role').get(
id=uid).role.id
post_data = {}
for k, v in dict(request.POST).items():
post_data[k] = v[0]
print(post_data)
if role_id not in shouyi_role_ids:
post_data["xie_wenda_money"] = ''
post_data["fa_wenda_money"] = ''
form_obj = user.UserProfileUpdateForm(post_data)
if form_obj.is_valid():
if not form_obj.cleaned_data["password"]:
del form_obj.cleaned_data["password"]
print(form_obj.cleaned_data)
models.UserProfile.objects.filter(
id=request.POST.get("id")).update(**form_obj.cleaned_data)
else:
response.status = False
print(form_obj.errors)
for i in [
"username", "password", "role_id", "xie_wenda_money",
"fa_wenda_money"
]:
if i in form_obj.errors:
response.message = form_obj.errors[i]
break
# 删除用户
elif oper_type == "delete":
user_profile_obj = models.UserProfile.objects.get(id=o_id)
user_profile_obj.is_delete = True
user_profile_obj.save()
response.status = True
response.message = "删除成功"
return JsonResponse(response.__dict__)
else:
roles_dict = models.Role.objects.all().values("id", "name")
# 添加
if oper_type == "create":
return render(request,
'wenda/set_keywords/set_keywords_modal_create.html',
locals())
# 修改
elif oper_type == "update":
user_profile_obj = models.UserProfile.objects.select_related(
"role").get(id=o_id)
guwen_objs = models.UserProfile.objects.filter(role_id=7,
is_delete=False)
xiaoshou_objs = models.UserProfile.objects.filter(role_id=12,
is_delete=False)
# 问答编辑、问答渠道、兼职发帖角色的id
print(user_profile_obj.role.id)
shouyi_role_ids = [8, 9, 6]
return render(
request,
'myadmin/user_management/user_management_modal_update.html',
locals())
# 删除
elif oper_type == "delete":
user_profile_obj = models.UserProfile.objects.get(id=o_id)
return render(request,
'wenda/set_keywords/set_keywords_modal_delete.html',
locals())
def wait_clearing_oper(request, oper_type, o_id):
user_id = request.session["user_id"]
response = pub.BaseResponse()
if request.method == "POST":
# 结算
if oper_type == "clearing":
publish_ok_num = request.POST["publish_ok_num"]
if publish_ok_num.isdigit() and int(publish_ok_num) > 0:
publish_ok_num = int(publish_ok_num)
task_obj = models.Task.objects.get(id=o_id)
global_settings_obj = models.GlobalSettings.objects.all()[0]
receive_user_username = task_obj.receive_user.username # 写问答的人
publish_user_username = task_obj.publish_user.username # 发问答的人
# 给写问答的人结算
if task_obj.receive_user.xie_wenda_money:
money = task_obj.receive_user.xie_wenda_money * publish_ok_num
else:
money = global_settings_obj.xie_wenda_money * publish_ok_num
user_profile_obj = models.UserProfile.objects.get(
id=task_obj.receive_user.id)
user_profile_obj.balance += money
user_profile_obj.save()
models.BalanceDetail.objects.create(
user_id=task_obj.receive_user.id,
account_type=3,
money=money,
oper_user_id=user_id,
remark="编写问答收益")
message = "编写问答任务 [{task_name}] 已经结算成功, 请注意查看".format(
task_name=task_obj.name, )
AddMessage(request, task_obj.receive_user.id, message)
# 给写问答的人结算
if task_obj.publish_user.xie_wenda_money:
money = task_obj.publish_user.xie_wenda_money * publish_ok_num
else:
money = global_settings_obj.fa_wenda_money * publish_ok_num
user_profile_obj = models.UserProfile.objects.get(
id=task_obj.publish_user.id)
user_profile_obj.balance += money
user_profile_obj.save()
models.BalanceDetail.objects.create(
user_id=task_obj.publish_user.id,
account_type=3,
money=money,
oper_user_id=user_id,
remark="发布问答收益")
message = "发布问答任务 [{task_name}] 已经结算成功, 请注意查看".format(
task_name=task_obj.name, )
AddMessage(request, task_obj.publish_user.id, message)
task_obj.clearing = 2
task_obj.publish_ok_num = publish_ok_num
task_obj.save()
response.status = True
response.message = "结算成功"
else:
response.status = False
response.message = "成功数量有误"
return JsonResponse(response.__dict__)
else:
# 结算
if oper_type == "clearing":
task_obj = models.Task.objects.get(id=o_id)
return render(
request,
'wenda/wait_clearing/wait_clearing_modal_clearing.html',
locals())
# 在线预览任务需求
elif oper_type == "online_preview_task_demand":
task_obj = models.Task.objects.get(id=o_id)
file_name_path = os.path.join(os.getcwd(),
task_obj.task_demand_file_path)
print(file_name_path)
book = xlrd.open_workbook(file_name_path)
sh = book.sheet_by_index(0)
table_data = []
for row in range(2, sh.nrows):
line_data = []
for col in range(sh.ncols):
value = sh.cell_value(rowx=row, colx=col)
line_data.append(value)
table_data.append(line_data)
print(table_data)
return render(request,
"wenda/my_task/my_task_modal_online_preview.html",
locals())
# 在线预览任务结果
elif oper_type == "online_preview_task_result":
task_obj = models.Task.objects.get(id=o_id)
file_name_path = os.path.join(os.getcwd(),
task_obj.task_result_file_path)
print(file_name_path)
book = xlrd.open_workbook(file_name_path)
sh = book.sheet_by_index(0)
table_data = []
for row in range(2, sh.nrows):
line_data = []
for col in range(sh.ncols):
value = sh.cell_value(rowx=row, colx=col)
line_data.append(value)
table_data.append(line_data)
print(table_data)
return render(request,
"wenda/my_task/my_task_modal_online_preview.html",
locals())
# 在线预览任务结果
elif oper_type == "online_preview_publish_task_result":
task_obj = models.Task.objects.get(id=o_id)
file_name_path = os.path.join(
os.getcwd(), task_obj.publish_task_result_file_path)
print(file_name_path)
book = xlrd.open_workbook(file_name_path)
sh = book.sheet_by_index(0)
table_data = []
for row in range(2, sh.nrows):
line_data = []
for col in range(sh.ncols):
value = sh.cell_value(rowx=row, colx=col)
if (task_obj.wenda_type == 1
and col == 2) or (task_obj.wenda_type == 2
and col == 1): # 新问答
value = "<a href='{value}'>查看链接</a>".format(
value=value)
line_data.append(value)
table_data.append(line_data)
print(table_data)
return render(request,
"wenda/my_task/my_task_modal_online_preview.html",
locals())
def get_wenda_task(request):
response = pub.BaseResponse()
if request.method == "POST":
print(request.POST)
token = request.POST.get("token")
user_objs = models.UserProfile.objects.filter(token=token,
token__isnull=False,
is_delete=False)
if user_objs:
task_id = request.POST.get("task_id")
status = request.POST.get("status")
current_url = request.POST.get("current_url")
cookies = request.POST.get("cookies")
phone = request.POST.get("phone")
ipaddr = request.POST.get("ipaddr")
if current_url == "http://zhidao.baidu.com/new?word=&ie=GBK":
response.status = False
response.message = "任务发布异常"
if response.status:
wenda_robot_task_objs = models.WendaRobotTask.objects.filter(
id=task_id)
if wenda_robot_task_objs:
wenda_robot_task_obj = wenda_robot_task_objs[0]
if status == "1": # 新发布问答
wenda_robot_task_obj.status = 2
wenda_robot_task_obj.wenda_url = current_url
elif status == "2": # 回复问答
wenda_robot_task_obj.status = 5
elif status == "20": # 回复异常
wenda_robot_task_obj.status = 20
elif status == "22": # 回复异常
wenda_robot_task_obj.status = 22
elif status == "30": # 标题过长
wenda_robot_task_obj.status = 30
elif status == "40": # 链接失效
wenda_robot_task_obj.status = 40
else: # status == 3 # 采纳问答
wenda_robot_task_obj.status = 6
wenda_robot_task_obj.update_date = datetime.datetime.now()
wenda_robot_task_obj.save()
models.RobotAccountLog.objects.create(
wenda_robot_task=wenda_robot_task_obj,
status=int(status),
phone_num=phone,
login_cookie=cookies,
ipaddr=ipaddr,
)
response.status = True
response.message = "提交成功"
else:
response.status = False
response.message = "任务异常"
else:
response.status = False
response.message = "token值错误"
else:
print(request.GET, request.POST)
token = request.GET.get("token")
status = request.GET.get("status")
task_id = request.GET.get("task_id")
user_objs = models.UserProfile.objects.filter(token=token,
token__isnull=False,
is_delete=False)
if user_objs:
# 只能获取10分钟内未操作的任务
up_hours_time = datetime.datetime.now() - datetime.timedelta(
minutes=10)
if task_id and status == "5": # 查询是否到采纳时间
# 先查询任务状态是否正常
wenda_robot_task_obj = models.WendaRobotTask.objects.get(
id=task_id)
if wenda_robot_task_obj.status not in [2, 5]:
response.status = True
response.error = "任务状态异常,请开始下一个任务"
return JsonResponse(response.__dict__)
else:
if wenda_robot_task_obj.update_date < up_hours_time:
if wenda_robot_task_obj.status == 2: # 如果状态不为 2, 5 等待回复和等待采纳, 则有异常
wenda_robot_task_obj = None
elif wenda_robot_task_obj.status == 5:
pass
else: # 如果时间没有到,则设置任务为空
wenda_robot_task_obj = None
else:
wenda_robot_task_obj = None
# 获取未完成的任务
wenda_robot_task_objs = models.WendaRobotTask.objects.filter(
status=status, update_date__isnull=True)
# wenda_robot_task_obj = models.WendaRobotTask.objects.filter(status=2)
if not wenda_robot_task_objs:
wenda_robot_task_objs = models.WendaRobotTask.objects.filter(
status=status, update_date__lt=up_hours_time)
print('-' * 10, wenda_robot_task_objs)
# 判断是否有任务
if wenda_robot_task_objs:
wenda_robot_task_obj = wenda_robot_task_objs[0]
print(wenda_robot_task_obj)
if wenda_robot_task_obj:
response.status = True
release_platform = [
i[0] for i in wenda_robot_task_obj.release_platform_choices
if i[0] == wenda_robot_task_obj.release_platform
][0]
response.data = {
"task_id": wenda_robot_task_obj.id,
"release_platform": release_platform,
"status": wenda_robot_task_obj.status,
}
if wenda_robot_task_obj.status == 1: # 发布新问答
response.data["title"] = wenda_robot_task_obj.title
elif wenda_robot_task_obj.status == 2: # 回复问答
response.data["url"] = wenda_robot_task_obj.wenda_url
response.data["content"] = wenda_robot_task_obj.content
elif wenda_robot_task_obj.status == 5: # 采纳
response.data["url"] = wenda_robot_task_obj.wenda_url
response.data["content"] = wenda_robot_task_obj.content
else:
response.status = False
response.data = None
response.message = "操作异常"
return JsonResponse(response.__dict__)
wenda_robot_task_obj.update_date = datetime.datetime.now()
wenda_robot_task_obj.save()
else:
response.message = "task is null!"
else:
response.status = False
response.message = "token值错误"
return JsonResponse(response.__dict__)
def my_task_edit_oper(request, oper_type, o_id):
user_id = request.session["user_id"]
role_id = request.session["role_id"]
response = pub.BaseResponse()
status_choices = models.EditContentManagement.status_choices
if request.method == "POST":
# 添加
if oper_type == "create":
client_user_id = request.POST.get('client_user_id')
remark = request.POST.get('remark')
number = request.POST.get('number')
file = request.FILES.get('file') # 所有提交的文件
form_data = {
"client_user_id": client_user_id,
"remark": remark,
"number": number,
"file": file,
}
form_obj = edit_content.EditContentForm(form_data)
if form_obj.is_valid():
file_name = ".".join(
[str(int(time.time() * 1000)),
file.name.split(".")[1]])
file_abs_name = os.path.join("statics", "upload_files",
file_name)
with open(file_abs_name, "wb") as f:
for chunk in file.chunks():
f.write(chunk)
models.EditContentManagement.objects.create(
client_user_id=form_obj.cleaned_data["client_user_id"],
create_user_id=user_id,
status=1,
reference_file_path="/" + file_abs_name,
number=form_obj.cleaned_data["number"],
remark=form_obj.cleaned_data["remark"])
response.status = True
response.message = "添加成功"
else:
response.status = False
for i in ["client_user_id", "number", "file", "remark"]:
if i in form_obj.errors:
response.message = form_obj.errors[i]
break
# 修改
elif oper_type == "update":
response.status = True
response.message = "修改成功"
print(request.POST.get("id"))
shouyi_role_ids = [8, 9, 6]
uid = request.POST.get("id")
role_id = models.UserProfile.objects.select_related('role').get(
id=uid).role.id
post_data = {}
for k, v in dict(request.POST).items():
post_data[k] = v[0]
print(post_data)
form_obj = user.UserProfileUpdateForm(post_data)
if form_obj.is_valid():
if not form_obj.cleaned_data["password"]:
del form_obj.cleaned_data["password"]
print(form_obj.cleaned_data)
models.UserProfile.objects.filter(
id=request.POST.get("id")).update(**form_obj.cleaned_data)
else:
response.status = False
print(form_obj.errors)
for i in [
"username", "password", "role_id", "xie_wenda_money",
"fa_wenda_money"
]:
if i in form_obj.errors:
response.message = form_obj.errors[i]
break
# 删除用户
elif oper_type == "delete":
user_profile_obj = models.UserProfile.objects.get(id=o_id)
user_profile_obj.is_delete = True
user_profile_obj.save()
response.status = True
response.message = "删除成功"
elif oper_type == "task_allotment":
print(request.POST)
task_obj = models.EditContentManagement.objects.get(id=o_id)
flag = True
task_allotment_data = {}
total = 0
for i in dict(request.POST):
if i.startswith("bianji"):
pub_num = request.POST.get(i)
if (pub_num.isdigit() and int(pub_num) >= 0
) or not pub_num: # 如果是整数类型并且大于等于0 或者为空
if pub_num:
total += int(pub_num)
else:
flag = False
task_allotment_data[int(i.replace(
"bianji_", ""))] = request.POST.get(i)
if not flag or total != task_obj.number:
response.status = False
response.message = "分配任务有误"
else:
for edit_user_id, number in task_allotment_data.items():
print(task_allotment_data, task_allotment_data.values())
models.EditTaskManagement.objects.create(
task=task_obj,
edit_user_id=edit_user_id,
number=number,
status=1,
)
task_obj.status = 2
task_obj.save()
response.status = True
response.message = "分配成功"
# 编辑上传任务
elif oper_type == "upload":
edit_task_management_obj = models.EditTaskManagement.objects.get(
id=o_id)
form_data = request.POST.get("form_data")
print("form_data -->", form_data)
print("json.loads(form_data) -->", json.loads(form_data))
form_data_obj = json.loads(
parse.unquote(form_data).replace("%u", "\\u"))
print("form_data_obj ->", form_data_obj)
content_str = form_data_obj["content"]
title_str = form_data_obj["title"]
print("content_str -->", content_str)
print("title_str -->", title_str)
if not title_str:
response.status = False
response.message = "提交问答问题不能为空"
if response.status and content_str:
# content_list = [i.strip() for i in content_str.strip().split("\n")]
# title_list = [i.strip() for i in title_str.strip().split("\n")]
content_list = [
i.strip() for i in content_str.strip().split("\n")
]
print("content_list -->", len(content_list), content_list)
title_list = [i.strip() for i in title_str.strip().split("\n")]
# 问题敏感词列表
SensitiveWordTitle_list = [
i[0] for i in models.SensitiveWordLibrary.objects.filter(
w_type=1).values_list('name')
]
# 答案敏感词列表
SensitiveWordContent_list = [
i[0] for i in models.SensitiveWordLibrary.objects.filter(
w_type=2).values_list('name')
]
content_list_str = " ".join(content_list)
title_list_str = " ".join(title_list)
title_err_name_list = [] # 问题中包含的敏感词列表
content_err_name_list = [] # 答案中包含的敏感词列表
for name in SensitiveWordTitle_list:
if name in title_list_str:
title_err_name_list.append(name)
for name in SensitiveWordContent_list:
if name in content_list_str:
content_err_name_list.append(name)
if title_err_name_list or content_err_name_list:
response.status = False
response.data = {
"title_err_name_list": title_err_name_list,
"content_err_name_list": content_err_name_list
}
response.message = "问题或答案中包含敏感词,已标红"
if response.status and len(
set(content_list)) != len(content_list):
response.status = False
response.message = "提交问答答案有重复"
if response.status and len(set(title_list)) != len(title_list):
response.status = False
response.message = "提交问答问题有重复"
print(len(title_list), len(content_list))
if response.status and len(title_list) != len(content_list):
response.status = False
response.message = "提交问答问题与提交问答问题数量不符"
if response.status:
query = []
flag = True
line_repetition = 0
for index in range(len(content_list)):
line_repetition += 1
content = content_list[index]
title = title_list[index]
# 判断所有的子任务中是否已经存在该内容
for i_obj in models.EditTaskManagement.objects.filter(
task_id=edit_task_management_obj.task.id):
# 在子任务的详情表中进行查找
obj = models.EditPublickTaskManagement.objects.filter(
content=content, title=title, task_id=i_obj.id)
if obj.count() > 0:
flag = False
break
if not flag:
break
else:
query.append(
models.EditPublickTaskManagement(
task_id=edit_task_management_obj.id,
content=content,
title=title,
status=1,
))
print("query -->", len(query))
if not flag:
response.status = False
response.message = "第 {line_num} 行已经存在".format(
line_num=line_repetition)
elif flag and len(
query) != edit_task_management_obj.number:
response.status = False
response.message = "提交数量与任务数量不符"
else:
models.EditPublickTaskManagement.objects.bulk_create(
query)
edit_task_management_obj.status = 2
edit_task_management_obj.complete_date = datetime.datetime.now(
)
edit_task_management_obj.save()
# 统计父任务下的子任务是否全部完成
edit_content_management_obj = models.EditContentManagement.objects.select_related(
'create_user').get(
id=edit_task_management_obj.task.id)
# 该条件如果成立,表示父任务下的所有子任务都已经完成
if edit_content_management_obj.edittaskmanagement_set.filter(
status=1).count() == 0:
edit_content_management_obj.status = 3
edit_content_management_obj.save()
# 发微信消息告知营销顾问
weixin_id = edit_content_management_obj.create_user.weixin_id
if not weixin_id: # 如果没有填写微信id 则告知 zhangcong
# 发送微信通知
now_datetime = datetime.datetime.now(
).strftime("%Y-%m-%d %H:%M:%S")
msg = "通知时间: {now_datetime} \n通知平台:诸葛问答\n用户 {username} 未设置微信id".format(
now_datetime=now_datetime,
username=edit_content_management_obj.
create_user.username)
user_id_str = "zhangcong"
else:
msg = "您交付给编辑完成的任务都已经完成,请前往问答后台-->编辑内容管理功能中查看"
user_id_str = weixin_id
tasks.send_msg.delay(user_id_str, msg)
response.status = True
response.message = "提交成功"
else:
response.status = False
response.message = "提交问答答案不能为空"
elif oper_type == "upload_file":
edit_task_management_obj = models.EditTaskManagement.objects.select_related(
'task__task').get(id=o_id)
file_obj = request.FILES.get('file') # 提交的文件
ext_name = file_obj.name.split(".")[-1] # 扩展名
file_name = ".".join([str(int(time.time()) * 1000), ext_name])
file_abs_name = os.path.join("statics/temp", file_name)
file_contents = bytes()
for chunk in file_obj.chunks():
file_contents += chunk
# 首先将提交的 excel 表格中的数据读出
book = xlrd.open_workbook(file_contents=file_contents)
sh = book.sheet_by_index(0)
excel_data = []
url_list = []
title_list = []
content_list = []
img_content_list = []
for row in range(2, sh.nrows):
url = sh.cell_value(rowx=row, colx=0) # 链接
title = sh.cell_value(rowx=row, colx=1) # 问题
content = sh.cell_value(rowx=row, colx=2) # 答案
img_content = sh.cell_value(rowx=row, colx=3) # 图片内容
excel_data.append({
"url": url,
"title": title,
"content": content,
"img_content": img_content
})
url_list.append(url)
title_list.append(title)
content_list.append(content)
img_content_list.append(img_content)
if edit_task_management_obj.task.task.wenda_type in [1, 10]:
if not title or not (content or img_content):
response.status = False
response.message = "上传数据异常"
break
else:
if not url or not title or not (content or img_content):
response.status = False
response.message = "上传数据异常"
break
print("content_list -->", content_list)
if response.status:
# 问题敏感词列表
if role_id != 14:
SensitiveWordTitle_list = [
i[0]
for i in models.SensitiveWordLibrary.objects.filter(
w_type=1).values_list('name')
]
# 答案敏感词列表
SensitiveWordContent_list = [
i[0]
for i in models.SensitiveWordLibrary.objects.filter(
w_type=2).values_list('name')
]
content_list_str = " ".join(content_list)
title_list_str = " ".join(title_list)
err_name_list = [] # 问题或答案中包含的敏感词列表
if edit_task_management_obj.task.task.wenda_type in [
1, 10
]:
for name in SensitiveWordTitle_list:
if name in title_list_str:
err_name_list.append(name)
for name in SensitiveWordContent_list:
if name in content_list_str:
err_name_list.append(name)
if err_name_list:
response.status = False
response.data = {"err_name_list": err_name_list}
response.message = "问题或答案中包含敏感词"
# if edit_task_management_obj.task.task.wenda_type in [1, 10]:
# if response.status and len(set(content_list)) != len(content_list):
# response.status = False
# response.message = "提交问答答案有重复"
# if response.status and len(set(content_list)) != len(content_list):
# response.status = False
# response.message = "提交问答答案有重复"
# print(len(title_list), len(content_list))
# if response.status and len(title_list) != len(content_list):
# response.status = False
# response.message = "提交问答问题与提交问答问题数量不符"
if response.status:
response.status = True
response.message = "添加成功"
query = []
flag = True
line_repetition = 0
for index in range(len(content_list)):
line_repetition += 1
content = content_list[index]
title = title_list[index]
url = url_list[index]
img_content = img_content_list[index]
# 判断所有的子任务中是否已经存在该内容
for i_obj in models.EditTaskManagement.objects.filter(
task_id=edit_task_management_obj.task.id):
# 在子任务的详情表中进行查找
obj = models.EditPublickTaskManagement.objects.filter(
content=content, title=title, task_id=i_obj.id)
if obj.count() > 0:
flag = False
break
if not flag:
break
else:
if role_id == 14:
status = 20
else:
status = 1
query.append(
models.EditPublickTaskManagement(
task_id=edit_task_management_obj.id,
content=content,
title=title,
url=url,
status=status,
img_content=img_content))
print("query -->", len(query))
if not flag:
response.status = False
response.message = "第 {line_num} 行已经存在".format(
line_num=line_repetition)
elif flag and len(query) != edit_task_management_obj.number:
response.status = False
response.message = "提交数量与任务数量不符"
else:
models.EditPublickTaskManagement.objects.bulk_create(query)
edit_task_management_obj.status = 2
edit_task_management_obj.complete_date = datetime.datetime.now(
)
edit_task_management_obj.save()
# 统计父任务下的子任务是否全部完成
edit_content_management_obj = models.EditContentManagement.objects.select_related(
'create_user').get(id=edit_task_management_obj.task.id)
# 该条件如果成立,表示父任务下的所有子任务都已经完成
if edit_content_management_obj.edittaskmanagement_set.filter(
status=1).count() == 0:
edit_content_management_obj.status = 3
edit_content_management_obj.save()
# 发微信消息告知营销顾问
weixin_id = edit_content_management_obj.create_user.weixin_id
if not weixin_id: # 如果没有填写微信id 则告知 zhangcong
# 发送微信通知
now_datetime = datetime.datetime.now().strftime(
"%Y-%m-%d %H:%M:%S")
msg = "通知时间: {now_datetime} \n通知平台:诸葛问答\n用户 {username} 未设置微信id".format(
now_datetime=now_datetime,
username=edit_content_management_obj.
create_user.username)
user_id_str = "zhangcong"
else:
msg = "您交付给编辑完成的任务都已经完成,请前往问答后台-->编辑内容管理功能中查看"
user_id_str = weixin_id
tasks.send_msg.delay(user_id_str, msg)
response.status = True
response.message = "提交成功"
print(title_list)
print(content_list)
print(response.message)
# 任务说明
elif oper_type == "remark_shuoming":
renwushuoming = request.POST.get('renwushuoming')
objs = models.EditTaskManagement.objects.filter(id=o_id)
task_id = objs[0].task.id
models.EditContentManagement.objects.filter(id=task_id).update(
remark=renwushuoming)
response.status = True
response.message = '修改成功'
return JsonResponse(response.__dict__)
else:
roles_dict = models.Role.objects.all().values("id", "name")
# 编辑上传任务
if oper_type == "upload":
return render(request,
'wenda/my_task_edit/my_task_edit_modal_upload.html',
locals())
elif oper_type == "upload_file":
return render(
request,
'wenda/my_task_edit/my_task_edit_modal_upload_file.html',
locals())
# 查看编写内容
elif oper_type == "search_edit_content":
edit_content_objs = models.EditPublickTaskManagement.objects.filter(
task_id=o_id).order_by("-status")
return render(
request,
'wenda/my_task_edit/my_task_edit_modal_search_edit_content.html',
locals())
# 任务说明
elif oper_type == "remark_shuoming":
objs = models.EditTaskManagement.objects.filter(id=o_id)
obj_remark = objs[0].task.remark
return render(
request,
'wenda/my_task_edit/my_task_edit_modal_remark_shuoming.html',
locals())
def personal_center_oper(request, oper_type, o_id):
user_id = request.session["user_id"]
response = pub.BaseResponse()
if request.method == "POST":
# 添加
if oper_type == "create":
response.status = True
response.message = "添加成功"
form_obj = TaskListCreateForm(request.POST)
if form_obj.is_valid():
form_obj.cleaned_data["user_id"] = user_id
models.Task.objects.create(**form_obj.cleaned_data)
else:
response.status = False
for i in [
"keywords", "url", "day_click_number", "search_engine",
"click_strategy_id"
]:
if i in form_obj.errors:
response.message = form_obj.errors[i]
break
# 批量添加
elif oper_type == "batch_create":
response.status = True
response.message = "添加成功"
print(request.POST)
keywords = request.POST["keywords"]
url = request.POST["url"]
if len(keywords.strip().split()) != len(url.strip().split()):
response.status = False
response.message = "关键词数量和网址数量不一致!"
else:
keywords_list = keywords.strip().split()
url_list = url.strip().split()
task_objs = []
for index in range(len(keywords_list)):
keywords = keywords_list[index].strip()
url = url_list[index].strip()
form_obj = TaskListCreateForm({
"keywords": keywords,
"url": url
})
if form_obj.is_valid():
task_objs.append(
models.Task(user_id=user_id,
keywords=keywords,
url=url))
else:
response.status = False
for i in ["keywords", "url"]:
if i in form_obj.errors:
response.message = "第{index}行发生错误: {message}".format(
index=index + 1,
message=form_obj.errors[i])
break
if not response.status:
break
if response.status:
models.Task.objects.bulk_create(task_objs)
# 修改
elif oper_type == "update":
response.status = True
response.message = "添加成功"
user_obj = models.UserProfile.objects.select_related('role').get(
id=user_id)
# 1 4 表示是管理员权限
if user_obj.role.id in [1, 4]:
form_obj = TaskListUpdateForm(request.POST)
else:
form_obj = TaskListCreateForm(request.POST)
if form_obj.is_valid():
models.Task.objects.filter(id=o_id).update(
**form_obj.cleaned_data)
else:
response.status = False
for i in [
"keywords", "url", "day_click_number", "search_engine",
"click_strategy_id"
]:
if i in form_obj.errors:
response.message = form_obj.errors[i]
break
# 删除用户
elif oper_type == "delete":
models.Task.objects.get(id=o_id).delete()
response.status = True
response.message = "删除成功"
# 充值
elif oper_type == "recharge":
balance = request.POST.get("balance")
if not balance or not balance.isdigit():
response.status = False
response.message = "充值金额有误"
models.UserProfile.objects.filter(id=o_id).update(
balance=F("balance") + int(balance))
models.BalanceDetail.objects.create(user_id=o_id,
type=1,
money=balance,
oper_user_id=user_id)
response.status = True
response.message = "充值成功"
# 下线
elif oper_type == "offline":
models.Task.objects.filter(id=o_id).update(status=2)
response.status = True
response.message = "下线成功"
# 上线
elif oper_type == "online":
models.Task.objects.filter(id=o_id).update(status=1)
response.status = True
response.message = "上线成功"
return JsonResponse(response.__dict__)
else:
roles_dict = models.Role.objects.all().values("id", "name")
# 添加
if oper_type == "create":
return render(request,
'paimingbao/task_list/task_list_modal_create.html',
locals())
# 批量添加
if oper_type == "batch_create":
return render(
request,
'paimingbao/task_list/task_list_modal_batch_create.html',
locals())
# 修改
elif oper_type == "update":
# 修改的时候区分管理员用户和普通用户
user_obj = models.UserProfile.objects.select_related('role').get(
id=user_id)
admin_role_list = [1, 4]
task_list_obj = models.Task.objects.select_related(
"click_strategy").get(id=o_id)
search_engine_choices = models.Task.search_engine_choices
click_strategy_objs = models.ClickStrategy.objects.filter(
user_id__in=[user_id, 1]) # 获取系统默认策略和自定义策略
return render(request,
'paimingbao/task_list/task_list_modal_update.html',
locals())
# 删除
elif oper_type == "delete":
task_list_obj = models.Task.objects.get(id=o_id)
return render(request,
'paimingbao/task_list/task_list_modal_delete.html',
locals())
# 下线
elif oper_type == "offline":
task_list_obj = models.Task.objects.get(id=o_id)
return render(request,
'paimingbao/task_list/task_list_modal_offline.html',
locals())
# 上线
elif oper_type == "online":
task_list_obj = models.Task.objects.get(id=o_id)
return render(request,
'paimingbao/task_list/task_list_modal_online.html',
locals())
def cover_reports_oper(request, oper_type, o_id):
user_id = request.session["user_id"]
role_id = request.session.get("role_id")
response = pub.BaseResponse()
if request.method == "POST":
# 添加
if oper_type == "create":
keyword = request.POST.get("keyword")
client_user_id = request.POST.get("client_user_id", None)
print(client_user_id)
if client_user_id == "":
response.status = False
response.message = "请选择用户"
elif client_user_id is None:
client_user_id = user_id
if response.status and not keyword:
response.status = False
response.message = "请输入需要添加的关键词"
if response.status:
keyword_list = set(keyword.splitlines())
query = []
repeat_num = 0
for i in keyword_list:
if not i: # 如果为空 则跳过
continue
obj = models.KeywordsTopSet.objects.filter(
client_user_id=user_id, keyword=i, is_delete=False)
if not obj:
query.append(
models.KeywordsTopSet(
keyword=i,
client_user_id=client_user_id,
oper_user_id=user_id,
))
else:
repeat_num += 1
models.KeywordsTopSet.objects.bulk_create(query)
response.status = True
response.message = "成功添加 {num} 个关键词".format(num=len(query))
# 删除
elif oper_type == "delete":
obj = models.KeywordsTopSet.objects.get(id=o_id)
obj.is_delete = True
obj.save()
response.status = True
response.message = "删除成功"
# 覆盖报表所有功能 修改计费 删除链接....
elif oper_type == 'quanbushezhi':
data_objs = models.UserProfile.objects.filter(id=o_id)
print('requeat -----> ', request.POST)
print('data_objs - -- - - -- - > ', data_objs)
# zhanshibianji = request.POST.get('zhanshibianji')
fasongbaobiao = request.POST.get('fasongbaobiao')
chongchafugai = request.POST.get('chongchafugai')
delete_lianjie = request.POST.get('delete_lianjie')
xiugaijifeiriqistart = request.POST.get('xiugaijifeiriqistart')
xiugaijifeiriqistop = request.POST.get('xiugaijifeiriqistop')
# 展示编辑
# if zhanshibianji == 'on':
# print('进入展示编辑 ')
# data_objs.update(task_edit_show=True)
# data_objs[0].save()
# print('data_objs -- - -- > ',data_objs[0].task_edit_show)
# else:
# print('展示编辑else')
# data_objs.update(task_edit_show=False)
# 发送报表
if fasongbaobiao == 'on':
data_objs.update(send_statement=True)
else:
data_objs.update(send_statement=False)
# 重查覆盖
if chongchafugai == 'on':
today_date = datetime.datetime.now().strftime("%Y-%m-%d")
models.KeywordsCover.objects.filter(
keywords__client_user_id=o_id,
create_date__gte=today_date).delete()
models.KeywordsTopSet.objects.filter(
client_user_id=o_id).update(update_select_cover_date=None)
models.UserprofileKeywordsCover.objects.filter(
client_user_id=o_id, create_date__gte=today_date).delete()
models.KeywordsSearchLog.objects.filter(
keyword__client_user_id=o_id,
create_date__gte=today_date).delete()
# 删除链接
if delete_lianjie:
print('进入删除 - - -- > ', delete_lianjie)
delete_lianjie_list = set(delete_lianjie.splitlines())
print('delete_lianjie_list - - - - - - >', delete_lianjie_list)
for delete_lianjie in delete_lianjie_list:
if not delete_lianjie:
continue
objs = models.TongjiKeywords.objects.filter(
url=delete_lianjie,
task__release_user_id=o_id,
)
print('objs - - -- -- -- - - 》', objs)
if objs:
objs.delete()
# 修改计费日期
if xiugaijifeiriqistart or xiugaijifeiriqistop:
print(xiugaijifeiriqistart, xiugaijifeiriqistop)
forms_obj = jifeiupdateForm(request.POST)
if forms_obj.is_valid():
time_objs = models.UserProfile.objects.filter(
id=o_id).update(jifei_start_date=xiugaijifeiriqistart,
jifei_stop_date=xiugaijifeiriqistop)
else:
response.status = False
response.message = '请填写正确日期'
response.status = True
response.message = "操作成功"
# 查询覆盖量
elif oper_type == 'chaxunfugai':
startfugai = request.POST.get('startfugai')
stopfugai = request.POST.get('stopfugai')
client_id = request.POST.get('client_id')
if not client_id:
response.code = 301
response.message = '请输入客户名称'
else:
print('开始时间--结束时间 -- - ->', startfugai, stopfugai)
print('id -- -- -> ', client_id)
q = Q(
Q(create_date__gte=startfugai)
& Q(create_date__lte=stopfugai)
& Q(client_user_id=client_id))
# q.add(Q(create_date__gte=startfugai) & Q(create_date__lte=stopfugai) & Q(client_user_id=client_id),Q.AND)
print('q = == == == >', q)
if startfugai and stopfugai:
# objs = models.UserprofileKeywordsCover.objects.filter(q).values('cover_num')
objs = models.UserprofileKeywordsCover.objects.filter(
q).values('create_date',
'cover_num').annotate(Count('cover_num'))
print(objs)
data_temp = {}
# data_obj = 0
sum_cover_num = 0
for obj in objs:
sum_cover_num += obj['cover_num']
# data_temp[obj.create_date] = obj.cover_num
# for index, data in data_temp.items():
# sum_cover_num += int(data)
response.code = 200
response.message = '查询成功'
response.data = sum_cover_num
return JsonResponse(response.__dict__)
# 重新生成覆盖报表
elif oper_type == 'rebuild':
date_obj = datetime.datetime.now()
date = date_obj.strftime("%Y-%m-%d")
objs = models.UserprofileKeywordsCover.objects.filter(
create_date=date, )
objs.delete()
response.code = 200
response.message = '生成成功'
# 单用户生成覆盖报表
elif oper_type == 'one_user_generation':
date_obj = datetime.datetime.now()
date = date_obj.strftime("%Y-%m-%d")
objs = models.UserprofileKeywordsCover.objects.filter(
create_date=date, client_user=o_id)
if objs:
objs.delete()
response.code = 200
response.status = True
response.message = '生成成功'
else:
response.status = False
response.message = '没有报表,请勿重复操作！'
# 下载报表
if oper_type == "download":
user_id = request.POST.get("user_id")
if not user_id:
response.status = False
response.message = "请选择导出用户名称"
else:
file_name = os.path.join(
"statics", "upload_files",
str(int(time.time() * 1000)) + ".xlsx")
search_objs = models.KeywordsCover.objects.select_related(
'keywords', 'keywords__client_user').filter(
keywords__client_user_id=user_id).order_by(
"-create_date")
data_list = []
for obj in search_objs:
data_list.append({
"username":
obj.keywords.client_user.username,
"keywords":
obj.keywords.keyword,
"page_type":
obj.get_page_type_display(),
"rank":
obj.rank,
"create_date":
obj.create_date.strftime("%Y-%m-%d"),
"link":
obj.url
})
tasks.cover_reports_generate_excel.delay(file_name, data_list)
tasks.userprofile_keywords_cover.delay()
response.status = True
response.message = "导出成功"
response.download_url = "/" + file_name
return JsonResponse(response.__dict__)
else:
# 添加
if oper_type == "create":
client_objs = models.UserProfile.objects.filter(is_delete=False,
role_id=5)
return render(
request,
'wenda/keywords_top_set/keywords_top_set_modal_create.html',
locals())
# 删除
elif oper_type == "delete":
obj = models.KeywordsTopSet.objects.get(id=o_id)
return render(
request,
'wenda/keywords_top_set/keywords_top_set_modal_delete.html',
locals())
# 客户首页覆盖
elif oper_type == "client_cover":
objs = models.KeywordsTopInfo.objects.values(
'keyword__client_user', 'keyword__client_user__username',
'page_type').annotate(
cover=Count("keyword__client_user")).all()
data = {}
for obj in objs:
client_user_id = obj["keyword__client_user"]
username = obj["keyword__client_user__username"]
page_type = obj["page_type"]
cover = obj["cover"]
if client_user_id in data:
data[client_user_id][page_type] = cover
if page_type == 1:
data[client_user_id][
"total"] = cover + data[client_user_id][3]
else:
data[client_user_id][
"total"] = cover + data[client_user_id][1]
else:
# 查询该用户添加了多少关键词数量
keywords_top_set_objs = models.KeywordsTopSet.objects.filter(
client_user_id=client_user_id)
keywords_num = keywords_top_set_objs.count()
no_select_keywords_num = keywords_top_set_objs.filter(
status=1).count()
if keywords_top_set_objs.filter(status=1):
keywords_status = "查询中"
else:
keywords_status = "已查询"
keywords_top_page_cover_excel_path = keywords_top_set_objs[
0].client_user.keywords_top_page_cover_excel_path
keywords_top_page_cover_yingxiao_excel_path = keywords_top_set_objs[
0].client_user.keywords_top_page_cover_yingxiao_excel_path
data[client_user_id] = {
page_type:
cover,
"username":
username,
"keywords_num":
"{keywords_num} / {no_select_keywords_num}".format(
keywords_num=keywords_num,
no_select_keywords_num=no_select_keywords_num),
"keywords_status":
keywords_status,
"keywords_top_page_cover_excel_path":
keywords_top_page_cover_excel_path,
"keywords_top_page_cover_yingxiao_excel_path":
keywords_top_page_cover_yingxiao_excel_path
}
return render(
request,
'wenda/keywords_top_set/keywords_top_set_modal_client_cover.html',
locals())
# 报表下载
elif oper_type == "download":
client_data = models.KeywordsCover.objects.values(
'keywords__client_user__username',
'keywords__client_user_id').annotate(Count("keywords"))
print(client_data)
return render(
request,
"wenda/cover_reports/cover_reports_modal_download.html",
locals())
# 查看客户每日覆盖明细
elif oper_type == "show_click_info":
data_objs = models.UserprofileKeywordsCover.objects.filter(
client_user_id=o_id)
# data_objs = models.KeywordsCover.objects.select_related(
# "keywords__client_user",
# "keywords"
# ).filter(keywords__client_user_id=o_id).values("create_date").annotate(count=Count('id'))
temp_data = {}
for obj in data_objs:
print(' = = = == = = = > ', obj)
date_format = obj.create_date.strftime("%Y-%m-%d")
temp_data[date_format] = {
"cover_num": obj.cover_num,
"url_num": obj.url_num,
"statement_path": obj.statement_path
}
if role_id in [5, 12, 15]: # 客户角色和销售角色
result_data = """
<table class="table table-bordered text-nowrap padding-left-50 margin-bottom-0" >
<tr><td>编号</td><td>日期</td><td>覆盖数</td><td>下载报表</td></tr>
{tr_html}
</table>
"""
else:
result_data = """
<table class="table table-bordered text-nowrap padding-left-50 margin-bottom-0" >
<tr><td>编号</td><td>日期</td><td>覆盖数</td><td>链接数</td><td>下载报表</td></tr>
{tr_html}
</table>
"""
tr_html = ""
for index, date in enumerate(sorted(temp_data.keys(),
reverse=True),
start=1):
# 销售角色只能下载属于自己客户的报表
file_path = temp_data[date]["statement_path"]
print('file_path - -- - - - - -> ', file_path)
print('temp_data -- - —— -> ', temp_data)
# 超级管理员 管理员 营销顾问看对应的报表
if role_id in [1, 4, 7]:
temp = temp_data[date]["statement_path"].split('/')
print(temp[:-1], 'yingxiaoguwen_' + temp[-1])
file_name = 'yingxiaoguwen_' + temp[-1]
file_path = '/'.join(temp[:-1]) + '/' + file_name
# print(file_path)
statement_path = "<a href='/{file_path}' download='{download}'>下载报表</a>".format(
file_path=file_path,
download=temp_data[date]["statement_path"].split("/")[-1])
if role_id == 12 and data_objs[
0].client_user.xiaoshou_id != user_id and user_id != 133:
statement_path = ''
if role_id in [5, 12, 15]:
tr_html += """
<tr><td>{index}</td><td>{date}</td><td>{count}</td><td>{statement_path}</td></tr>
""".format(index=index,
date=date,
count=temp_data[date]["cover_num"],
statement_path=statement_path)
else:
tr_html += """
<tr><td>{index}</td><td>{date}</td><td>{count}</td><td>{url_num}</td><td>{statement_path}</td></tr>
""".format(index=index,
date=date,
count=temp_data[date]["cover_num"],
url_num=temp_data[date]["url_num"],
statement_path=statement_path)
result_data = result_data.format(tr_html=tr_html)
return HttpResponse(result_data)
# 展示编辑内容
elif oper_type == 'task_edit_show':
data_objs = models.UserProfile.objects.filter(id=o_id)
if data_objs:
data_objs[0].task_edit_show = not data_objs[0].task_edit_show
data_objs[0].save()
return redirect(reverse("cover_reports"))
# 重查报表
elif oper_type == "chongcha":
today_date = datetime.datetime.now().strftime("%Y-%m-%d")
models.KeywordsCover.objects.filter(
keywords__client_user_id=o_id,
create_date__gte=today_date).delete()
models.KeywordsTopSet.objects.filter(client_user_id=o_id).update(
update_select_cover_date=None)
models.UserprofileKeywordsCover.objects.filter(
client_user_id=o_id, create_date__gte=today_date).delete()
return redirect(reverse("cover_reports"))
# 删除链接
elif oper_type == 'shanchulianjie':
objs = models.UserProfile.objects.filter(id=o_id)
user = objs[0]
return render(
request,
'wenda/cover_reports/client_reports_modal_shanchulianjie.html',
locals())
# return redirect(reverse("cover_reports"))
# 修改计费日期
elif oper_type == 'xiugaijifeiriqi':
o_id = o_id
return render(
request,
'wenda/cover_reports/client_reports_modal_xiugaijifeiriqi.html',
locals())
# 设置按钮
elif oper_type == 'quanbushezhi':
o_id = o_id
obj = models.UserProfile.objects.get(id=o_id)
print('obj - --- -> ', obj)
start_time = ''
stop_time = ''
if obj.jifei_start_date:
start_time = obj.jifei_start_date.strftime('%Y-%m-%d')
if obj.jifei_stop_date:
stop_time = obj.jifei_stop_date.strftime('%Y-%m-%d')
return render(
request,
'wenda/cover_reports/client_reports_modal_shezhi.html',
locals())
# 查讯覆盖量
elif oper_type == 'chaxunfugai':
client_data = models.ClientCoveringData.objects.filter(
client_user__is_delete=False).values(
'client_user__username',
'client_user_id').annotate(Count("id"))
return render(
request,
'wenda/cover_reports/client_reports__modal_select_fugai_liang.html',
locals())
# 重新生成覆盖报表
elif oper_type == 'rebuild':
return render(
request,
'wenda/cover_reports/cover_chongxin_shengcheng_baobiao.html',
locals())
# 单用户生成覆盖报表
elif oper_type == 'one_user_generation':
print('o_id = === = =>', o_id)
objs = models.UserProfile.objects.filter(id=o_id)
user_name = objs[0].username
return render(
request,
'wenda/cover_reports/cover_chongxin_one_user_shengcheng_baobiao.html',
locals())
def wenda_robot_oper(request, oper_type, o_id):
user_id = request.session["user_id"]
response = pub.BaseResponse()
if request.method == "POST":
if oper_type == "create":
print("xxx")
form_obj = WendaRobotTaskCreateForm(request.POST)
if form_obj.is_valid():
release_platform = form_obj.cleaned_data["release_platform"]
wenda_type = form_obj.cleaned_data["wenda_type"]
content = form_obj.cleaned_data["content"]
create_data = {
"release_platform": release_platform,
"wenda_type": wenda_type,
"content": content,
"user_id": user_id,
}
print('create_data -- > ', create_data)
if wenda_type == "1":
title = request.POST["title"]
create_data["title"] = title
elif wenda_type == "2":
wenda_url = request.POST["wenda_url"]
create_data["wenda_url"] = wenda_url
create_data["status"] = 2
models.WendaRobotTask.objects.create(**create_data)
response.status = True
response.message = "添加成功"
else:
pass
elif oper_type == "download":
print(request.POST)
task_id = request.POST.get("task_id")
print(task_id)
if not task_id:
response.status = False
response.message = "请选择任务名称"
else:
wenda_robot_task_objs = models.WendaRobotTask.objects.filter(
task_id=task_id).order_by('status')
status_choices = models.WendaRobotTask.status_choices
file_name = os.path.join(
"statics", "upload_files",
str(int(time.time() * 1000)) + ".xlsx")
wenda_robot_task_list = []
for obj in wenda_robot_task_objs:
wenda_robot_task_list.append({
"status": obj.status,
"wenda_url": obj.wenda_url,
"title": obj.title,
"content": obj.content,
})
tasks.WendaRobotWriteExcel.delay(file_name,
wenda_robot_task_list,
status_choices)
response.status = True
response.message = "导出成功"
response.download_url = "/" + file_name
elif oper_type == "add_map":
obj = models.WendaRobotTask.objects.get(id=o_id)
obj.add_map = 1
obj.save()
response.status = True
response.message = "添加地图成功"
elif oper_type == 'jiqirenfabutongji':
robotstart = request.POST.get('robotstart')
robotstop = request.POST.get('robotstop')
if robotstart and robotstop:
objs = models.RobotReleaseNum.objects.filter(
create_date__gte=robotstart,
create_date__lt=robotstop,
).values('robot_count', 'create_date').annotate(Count('id'))
print('objs---->', objs)
temp_data = {}
data_list = []
for obj in objs:
robot_count = obj['robot_count']
create_date = obj['create_date'].strftime('%Y-%m-%d')
if robot_count == None:
robot_count = 0
if 'data' in temp_data:
if create_date in temp_data['data']:
temp_data['data'][create_date] += robot_count
else:
temp_data['data'][create_date] = robot_count
else:
temp_data['data'] = {create_date: robot_count}
for k, data in temp_data.items():
for k1, v1 in data.items():
data_list.append({'date_time': k1, 'count': v1})
print('data_list---->', data_list)
response.code = 200
response.data = data_list
elif oper_type == 'look_log':
pass
return JsonResponse(response.__dict__)
else:
# 添加
if oper_type == "create":
release_platform_choices = models.WendaRobotTask.release_platform_choices
wenda_type_choices = models.WendaRobotTask.wenda_type_choices
return render(request,
"wenda/wenda_robot/wenda_robot_modal_create.html",
locals())
# 导出
elif oper_type == "download":
wenda_type_choices = models.WendaRobotTask.wenda_type_choices
task_names = models.WendaRobotTask.objects.values(
"task_id", "task__name").distinct()
return render(request,
"wenda/wenda_robot/wenda_robot_modal_download.html",
locals())
elif oper_type == "add_map":
obj = models.WendaRobotTask.objects.get(id=o_id)
# 判断是否填写地图搜索关键词和地图匹配关键词
if obj.task.release_user.map_search_keywords and obj.task.release_user.map_match_keywords:
map_flag = True
else:
map_flag = False
return render(request,
"wenda/wenda_robot/wenda_robot_modal_add_map.html",
locals())
elif oper_type == 'jiqirenfabutongji':
now_data = datetime.datetime.now()
now_data = now_data.strftime('%Y-%m-%d')
objs = models.RobotReleaseNum.objects.filter(
create_date__gte=now_data, ).values('robot_count',
'create_date').annotate(
Count('id'))
data_temp = {}
for obj in objs:
create_data = obj['create_date'].strftime('%Y-%m-%d')
robot_count = obj['robot_count']
if 'count' in data_temp:
if create_data in data_temp['count']:
data_temp['count'][create_data] += robot_count
else:
data_temp['count'[create_data]] = robot_count
else:
data_temp['count'] = {create_data: robot_count}
print(data_temp)
data = ''
for index, data in data_temp.items():
for k, v in data.items():
data = str(v)
response.code = 200
response.data = data
return render(request,
'wenda/wenda_robot/wenda_robot_release_num.html',
locals())
# 查看答案
elif oper_type == 'look_content':
objs = models.WendaRobotTask.objects.filter(id=o_id)
content = objs[0].content
print('content- ------------- > ', content)
return render(
request,
'wenda/wenda_robot/wenda_robot_modal_look_content.html',
locals())
# 查看最近操作日志
elif oper_type == 'look_log':
objs = models.RobotAccountLog.objects.filter(
wenda_robot_task_id=o_id).order_by('create_date')
return render(request,
'wenda/wenda_robot/wenda_robot_modal_look_log.html',
locals())
def user_management_oper(request, oper_type, o_id):
user_id = request.session["user_id"]
response = pub.BaseResponse()
if request.method == "POST":
# 添加
if oper_type == "create":
response.status = True
response.message = "添加成功"
username = request.POST.get('username')
xiaoshou_id = request.POST.get('xiaoshou_id')
print('username ,xiaoshou_id - -- ->', username, xiaoshou_id)
form_obj = user.UserProfileCreateForm(request.POST)
print(form_obj.is_valid())
if form_obj.is_valid():
form_obj.cleaned_data["oper_user_id"] = user_id
user_obj = models.UserProfile.objects.create(
**form_obj.cleaned_data)
models.YingXiaoGuWen_DuiJie.objects.create(
kehu_username_id=user_obj.id, market=user_obj.xiaoshou)
else:
response.status = False
for i in [
"username", "password", "role_id", "guwen_id",
"xiaoshou_id", 'xinlaowenda_status',
'zhidao_hehuoren_website'
]:
if i in form_obj.errors:
response.message = form_obj.errors[i]
break
# 修改
elif oper_type == "update":
response.status = True
response.message = "修改成功"
print(request.POST.get("id"))
shouyi_role_ids = [8, 9, 6]
uid = request.POST.get("id")
role_id = models.UserProfile.objects.select_related('role').get(
id=uid).role.id
post_data = {}
for k, v in dict(request.POST).items():
post_data[k] = v[0]
print(post_data)
if role_id not in shouyi_role_ids:
post_data["xie_wenda_money"] = ''
post_data["fa_wenda_money"] = ''
if role_id != 5:
post_data["map_search_keywords"] = ''
post_data["map_match_keywords"] = ''
form_obj = user.UserProfileUpdateForm(post_data)
if form_obj.is_valid():
if not form_obj.cleaned_data["password"]:
del form_obj.cleaned_data["password"]
print(form_obj.cleaned_data)
department_id = request.POST.get('department_id')
if department_id:
models.HospitalInformation.objects.filter(
user_id=o_id).update(department_id=department_id)
print(form_obj.cleaned_data)
models.UserProfile.objects.filter(
id=request.POST.get("id")).update(**form_obj.cleaned_data)
else:
response.status = False
print(form_obj.errors)
for i in [
"username", "password", "role_id", "guwen_id",
"xiaoshou_id", "xie_wenda_money", "fa_wenda_money",
'xinlaowenda_status'
]:
if i in form_obj.errors:
response.message = form_obj.errors[i]
break
# 删除用户
elif oper_type == "delete":
user_profile_obj = models.UserProfile.objects.get(id=o_id)
user_profile_obj.is_delete = True
user_profile_obj.save()
response.status = True
response.message = "删除成功"
# 充值
elif oper_type == "recharge":
balance = request.POST.get("balance")
zbalance = request.POST.get("zbalance")
remark = request.POST.get("remark")
if not balance or not balance.lstrip('-').isdigit():
response.status = False
response.message = "充值金额有误"
if zbalance and not zbalance.lstrip('-').isdigit():
response.status = False
response.message = "赠送金额有误"
elif not zbalance:
zbalance = 0
else:
zbalance = int(zbalance)
if response.status:
sum_moeny = int(balance) + int(zbalance)
user_profile_obj = models.UserProfile.objects.select_related(
"oper_user").get(id=o_id)
# .update(balance=F("balance") + int(balance))
user_profile_obj.balance += sum_moeny
user_profile_obj.save()
models.BalanceDetail.objects.create(user_id=o_id,
account_type=1,
money=sum_moeny,
balance=balance,
zbalance=zbalance,
oper_user_id=user_id,
remark=remark)
message = "【充值】{username} 为您充值 {moeny} 问答币 ".format(
username=models.UserProfile.objects.get(
id=user_id).username,
moeny=sum_moeny)
AddMessage(request, user_profile_obj.id, message)
response.status = True
response.message = "充值成功"
return JsonResponse(response.__dict__)
else:
roles_dict = models.Role.objects.all().values("id", "name")
# 添加用户
if oper_type == "create":
guwen_objs = models.UserProfile.objects.filter(role_id=7,
is_delete=False)
xiaoshou_objs = models.UserProfile.objects.filter(role_id=12,
is_delete=False)
return render(
request,
'myadmin/user_management/user_management_modal_create.html',
locals())
# 修改用户
elif oper_type == "update":
user_profile_obj = models.UserProfile.objects.select_related(
"role").get(id=o_id)
guwen_objs = models.UserProfile.objects.filter(role_id=7,
is_delete=False)
xiaoshou_objs = models.UserProfile.objects.filter(role_id=12,
is_delete=False)
xinlaowenda = models.UserProfile.objects.filter(id=o_id)
wenda_status = xinlaowenda[0].get_xinlaowenda_status_display()
# 问答编辑、问答渠道、兼职发帖角色的id
print(user_profile_obj.role.id)
shouyi_role_ids = [8, 9, 6]
print('wenda_status ============ >', wenda_status)
print('models.UserProfile.xinlaowenda_status_choices--》',
models.UserProfile.xinlaowenda_status_choices)
if wenda_status == '新问答':
xinlaowenda_status = models.UserProfile.xinlaowenda_status_choices[
1]
else:
xinlaowenda_status = models.UserProfile.xinlaowenda_status_choices[
0]
print('xinlaowenda_status ============ >', xinlaowenda_status)
department_objs = models.Department.objects.all()
hospital_infomation_objs = models.HospitalInformation.objects.filter(
user_id=o_id)
if hospital_infomation_objs:
hospital_infomation_obj = hospital_infomation_objs[0]
print('user_profile_obj.role.id -->', user_profile_obj.role.id)
return render(
request,
'myadmin/user_management/user_management_modal_update.html',
locals())
# 删除用户
elif oper_type == "delete":
user_profile_obj = models.UserProfile.objects.get(id=o_id)
return render(
request,
'myadmin/user_management/user_management_modal_delete.html',
locals())
# 充值
elif oper_type == "recharge":
return render(
request,
'myadmin/user_management/user_management_modal_recharge.html',
locals())
def guanjianci_jieping_oper(request, oper_type, o_id):
role_id = request.session.get("role_id")
response = pub.BaseResponse()
if request.method == "POST":
# 添加50个关键词
if oper_type == "create_guanjianci":
yonghu_id = request.POST.get('yonghuming')
guanjianci_create = request.POST.get('guanjianci_create')
print('guanjianci_create = == = == = >', guanjianci_create)
guanjianci_list = set(guanjianci_create.splitlines())
# 数据库查询条数
objs = models.Fifty_GuanJianCi.objects.filter(
yonghu_user=yonghu_id).values('yonghu_user_id').annotate(
Count('id'))
# 输入的条数
# now_date_time = datetime.date.today()
if objs:
len_guanjianci = len(guanjianci_list)
# print('输入的条数 - -- - -> ',len_guanjianci )
# print('数据库条数 - -- - -> ',objs[0]['id__count'] )
# print('数据库条数 + 输入的条数 - -- - -> ',objs[0]['id__count'] + len_guanjianci )
if objs[0]['id__count'] + len_guanjianci > 50:
response.status = False
response.message = '数据库大于50条,请删除部分关键词'
elif len_guanjianci > 50:
response.status = False
response.message = '关键字超出50条,请检查!'
else:
obj = models.UserProfile.objects.filter(id=yonghu_id)
if obj:
# print('查询user成功 = = = = 》')
for guanjianci in guanjianci_list:
# print('关键词入库 -- -- - - 》', guanjianci)
# print('用户id ------ 》 ',yonghu_id )
models.Fifty_GuanJianCi.objects.create(
guanjianci=guanjianci,
yonghu_user=obj[0],
)
response.status = True
response.message = '添加成功'
else:
len_guanjianci = len(guanjianci_list)
if len_guanjianci > 50:
response.status = False
response.message = '关键字总数超出50条,请检查!'
else:
obj = models.UserProfile.objects.filter(id=yonghu_id)
if obj:
for guanjianci in guanjianci_list:
models.Fifty_GuanJianCi.objects.create(
guanjianci=guanjianci,
yonghu_user=obj[0],
)
response.status = True
response.message = '添加成功'
# 修改关键词
elif oper_type == 'update_guanjianci':
guanjianci = request.POST.get('guanjianci')
print('guanjianci - -- - >', guanjianci)
if guanjianci:
objs = models.Fifty_GuanJianCi.objects.filter(id=o_id)
if objs:
objs.update(guanjianci=guanjianci)
response.status = True
response.message = '修改成功'
else:
response.status = False
response.message = '修改失败'
# 删除关键词
elif oper_type == 'delete_guanjianci':
print('o_id - - -> ', o_id)
obj = models.Fifty_GuanJianCi.objects.get(id=o_id)
if obj:
obj.delete()
response.status = True
response.message = '删除成功'
else:
response.status = False
response.message = '删除失败'
#删除单个用户所有关键词
elif oper_type == 'delete_in_batches':
yonghuming = request.POST.get('yonghuming')
print('yonghuming ============ > ', yonghuming)
if yonghuming:
objs = models.Fifty_GuanJianCi.objects.filter(
yonghu_user_id=yonghuming)
if objs:
objs.delete()
response.status = True
response.message = '删除成功'
else:
response.status = False
response.message = '删除失败'
return JsonResponse(response.__dict__)
else:
# 添加50个关键词
if oper_type == "create_guanjianci":
client_objs = models.UserProfile.objects.filter(is_delete=False,
role_id=5)
return render(
request,
'wenda/fifty_guanjianci_jieping/fifty_guanjianci_create.html',
locals())
# 修改关键词
elif oper_type == 'update_guanjianci':
client_objs = models.UserProfile.objects.filter(is_delete=False,
role_id=5)
obj = models.Fifty_GuanJianCi.objects.get(id=o_id)
guanjianci_name = obj.guanjianci
guanjianci_id = obj.id
return render(
request,
'wenda/fifty_guanjianci_jieping/fifty_guanjianci_update.html/',
locals())
# 删除关键词
elif oper_type == 'delete_guanjianci':
obj = models.Fifty_GuanJianCi.objects.get(id=o_id)
guanjianci = obj.guanjianci
return render(
request,
'wenda/fifty_guanjianci_jieping/fifty_guanjianci_delete.html',
locals())
# 查看关键词截屏
elif oper_type == 'guanjianci_jieping_select':
objs = models.Fifty_GetKeywordsJiePing.objects.filter(
guanjianci_id=o_id)
data_list = []
for obj in objs:
picture = obj.picture_path
print('picture- - -> ', picture)
data_list.append(str(picture))
response.data = data_list
return JsonResponse(response.__dict__)
# 删除单个用户所有关键词
elif oper_type == 'delete_in_batches':
client_objs = {}
objs = models.Fifty_GuanJianCi.objects.filter(
yonghu_user__isnull=False)
for obj in objs:
username = obj.yonghu_user.username
p_id = obj.yonghu_user_id
client_objs[p_id] = {'username': username, 'p_id': p_id}
client_obj = []
for p_id, data in client_objs.items():
client_obj.append(data)
print(client_obj)
return render(
request,
'wenda/fifty_guanjianci_jieping/fifty_delete_in_batches.html',
locals())
def my_task_oper(request, oper_type, o_id):
user_id = request.session["user_id"]
response = pub.BaseResponse()
if request.method == "POST":
# 添加
if oper_type == "create":
print(request.POST)
release_platform = request.POST.get("release_platform")
wenda_type = request.POST.get("wenda_type")
num = request.POST.get("num")
file_obj = request.FILES.get('file')
form_obj = MyTaskCreateForm(data={
"release_platform": release_platform,
"wenda_type": wenda_type,
"num": num,
"file_obj": file_obj,
})
if form_obj.is_valid():
user_profile_obj = models.UserProfile.objects.get(id=user_id)
# 扣费
global_settings_obj = models.GlobalSettings.objects.all()[0]
if int(wenda_type) in [1, 10]: # 新问答 和 新问答补发
money = int(num) * global_settings_obj.new_wenda_money
else: # 老问答
money = int(num) * global_settings_obj.old_wenda_money
if user_profile_obj.balance >= money: # 表示钱够
hospital_information_obj = models.HospitalInformation.objects.select_related("department").get(
user_id=user_id)
task_count = models.Task.objects.filter(release_user_id=user_id).count() + 1
release_platform_name = \
[i[1] for i in models.Task.release_platform_choices if int(release_platform) == i[0]][0]
wenda_type_name = [i[1] for i in models.Task.type_choices if int(wenda_type) == i[0]][0]
print(release_platform_name, wenda_type_name)
task_name = "%s_%s_%s_%s_%s" % (
hospital_information_obj.name,
hospital_information_obj.department.name,
release_platform_name,
wenda_type_name,
task_count,
)
file_name = file_obj.name
extension_name = file_name.split(".")[-1]
file_save_name = ".".join([task_name, extension_name])
file_save_path = "/".join(["statics", "task_excel", "demand", file_save_name])
print(file_save_path)
file_contents = bytes()
for chunk in file_obj.chunks():
file_contents += chunk
if int(wenda_type) in [1, 10]: # 新问答或新问答补发
# 首先将提交的 excel 表格中的数据读出
book = xlrd.open_workbook(file_contents=file_contents)
sh = book.sheet_by_index(0)
excel_data = []
for row in range(2, sh.nrows):
line_data = ['']
for col in range(sh.ncols):
value = sh.cell_value(rowx=row, colx=col)
line_data.append(value)
excel_data.append(line_data)
print(excel_data)
# 然后将数据写入新的excel表格中
templete_path = os.path.join('statics/task_excel/template/新问答-信息模板2.xlsx') # 模板存放路径
# wb = load_workbook(filename=templete_path)
print("excel_data -->", excel_data, os.path.join(os.getcwd(), file_save_path))
tasks.CreateExcel.delay(excel_data, os.path.join(os.getcwd(), file_save_path))
else: # 老问答
with open(file_save_path, "wb") as f:
f.write(file_contents)
# 添加任务
task_obj = models.Task.objects.create(
release_user_id=user_id,
name=task_name,
release_platform=form_obj.cleaned_data["release_platform"],
wenda_type=form_obj.cleaned_data["wenda_type"],
num=form_obj.cleaned_data["num"],
task_demand_file_path=file_save_path,
update_date=datetime.datetime.now()
)
user_profile_obj.balance -= money
user_profile_obj.save()
# 添加任务日志
models.TaskProcessLog.objects.create(
task=task_obj,
status=1,
oper_user_id=user_id
)
message = "新发布任务 [{task_name}] , 请分配发布人员".format(
task_name=task_obj.name,
)
AddMessage(request, task_obj.release_user.guwen.id, message)
response.status = True
response.message = "添加成功"
else:
response.status = False
response.message = "当前用户余额不足!"
else:
response.status = False
for i in ["release_platform", "wenda_type", "num", "file_obj"]:
if i in form_obj.errors:
response.message = form_obj.errors[i]
break
# # 修改
# elif oper_type == "update":
# response.status = True
# response.message = "修改成功"
# print(request.POST.get("id"))
# form_obj = user.UserProfileUpdateForm(request.POST)
#
# if form_obj.is_valid():
# if not form_obj.cleaned_data["password"]:
# del form_obj.cleaned_data["password"]
#
# print(form_obj.cleaned_data)
#
# models.UserProfile.objects.filter(id=request.POST.get("id")).update(**form_obj.cleaned_data)
# else:
# response.status = False
# for i in ["username", "password", "role_id"]:
# if i in form_obj.errors:
# response.message = form_obj.errors[i]
# break
# 删除
elif oper_type == "delete":
task_obj = models.Task.objects.get(id=o_id)
user_profile_obj = models.UserProfile.objects.get(id=user_id)
# 扣费
global_settings_obj = models.GlobalSettings.objects.all()[0]
if task_obj.wenda_type == 1: # 新问答
money = task_obj.num * global_settings_obj.new_wenda_money
else: # 老问答
money = task_obj.num * global_settings_obj.old_wenda_money
user_profile_obj.balance += money
user_profile_obj.save()
task_obj.is_delete = True
task_obj.update_date = datetime.datetime.now()
task_obj.save()
# 删除任务日志
models.TaskProcessLog.objects.create(
task=task_obj,
status=11,
oper_user_id=user_id
)
response.status = True
response.message = "删除成功"
# 提交任务结果
elif oper_type == "upload_task_file":
file_obj = request.FILES.get('file')
if not file_obj:
response.status = False
response.message = "请选择需要上传的文件!"
else:
file_name = file_obj.name
extension_name = file_name.split(".")[-1]
task_obj = models.Task.objects.get(id=o_id)
file_save_name = ".".join([task_obj.name, extension_name])
if task_obj.status in [2, 4]:
file_save_path = "/".join(["statics", "task_excel", "result", file_save_name])
else: # task_obj.status = 6
file_save_path = "/".join(["statics", "task_excel", "publish", file_save_name])
with open(file_save_path, "wb") as f:
for chunk in file_obj.chunks():
f.write(chunk)
if task_obj.status in [2, 3, 4]:
status = 3
task_obj.status = 3
task_obj.task_result_file_path = file_save_path
message = "您的任务 [{task_name}] 编辑已经提交结果,请前去查看,并审核".format(
task_name=task_obj.name,
)
else:
status = 6
task_obj.status = 7
task_obj.publish_task_result_file_path = file_save_path
task_obj.is_check = False
task_obj.yichang_date = None
# 将提交的 excel 表格中的数据读出
book = xlrd.open_workbook(file_save_path)
sh = book.sheet_by_index(0)
excel_data = []
error_dict = {}
for row in range(2, sh.nrows):
line_data = []
for index, col in enumerate(range(sh.ncols)):
value = sh.cell_value(rowx=row, colx=col)
line_data.append(value)
if index == 0:
if value in error_dict:
error_dict[value]["repetition_row"].append(str(row + 1))
else:
error_dict[value] = {
'repetition_row': [str(row + 1)]
}
excel_data.append(line_data)
result_error = ["链接重复,请处理完重新上传"]
for k, v in error_dict.items():
if len(v["repetition_row"]) > 1:
result_error.append("重复链接 --> %s 重复行数: %s" % (k, ",".join(v["repetition_row"])))
if len(result_error) > 1:
response.status = False
response.message = "链接发生重复"
response.error = result_error
return JsonResponse(response.__dict__)
message = "您的任务 [{task_name}] 编辑已经提交结果,请前去查看,并审核".format(
task_name=task_obj.name,
)
AddMessage(request, task_obj.release_user.id, message)
task_obj.update_date = datetime.datetime.now()
task_obj.save()
# 编辑提交任务结果
models.TaskProcessLog.objects.create(
task=task_obj,
status=status,
oper_user_id=user_id
)
response.status = True
response.message = "添加成功"
# 发布者审核任务
elif oper_type == "shenhe":
task_obj = models.Task.objects.get(id=o_id)
task_obj.status = 5
response.status = True
response.message = "审核成功"
message = "任务 [{task_name}] 发布方已经审核通过".format(
task_name=task_obj.name,
)
AddMessage(request, task_obj.receive_user.id, message)
message = "任务 [{task_name}] 发布方已经审核通过, 请分配发布人员".format(
task_name=task_obj.name,
)
AddMessage(request, task_obj.release_user.guwen.id, message)
# 发布者审核任务日志
models.TaskProcessLog.objects.create(
task=task_obj,
status=5,
oper_user_id=user_id
)
task_obj.update_date = datetime.datetime.now()
task_obj.save()
# 发布者验收任务
elif oper_type == "yanshou":
task_obj = models.Task.objects.get(id=o_id)
task_obj.status = 10
task_obj.complete_date = datetime.datetime.now()
models.EditTaskManagement.objects.filter(task__task=task_obj).update(status=5)
response.status = True
response.message = "验收成功"
message = "任务 [{task_name}] 发布方已经审核通过".format(
task_name=task_obj.name,
)
AddMessage(request, task_obj.publish_user.id, message)
# 发布者验收任务日志
models.TaskProcessLog.objects.create(
task=task_obj,
status=10,
oper_user_id=user_id
)
task_obj.update_date = datetime.datetime.now()
task_obj.save()
# 发布者驳回任务
elif oper_type == "bohui":
remark = request.POST["remark"]
if remark:
task_obj = models.Task.objects.get(id=o_id)
task_obj.status = 4
response.status = True
response.message = "任务驳回成功"
message = "任务 [{task_name}] 被发布方驳回".format(
task_name=task_obj.name,
)
AddMessage(request, task_obj.receive_user.id, message)
# 发布者验收任务日志
models.TaskProcessLog.objects.create(
task=task_obj,
status=4,
oper_user_id=user_id,
remark=remark
)
task_obj.update_date = datetime.datetime.now()
task_obj.save()
objs = models.EditContentManagement.objects.filter(task=task_obj)
print(objs)
if objs:
objs.update(status=2)
objs[0].edittaskmanagement_set.update(status=1)
models.EditPublickTaskManagement.objects.filter(task__task=objs[0]).delete()
else:
response.status = False
response.message = "驳回理由不能为空"
# 提交异常
elif oper_type == "yichang":
file_obj = request.FILES.get('file')
if file_obj:
file_name = file_obj.name
extension_name = file_name.split(".")[-1]
task_obj = models.Task.objects.get(id=o_id)
file_save_name = ".".join([task_obj.name, extension_name])
file_save_path = "/".join(["statics", "task_excel", "yichang", file_save_name])
with open(file_save_path, "wb") as f:
for chunk in file_obj.chunks():
f.write(chunk)
obj = models.Task.objects.get(id=o_id)
obj.yichang = file_save_path
response.status = True
response.message = "提交成功"
message = "客户 [{username}] 对任务 [{task_name}] 提出异议,请查看".format(
task_name=obj.name,
username=obj.release_user.username
)
AddMessage(request, obj.release_user.guwen.id, message)
obj.update_date = datetime.datetime.now()
obj.save()
else:
response.status = False
response.message = "提交内容不能为空"
# 备注 pub
elif oper_type == 'beizhu_pub_marker':
print('o_id== ',o_id)
pub_remark = request.POST.get('pub_remark')
print('pub_remark- - ========--> ',pub_remark)
objs = models.Task.objects.filter(id=o_id)
objs.update(publish_remark=pub_remark)
response.status = True
response.message = '修改成功'
# 备注 obj
elif oper_type == 'beizhu_obj_marker':
obj_remark = request.POST.get('obj_remark')
print('obj_remark- - = = ============>',obj_remark)
objs = models.Task.objects.filter(id=o_id)
objs.update(remark=obj_remark)
response.status = True
response.message = '修改成功'
return JsonResponse(response.__dict__)
else:
release_platform_choices = models.Task.release_platform_choices
type_choices = models.Task.type_choices
# 添加
if oper_type == "create":
return render(request, 'wenda/my_task/my_task_modal_create.html', locals())
# # 修改
# elif oper_type == "update":
# user_profile_obj = models.UserProfile.objects.select_related("role").get(id=o_id)
#
# return render(request, 'myadmin/user_management/user_management_modal_update.html', locals())
# 删除
elif oper_type == "delete":
task_obj = models.Task.objects.get(id=o_id)
return render(request, 'wenda/my_task/my_task_modal_delete.html', locals())
# 编辑 上传任务结果的excel表格
elif oper_type == "upload_task_file":
task_obj = models.Task.objects.get(id=o_id)
if task_obj.status in [3, 7]:
update = True
return render(request, "wenda/my_task/my_task_modal_upload_task_file.html", locals())
# 发布方验收编辑上传的结果
elif oper_type == "yanshou":
task_obj = models.Task.objects.get(id=o_id)
return render(request, "wenda/my_task/my_task_modal_yanshou.html", locals())
# 发布方验收发布的结果
elif oper_type == "shenhe":
task_obj = models.Task.objects.get(id=o_id)
return render(request, "wenda/my_task/my_task_modal_shenhe.html", locals())
# 下载模板
elif oper_type == "download_template":
return render(request, "wenda/my_task/my_task_modal_download_template.html")
# 在线预览任务需求
elif oper_type == "online_preview_task_demand":
task_obj = models.Task.objects.get(id=o_id)
file_name_path = os.path.join(os.getcwd(), task_obj.task_demand_file_path)
print(file_name_path)
book = xlrd.open_workbook(file_name_path)
sh = book.sheet_by_index(0)
table_data = []
for row in range(2, sh.nrows):
line_data = []
for col in range(sh.ncols):
value = sh.cell_value(rowx=row, colx=col)
ctype = sh.cell(row, col).ctype # 表格的数据类型
if ctype == 2 and int(str(value).split(".")[1]) == 0:
value = int(value)
line_data.append(value)
table_data.append(line_data)
print(table_data)
return render(request, "wenda/my_task/my_task_modal_online_preview.html", locals())
# 在线预览任务结果
elif oper_type == "online_preview_task_result":
task_obj = models.Task.objects.get(id=o_id)
file_name_path = os.path.join(os.getcwd(), task_obj.task_result_file_path)
print(file_name_path)
book = xlrd.open_workbook(file_name_path)
sh = book.sheet_by_index(0)
table_data = []
for row in range(2, sh.nrows):
line_data = []
for col in range(sh.ncols):
value = sh.cell_value(rowx=row, colx=col)
ctype = sh.cell(row, col).ctype # 表格的数据类型
if ctype == 2 and int(str(value).split(".")[1]) == 0:
value = int(value)
line_data.append(value)
table_data.append(line_data)
print(table_data)
return render(request, "wenda/my_task/my_task_modal_online_preview.html", locals())
# 在线预览任务结果
elif oper_type == "online_preview_publish_task_result":
task_obj = models.Task.objects.get(id=o_id)
wenda_link_obj = models.WendaLink.objects.filter(task=task_obj)
if wenda_link_obj.count() == 0:
wenda_link_flag = False
elif wenda_link_obj.filter(status=1).count() > 0:
wenda_link_flag = False
else:
wenda_link_flag = True
file_name_path = os.path.join(os.getcwd(), task_obj.publish_task_result_file_path)
print(file_name_path)
book = xlrd.open_workbook(file_name_path)
sh = book.sheet_by_index(0)
table_data = []
for row in range(2, sh.nrows):
line_data = []
for col in range(sh.ncols):
value = sh.cell_value(rowx=row, colx=col)
ctype = sh.cell(row, col).ctype # 表格的数据类型
if ctype == 2 and int(str(value).split(".")[1]) == 0:
value = int(value)
line_data.append(value)
table_data.append(line_data)
print(table_data)
print("wenda_link_flag -->", wenda_link_flag)
return render(request, "wenda/my_task/my_task_modal_online_preview.html", locals())
# 发布方驳回编辑上传的结果
elif oper_type == "bohui":
task_obj = models.Task.objects.get(id=o_id)
return render(request, "wenda/my_task/my_task_modal_bohui.html", locals())
# 任务明细
elif oper_type == "task_detail":
role_id = models.UserProfile.objects.get(id=user_id).role.id
print(role_id)
task_process_log_objs = models.TaskProcessLog.objects.select_related('oper_user').filter(
task_id=o_id).order_by("-create_date")
return render(request, "wenda/my_task/my_task_modal_task_detail.html", locals())
# 医院信息
elif oper_type == "hospital_info":
user_obj = models.Task.objects.get(id=o_id).release_user
hospital_information_obj = models.HospitalInformation.objects.select_related('department').get(
user=user_obj)
# 问答内容方向
content_direction_list = [int(i) for i in hospital_information_obj.content_direction.split(",")]
content_direction = []
for i in hospital_information_obj.content_direction_choices:
if i[0] in content_direction_list:
content_direction.append(i[1])
content_direction = ",".join(content_direction)
if hospital_information_obj.content_direction_custom:
content_direction += ",%s" % hospital_information_obj.content_direction_custom
# 表达人称角色
reply_role_list = [int(i) for i in hospital_information_obj.reply_role.split(",")]
reply_role = []
for i in hospital_information_obj.reply_role_choices:
if i[0] in reply_role_list:
reply_role.append(i[1])
reply_role = ",".join(reply_role)
return render(request, 'wenda/task_list/task_list_modal_hospital_info.html', locals())
# 异常提交
elif oper_type == "yichang":
return render(request, "wenda/my_task/my_task_modal_yichang.html", locals())
# 查看异常
elif oper_type == "online_preview_yichang":
obj = models.Task.objects.get(id=o_id)
status_choices = models.WendaLink.status_choices
wendalink_objs = obj.wendalink_set.filter(status__gt=2)
return render(request, "wenda/my_task/my_task_modal_online_preview_yichang.html", locals())
# 备注 pub
elif oper_type == 'beizhu_pub_marker':
objs = models.Task.objects.filter(is_delete=False).filter(id=o_id)
pub_remark= objs[0].publish_remark
print('pub_remark - - -> ',pub_remark )
return render(request,'wenda/my_task/my_task_modal_beizhu_pub_marker.html',locals())
# 备注 obj
elif oper_type == 'beizhu_obj_marker':
objs = models.Task.objects.filter(is_delete=False).filter(id=o_id)
obj_remark = objs[0].remark
print('-obj_remark- -- > ',obj_remark)
return render(request, 'wenda/my_task/my_task_modal_beizhu_obj_marker.html', locals())
def keywords_top_set_oper(request, oper_type, o_id):
user_id = request.session["user_id"]
role_id = request.session.get("role_id")
response = pub.BaseResponse()
if request.method == "POST":
# 添加
if oper_type == "create":
keyword = request.POST.get("keyword")
client_user_id = request.POST.get("client_user_id", None)
keywords_type = request.POST.get('keywords_type')
print(client_user_id)
if client_user_id == "":
response.status = False
response.message = "请选择用户"
elif client_user_id is None:
client_user_id = user_id
if response.status and not keyword:
response.status = False
response.message = "请输入需要添加的关键词"
if response.status:
keyword_list = set(keyword.splitlines())
print('keyword_list - - -> ',keyword_list)
query = []
repeat_num = 0
for i in keyword_list:
if not i: # 如果为空 则跳过
continue
objs = models.KeywordsTopSet.objects.filter(
client_user_id=client_user_id,
keyword=i,
is_delete=False
)
if not objs:
query.append(models.KeywordsTopSet(
keyword=i,
client_user_id=client_user_id,
oper_user_id=user_id,
keywords_type=keywords_type
))
else:
obj = objs[0]
obj.keywords_type = keywords_type
obj.save()
repeat_num += 1
models.KeywordsTopSet.objects.bulk_create(query)
response.status = True
response.message = "成功添加 {num} 个关键词".format(num=len(query))
# 删除
elif oper_type == "delete":
obj = models.KeywordsTopSet.objects.get(id=o_id)
obj.is_delete = True
obj.save()
response.status = True
response.message = "删除成功"
# 客户重查
elif oper_type == "chongcha":
models.KeywordsTopInfo.objects.filter(keyword__client_user_id=o_id).delete()
models.KeywordsTopSet.objects.filter(client_user_id=o_id).update(status=1)
user_obj = models.UserProfile.objects.get(id=o_id)
user_obj.keywords_top_page_cover_excel_path = None
user_obj.keywords_top_page_cover_yingxiao_excel_path = None
user_obj.save()
response.status = True
response.message = "开始重查"
# 删除回复异常任务
elif oper_type == 'shanchuhuifuyichang':
objs = models.WendaRobotTask.objects.select_related('task__release_user').filter(
task__release_user_id=o_id,
status=20,
task__is_delete=False,
wenda_type=2
).delete()
# 清空关键词
elif oper_type == "clearKeywords":
print('o_id ========>',o_id)
models.KeywordsTopSet.objects.filter(client_user_id=o_id).delete()
obj = models.KeyWords_YouHua.objects.get(username_id=o_id)
obj.keywords_num = 0
obj.no_select_keywords_num = 0
obj.save()
response.status = True
response.message = "关键词清空成功"
# 老问答优先处理
elif oper_type == "laowendaYouxian":
# models.UserProfile.objects.all().update(laowenda_youxian=False)
models.UserProfile.objects.filter(id=o_id).update(laowenda_youxian=True)
response.status = True
response.message = "设置成功"
# 清除所有客户发布老问答优先
elif oper_type == "clearLaowendaYouxian":
models.UserProfile.objects.all().update(laowenda_youxian=False)
response.status = True
response.message = "清除所有客户发布老问答优先"
elif oper_type == "laowendaYouxianQuxiao":
models.UserProfile.objects.filter(id=o_id).update(laowenda_youxian=False)
response.status = True
response.message = "取消成功"
elif oper_type == "shengchengbaobiao":
print('o_id -->', o_id)
tasks.keywords_top_page_cover_excel.delay(o_id)
response.status = True
response.message = "报表生成中,请稍后查看"
# 下载关键词
elif oper_type == 'download_keyword':
if o_id:
print('o_id - - -- > 下载',o_id)
objs = models.KeywordsTopSet.objects.filter(
client_user_id=o_id,
is_delete=False,
)
data_list = []
file_name = ''
for obj in objs:
file_name = os.path.join("statics" +'/'+ "task_excel" +'/'+ "keywords_top_set"+'/'+ obj.client_user.username + ".xlsx")
keyword = obj.keyword
keywords_type = obj.get_keywords_type_display()
data_list.append({
'keyword': keyword,
'keywords_type': keywords_type
})
response.status = True
response.message = "导出成功"
response.download_url = file_name
print('下载路径----> ',file_name)
tasks.guanjianci_xiazai.delay(file_name, data_list)
# RedisOper.write_to_cache("keywords_top_set-init-data", None)
return JsonResponse(response.__dict__)
else:
# 添加
if oper_type == "create":
client_objs = models.UserProfile.objects.filter(is_delete=False, role_id__in=[5, 15]) # 5为普通用户，15为知道合伙人账号
keywords_type_choices = models.KeywordsTopSet.keywords_type_choices
return render(request, 'wenda/keywords_top_set/keywords_top_set_modal_create.html', locals())
# 删除
elif oper_type == "delete":
obj = models.KeywordsTopSet.objects.get(id=o_id)
return render(request, 'wenda/keywords_top_set/keywords_top_set_modal_delete.html', locals())
# 客户首页覆盖
elif oper_type == "client_cover":
objs = models.KeywordsTopInfo.objects.filter(keyword__client_user__is_delete=False).values(
'keyword__client_user',
'keyword__client_user__username',
'page_type'
).annotate(cover=Count("keyword__client_user"))
# ).annotate(cover=Count("keyword__client_user")).all().order_by('create_date')
# print(objs)
data = {}
for obj in objs:
client_user_id = obj["keyword__client_user"]
username = obj["keyword__client_user__username"]
page_type = obj["page_type"]
cover = obj["cover"]
print(page_type, cover)
# print(data)
if client_user_id in data:
data[client_user_id][page_type] = cover
if page_type == 1:
data[client_user_id]["total"] = cover + data[client_user_id][3]
else:
data[client_user_id]["total"] = cover + data[client_user_id][1]
else:
# 查询该用户添加了多少关键词数量
keywords_top_set_objs = models.KeywordsTopSet.objects.filter(client_user_id=client_user_id,
is_delete=False)
keywords_num = keywords_top_set_objs.count()
no_select_keywords_num = keywords_top_set_objs.filter(status=1).count()
if no_select_keywords_num > 0:
keywords_status = "查询中"
else:
keywords_status = "已查询"
keywords_top_page_cover_excel_path = keywords_top_set_objs[
0].client_user.keywords_top_page_cover_excel_path
keywords_top_page_cover_yingxiao_excel_path = keywords_top_set_objs[
0].client_user.keywords_top_page_cover_yingxiao_excel_path
pc_cover = 0
wap_cover = 0
if page_type == 1: # PC 端
pc_cover += cover
else:
wap_cover += cover
data[client_user_id] = {
# 1: pc_cover,
# 3: wap_cover,
page_type: cover,
"username": username,
"keywords_num": "{keywords_num} / {no_select_keywords_num}".format(keywords_num=keywords_num,
no_select_keywords_num=no_select_keywords_num),
"keywords_status": keywords_status,
"keywords_top_page_cover_excel_path": keywords_top_page_cover_excel_path,
"keywords_top_page_cover_yingxiao_excel_path": keywords_top_page_cover_yingxiao_excel_path
}
return render(request, 'wenda/keywords_top_set/keywords_top_set_modal_client_cover.html', locals())
# 清除所有客户发布老问答优先
elif oper_type == "clearLaowendaYouxian":
print('请求到 GET -=---------------')
return render(request,'wenda/keywords_top_set/keyword_top_set_modal_clearLaowendaYouxian.html',locals())
def edit_content_detail_oper(request, oper_type, o_id):
user_id = request.session["user_id"]
response = pub.BaseResponse()
if request.method == "POST":
# 人工完成单条已经存在任务
if oper_type == "rengong":
response = pub.BaseResponse()
content = request.POST.get("content")
print(request.POST)
obj = models.EditPublickTaskManagement.objects.select_related(
'run_task').get(id=o_id)
if not content:
response.status = False
response.message = "请填写答案"
if response.status and obj.content == content:
response.status = False
response.message = "答案无变化"
if response.status:
obj.status = 3
obj.content = content
wenda_robot_task_obj = models.WendaRobotTask.objects.get(
id=obj.run_task.id)
wenda_robot_task_obj.content = content
wenda_robot_task_obj.status = 6
models.RobotAccountLog.objects.create(
wenda_robot_task=wenda_robot_task_obj,
status=2,
phone_num="人工发布",
)
tongji_objs = models.TongjiKeywords.objects.filter(
run_task=wenda_robot_task_obj)
if tongji_objs:
tongji_objs.update(content=content,
is_update=False,
is_pause=False,
update_date=datetime.datetime.now())
else:
models.TongjiKeywords.objects.create(
task_id=wenda_robot_task_obj.task.id,
title=obj.title,
content=obj.content,
url=obj.url,
run_task=wenda_robot_task_obj,
)
obj.save()
wenda_robot_task_obj.save()
response.status = True
response.message = "人工完成成功"
# 添加人工完成当前不存在的任务
elif oper_type == "rengong_add":
response = pub.BaseResponse()
task_id = request.POST.get('task_id') # 任务id
edit_id = request.POST.get('edit_id') # 编辑id
zhidao_url = request.POST.get('zhidao_url') # 知道链接
title = request.POST.get('title') # 标题
content = request.POST.get('content') # 内容
task_obj = models.Task.objects.get(id=task_id)
wenda_robot_task_objs = models.WendaRobotTask.objects.filter(
task__release_user_id=task_obj.id, wenda_url=zhidao_url)
if wenda_robot_task_objs:
response.status = False
response.message = "链接已经存在"
if response.status:
wenda_robot_task_obj = models.WendaRobotTask.objects.create(
task_id=task_id,
title=title,
content=content,
wenda_url=zhidao_url,
release_platform=1,
wenda_type=2,
status=6,
next_date=datetime.datetime.now())
print(wenda_robot_task_obj.id)
edit_task_management_obj = models.EditTaskManagement.objects.filter(
task__task__id=task_id)
models.EditPublickTaskManagement.objects.create(
task_id=edit_task_management_obj[0].id,
url=zhidao_url,
title=title,
content=content,
status=3,
run_task=wenda_robot_task_obj)
models.TongjiKeywords.objects.create(
task_id=task_id,
title=title,
content=content,
url=zhidao_url,
run_task=wenda_robot_task_obj)
response.status = True
response.message = "添加成功"
# 渠道角色下载报表
elif oper_type == "download":
objs = models.EditPublickTaskManagement.objects.filter(
task__edit_user_id=user_id)
file_name = os.path.join("statics", "upload_files",
str(int(time.time() * 1000)) + ".xlsx")
data_list = []
for obj in objs:
data_list.append({
"title":
obj.title,
"content":
obj.content,
"url":
obj.url,
"status":
obj.get_status_display(),
"create_date":
obj.create_date.strftime("%Y-%m-%d %H:%M:%S"),
"update_date":
obj.update_date.strftime("%Y-%m-%d %H:%M:%S")
})
status_choices = models.EditPublickTaskManagement.status_choices
tasks.EditPublickTaskManagementWriteExcel.delay(
file_name, data_list)
response.status = True
response.message = "导出成功"
response.download_url = "/" + file_name
return JsonResponse(response.__dict__)
else:
# 查看历史修改数据
if oper_type == "edit_history":
objs = models.EditTaskLog.objects.filter(
edit_public_task_management_id=o_id)
return render(
request,
'wenda/edit_content_detail/edit_content_detail_modal_edit_history.html',
locals())
# 人工回答
elif oper_type == "rengong":
objs = models.EditPublickTaskManagement.objects.get(id=o_id)
return render(
request,
'wenda/edit_content_detail/edit_content_detail_modal_rengong.html',
locals())
# 添加人工完成当前不存在的任务
elif oper_type == "rengong_add":
task_objs = models.Task.objects.filter(release_platform=1,
wenda_type=2)
# 内部编辑
bianji_objs = models.UserProfile.objects.filter(role_id=13)
return render(
request,
'wenda/edit_content_detail/edit_content_detail_modal_rengong_add.html',
locals())
def kehu_cunhuo_xiaohao_tongji_oper(request, oper_type, o_id):
user_id = request.session["user_id"]
response = pub.BaseResponse()
if request.method == "POST":
# 添加
if oper_type == "create":
client_id = request.POST.get("client_id")
hezuo_num = request.POST.get("hezuo_num")
remark = request.POST.get("remark")
if not client_id:
response.status = False
response.message = "请选择用户"
if response.status and (not hezuo_num or not hezuo_num.isdigit()):
response.status = False
response.message = "合作数量格式不对"
if response.status:
models.KehuCunhuoXiaohaoTongji.objects.create(
client_id=client_id,
hezuo_num=hezuo_num,
shengyu_num=hezuo_num,
oper_user_id=user_id,
remark=remark)
response.status = True
response.message = "添加成功"
# 添加子项
elif oper_type == "add_child":
fabu_num = request.POST.get("fabu_num")
jifei_num = request.POST.get("jifei_num")
remark = request.POST.get("remark")
if not fabu_num or not fabu_num.isdigit():
response.status = False
response.message = "发布数量格式不对"
if response.status and (not jifei_num or not jifei_num.isdigit()):
response.status = False
response.message = "计费数量格式不对"
if response.status:
fabu_num = int(fabu_num)
jifei_num = int(jifei_num)
obj = models.KehuCunhuoXiaohaoTongji.objects.get(id=o_id)
obj.shengyu_num -= jifei_num
obj.save()
models.KehuCunhuoXiaohaoTongjiInfo.objects.create(
kehu_cunhuo_xiaohao_tongji=obj,
fabu_num=fabu_num,
jifei_num=jifei_num,
oper_user_id=user_id,
remark=remark)
response.status = True
response.message = "添加成功"
elif oper_type == "delete":
models.KehuCunhuoXiaohaoTongji.objects.filter(id=o_id).delete()
response.status = True
response.message = "删除成功"
return JsonResponse(response.__dict__)
else:
client_obj = models.UserProfile.objects.filter(role_id=5,
is_delete=False)
# 添加
if oper_type == "create":
return render(
request,
'myadmin/kehu_cunhuo_xiaohao_tongji/kehu_cunhuo_xiaohao_tongji_modal_create.html',
locals())
# 添加子项
elif oper_type == "add_child":
client_username = models.KehuCunhuoXiaohaoTongji.objects.select_related(
'client').get(id=o_id).client.username
return render(
request,
'myadmin/kehu_cunhuo_xiaohao_tongji/kehu_cunhuo_xiaohao_tongji_modal_add_child.html',
locals())
# 查看详情
elif oper_type == "search_detail":
obj = models.KehuCunhuoXiaohaoTongji.objects.select_related(
'client').get(id=o_id)
info_objs = obj.kehucunhuoxiaohaotongjiinfo_set.select_related(
'oper_user').all()
return render(
request,
'myadmin/kehu_cunhuo_xiaohao_tongji/kehu_cunhuo_xiaohao_tongji_modal_search_detail.html',
locals())
# 删除
elif oper_type == "delete":
obj = models.KehuCunhuoXiaohaoTongji.objects.select_related(
'client').get(id=o_id)
return render(
request,
'myadmin/kehu_cunhuo_xiaohao_tongji/kehu_cunhuo_xiaohao_tongji_modal_delete.html',
locals())
def big_data_oper(request, oper_type, o_id):
user_id = request.session["user_id"]
response = pub.BaseResponse()
if request.method == "POST":
# 添加
if oper_type == "create":
print(request.POST)
response.status = True
response.message = "添加成功"
form_obj = user.UserProfileCreateForm(request.POST)
if form_obj.is_valid():
form_obj.cleaned_data["oper_user_id"] = user_id
models.UserProfile.objects.create(**form_obj.cleaned_data)
else:
response.status = False
for i in ["username", "password", "role_id"]:
if i in form_obj.errors:
response.message = form_obj.errors[i]
break
# 修改
elif oper_type == "update":
response.status = True
response.message = "修改成功"
print(request.POST.get("id"))
shouyi_role_ids = [8, 9, 6]
uid = request.POST.get("id")
role_id = models.UserProfile.objects.select_related('role').get(id=uid).role.id
post_data = {}
for k, v in dict(request.POST).items():
post_data[k] = v[0]
print(post_data)
if role_id not in shouyi_role_ids:
post_data["xie_wenda_money"] = ''
post_data["fa_wenda_money"] = ''
form_obj = user.UserProfileUpdateForm(post_data)
if form_obj.is_valid():
if not form_obj.cleaned_data["password"]:
del form_obj.cleaned_data["password"]
print(form_obj.cleaned_data)
models.UserProfile.objects.filter(id=request.POST.get("id")).update(**form_obj.cleaned_data)
else:
response.status = False
print(form_obj.errors)
for i in ["username", "password", "role_id", "xie_wenda_money", "fa_wenda_money"]:
if i in form_obj.errors:
response.message = form_obj.errors[i]
break
# 删除用户
elif oper_type == "delete":
user_profile_obj = models.UserProfile.objects.get(id=o_id)
user_profile_obj.is_delete = True
user_profile_obj.save()
response.status = True
response.message = "删除成功"
# 充值
elif oper_type == "recharge":
balance = request.POST.get("balance")
zbalance = request.POST.get("zbalance")
remark = request.POST.get("remark")
if not balance or not balance.lstrip('-').isdigit():
response.status = False
response.message = "充值金额有误"
if zbalance and not zbalance.lstrip('-').isdigit():
response.status = False
response.message = "赠送金额有误"
elif not zbalance:
zbalance = 0
else:
zbalance = int(zbalance)
if response.status:
sum_moeny = int(balance) + int(zbalance)
user_profile_obj = models.UserProfile.objects.select_related("oper_user").get(id=o_id)
# .update(balance=F("balance") + int(balance))
user_profile_obj.balance += sum_moeny
user_profile_obj.save()
models.BalanceDetail.objects.create(
user_id=o_id,
account_type=1,
money=sum_moeny,
balance=balance,
zbalance=zbalance,
oper_user_id=user_id,
remark=remark
)
message = "【充值】{username} 为您充值 {moeny} 问答币 ".format(
username=user_profile_obj.guwen.username,
moeny=sum_moeny
)
AddMessage(request, user_profile_obj.id, message)
response.status = True
response.message = "充值成功"
return JsonResponse(response.__dict__)
else:
roles_dict = models.Role.objects.all().values("id", "name")
# 添加用户
if oper_type == "create":
guwen_objs = models.UserProfile.objects.filter(role_id=7, is_delete=False)
xiaoshou_objs = models.UserProfile.objects.filter(role_id=12, is_delete=False)
return render(request, 'myadmin/user_management/user_management_modal_create.html', locals())
# 修改用户
elif oper_type == "update":
user_profile_obj = models.UserProfile.objects.select_related("role").get(id=o_id)
guwen_objs = models.UserProfile.objects.filter(role_id=7, is_delete=False)
xiaoshou_objs = models.UserProfile.objects.filter(role_id=12, is_delete=False)
# 问答编辑、问答渠道、兼职发帖角色的id
print(user_profile_obj.role.id)
shouyi_role_ids = [8, 9, 6]
return render(request, 'myadmin/user_management/user_management_modal_update.html', locals())
# 删除用户
elif oper_type == "delete":
user_profile_obj = models.UserProfile.objects.get(id=o_id)
return render(request, 'myadmin/user_management/user_management_modal_delete.html', locals())
# 充值
elif oper_type == "recharge":
return render(request, 'myadmin/user_management/user_management_modal_recharge.html', locals())
def guwen_duijie_oper(request, oper_type, o_id):
role_id = request.session.get("role_id")
response = pub.BaseResponse()
print('user',o_id)
if request.method == "POST":
# 外层添加
if oper_type == "outer_create":
yonghuming_id = request.POST.get('yonghuming')
xiaoshou_id = request.POST.get('xiaoshou')
bianji_id = request.POST.get('bianji')
daozhang = request.POST.get('daozhang')
fugailiang = request.POST.get('fugailiang')
start_time = request.POST.get('start_time')
stop_time = request.POST.get('stop_time')
print('request--- -- - -> ',request.POST)
forms_obj = guwen_duijie_biao.OuterAddForm(request.POST)
if forms_obj.is_valid():
print('--',yonghuming_id,xiaoshou_id,bianji_id,daozhang,fugailiang,start_time,stop_time)
objs = models.YingXiaoGuWen_DuiJie.objects.filter(kehu_username_id=yonghuming_id)
if objs:
response.status = False
response.message = '添加失败,该用户已存在'
else:
models.YingXiaoGuWen_DuiJie.objects.create(
market_id=xiaoshou_id, # 销售
kehu_username_id=yonghuming_id, # 客户名
shiji_daozhang=daozhang, # 实际到账
fugai_count=fugailiang, # 覆盖总数
jifeishijian_start=start_time, # 计费开始
jifeishijian_stop=stop_time, # 结束计费
bianji_id=bianji_id # 编辑
)
response.status = True
response.message = "添加成功"
else:
print(forms_obj.errors)
response.status = False
response.message = '参数验证失败'
# 备注
elif oper_type =='beizhuy_oper':
panduan_xinwenda = request.POST.get('panduan_xinwenda')
xuanchuan = request.POST.get('xuanchuanyaoqiu')
shangwutong = request.POST.get('shangwutong')
wendageshu = request.POST.get('wendageshu')
obj = models.YingXiaoGuWen_DuiJie.objects.filter(id=o_id)
if obj:
if panduan_xinwenda and wendageshu:
obj.update(
shangwutong=shangwutong,
xuanchuanyaoqiu=xuanchuan,
wenda_geshu=wendageshu,
xinwenda=True,
)
else:
obj.update(
shangwutong=shangwutong,
xuanchuanyaoqiu=xuanchuan,
xinwenda=False,
)
response.status = True
response.message = '备注成功'
else:
response.status = False
response.message = '用户错误'
# 外层修改
elif oper_type == 'outer_update':
xiaoshou = request.POST.get('xiaoshou')
bianji = request.POST.get('bianji')
daozhang = request.POST.get('daozhang')
fugailiang = request.POST.get('fugailiang')
start_time = request.POST.get('start_time')
stop_time = request.POST.get('stop_time')
forms_obj = guwen_duijie_biao.OuterUpdateForm(request.POST)
print('=================', xiaoshou, bianji, daozhang, fugailiang, start_time, stop_time)
if forms_obj.is_valid():
print('验证通过')
obj = models.YingXiaoGuWen_DuiJie.objects.filter(id=o_id)
if obj:
obj.update(
market_id=xiaoshou, # 销售
shiji_daozhang=daozhang, # 实际到账
fugai_count=fugailiang, # 覆盖总数
jifeishijian_start=start_time, # 计费开始
jifeishijian_stop=stop_time, # 结束计费
bianji_id=bianji # 编辑
)
# obj.save()
print('obj- - - > ',obj[0].shiji_daozhang)
response.status = True
response.message = '修改成功'
else:
response.status = False
response.message = 'form验证失败'
# 外层删除
elif oper_type == 'outer_delete':
obj = models.YingXiaoGuWen_DuiJie.objects.get(id=o_id)
if obj:
obj.delete()
response.status = True
response.message = '删除成功'
else:
response.status = False
response.message = '删除失败'
# 内层添加
elif oper_type == 'inner_create':
print('内层添加')
obj = models.YingXiaoGuWen_DuiJie.objects.get(id=o_id)
print('obj --- > ',obj )
daozhang = request.POST.get('daozhang')
fugailiang = request.POST.get('fugailiang')
start_time = request.POST.get('start_time')
stop_time = request.POST.get('stop_time')
panduan_xinwenda = request.POST.get('panduan_xinwenda')
if panduan_xinwenda :
panduan_xinwenda = True
else:
panduan_xinwenda = False
data_temp = {}
forms_obj = guwen_duijie_biao.InnerCreateForm(request.POST)
if forms_obj.is_valid():
data_temp = {
"shiji_daozhang":daozhang,
"fugai_count":fugailiang,
"jifeishijian_start":start_time,
"jifeishijian_stop":stop_time,
"xinwenda":panduan_xinwenda,
"guishu":obj
}
models.YingXiaoGuWen_NeiBiao.objects.create(**data_temp)
response.status = True
response.message = '添加成功'
else:
response.status = False
response.message = 'form验证失败'
# 内层修改
elif oper_type == 'inner_update':
obj = models.YingXiaoGuWen_NeiBiao.objects.get(id=o_id)
if obj:
daozhang = request.POST.get('daozhang')
fugailiang = request.POST.get('fugailiang')
start_time = request.POST.get('start_time')
stop_time = request.POST.get('stop_time')
panduan_xinwenda = request.POST.get('panduan_xinwenda')
if panduan_xinwenda:
panduan_xinwenda = True
else:
panduan_xinwenda = False
print(panduan_xinwenda)
data_temp = {
'daozhang' : daozhang,
'fugailiang' : fugailiang ,
'start_time' : start_time ,
'stop_time' : stop_time,
'panduan_xinwenda' : panduan_xinwenda ,
}
print('到这了=======')
forms_obj = guwen_duijie_biao.InnerCreateForm(data_temp)
if forms_obj.is_valid():
print('验证成功')
cleant = forms_obj.cleaned_data
obj.shiji_daozhang = cleant['daozhang']
obj.jifeishijian_start = cleant['start_time']
obj.jifeishijian_stop = cleant['stop_time']
obj.fugai_count = cleant['fugailiang']
obj.xinwenda = cleant['panduan_xinwenda']
obj.save()
print('obj - -- > ',obj.xinwenda)
response.status = True
response.message = '修改成功'
else:
response.status = False
response.message = 'form验证失败'
else:
response.status = False
response.message = '修改失败'
# 内层删除
elif oper_type == 'inner_delete':
print('内层删除')
obj = models.YingXiaoGuWen_NeiBiao.objects.get(id=o_id)
if obj:
obj.delete()
response.status = True
response.message = '删除成功'
else:
response.status = False
response.message = '删除失败'
return JsonResponse(response.__dict__)
else:
# 外层添加
if oper_type == "outer_create":
client_objs = models.UserProfile.objects.filter(is_delete=False, role_id=5)
xiaoshous = models.UserProfile.objects.filter(is_delete=False,role_id=12)
bianjis = models.UserProfile.objects.filter(is_delete=False,role_id=6)
return render(request, 'wenda/guwen_Docking_table/guwen_duijie_outer/guwen_outer_create.html', locals())
# 备注按钮
elif oper_type == 'beizhu_botton':
objs = models.YingXiaoGuWen_DuiJie.objects.filter(id=o_id).values('shangwutong','fugai_count','xuanchuanyaoqiu','wenda_geshu','xinwenda')
shangwutong = objs[0]['shangwutong']
fugailiang = objs[0]['fugai_count']
xinwenda = objs[0]['xinwenda']
wenda_geshu = objs[0]['wenda_geshu']
xuanchuanyaoqiu = objs[0]['xuanchuanyaoqiu']
if wenda_geshu is None:
wenda_geshu = ''
if shangwutong is None:
shangwutong = ''
if xuanchuanyaoqiu is None:
xuanchuanyaoqiu = ''
print('---------->',shangwutong,fugailiang,xuanchuanyaoqiu,wenda_geshu,xinwenda)
return render(request, 'wenda/guwen_Docking_table/guwen_duijie_outer/guwen_beizhu_button.html', locals())
# 外层修改
elif oper_type == 'outer_update':
obj = models.YingXiaoGuWen_DuiJie.objects.filter(id=o_id)
if obj:
bianji_id = obj[0].bianji_id
xiaoshou_id = obj[0].market_id
bianjiming = obj[0].bianji.username
xiaoshouming = obj[0].market
shangwutong = obj[0].shangwutong
jifeishijian_start = obj[0].jifeishijian_start.strftime('%Y-%m-%d')
jifeishijian_stop = obj[0].jifeishijian_stop.strftime('%Y-%m-%d')
daozhang = obj[0].shiji_daozhang
fugai = obj[0].fugai_count
xuanchuan = obj[0].xuanchuanyaoqiu
wendageshu = obj[0].wenda_geshu
panduan_xinwenda = obj[0].xinwenda
print('role_id = = > ',bianji_id , xiaoshou_id)
xiaoshous = models.UserProfile.objects.filter(role_id=12)
print('xiaoshous = = = > ',xiaoshous[0])
bianjis = models.UserProfile.objects.filter(role_id=6)
return render(request, 'wenda/guwen_Docking_table/guwen_duijie_outer/guwen_outer_update.html',locals())
# 外层删除
elif oper_type == 'outer_delete':
obj = models.YingXiaoGuWen_DuiJie.objects.filter(id=o_id)
username = obj[0].kehu_username.username
print('o_id = == == => 1',o_id)
return render(request, 'wenda/guwen_Docking_table/guwen_duijie_outer/guwen_outer_delete.html',locals())
# 点开详情
elif oper_type == 'outer_xiangqing':
objs = models.YingXiaoGuWen_NeiBiao.objects.filter(guishu=o_id)
tr_html = ''
result_data = """
<table class="table table-bordered text-nowrap padding-left-50 margin-bottom-0" >
<tr><td>编号</td><td style="display:none;">ID</td><td>实际到账</td><td>覆盖总数</td><td>计费时间</td><td>停表时间</td><td>是否操作新问答</td><td>操作</td></tr>
{tr_html}
</table>
"""
for index,obj in enumerate(objs):
inner_id = obj.id
jifeistart = obj.jifeishijian_start
tingbiao = obj.jifeishijian_stop
fugai = obj.fugai_count
daozhang = obj.shiji_daozhang
panduan_xinwenda = obj.xinwenda
if panduan_xinwenda == True:
panduan_xinwenda = '是'
else:
panduan_xinwenda = '否'
tr_html += """
<tr>
<td>{index}</td>
<td>{daozhang}</td>
<td>{fugai}</td>
<td>{jifeistart}</td>
<td>{tingbiao}</td>
<td>{panduan_xinwenda}</td>
<td style="display:none">{inner_id}</td>
<td>
<a href="inner_update/{o_id}/" data-toggle='modal' data-target='#exampleFormModal'>修改</a>
----<a href="inner_delete/{o_id}/" data-toggle='modal' data-target='#exampleFormModal'>删除</a></td>
</tr>
""".format(index=index,inner_id=inner_id,fugai=fugai,daozhang=daozhang,
jifeistart=jifeistart,tingbiao=tingbiao,panduan_xinwenda=panduan_xinwenda,o_id=obj.id)
result_data = result_data.format(tr_html=tr_html)
return HttpResponse(result_data)
# 内层添加
elif oper_type == 'inner_create':
return render(request,'wenda/guwen_Docking_table/guwen_duijie_inner/guwen_duijie_inner_create.html',locals())
# 内层修改
elif oper_type == 'inner_update':
obj = models.YingXiaoGuWen_NeiBiao.objects.get(id=o_id)
daozhang = obj.shiji_daozhang
fugai = obj.fugai_count
jifei_start = obj.jifeishijian_start.strftime('%Y-%m-%d')
jifei_stop = obj.jifeishijian_stop.strftime('%Y-%m-%d')
panduan_xinwenda = obj.xinwenda
return render(request, 'wenda/guwen_Docking_table/guwen_duijie_inner/guwen_inner_update.html', locals())
# 内层删除
elif oper_type == 'inner_delete':
obj = models.YingXiaoGuWen_NeiBiao.objects.get(id=o_id)
username = obj.guishu.kehu_username
return render(request, 'wenda/guwen_Docking_table/guwen_duijie_inner/guwen_inner_delete.html', locals())
