def get_ent_info(user_id, appid=None):
print('---------# 获取用户 企业的 appid等信息-------------> ', user_id)
if appid:
ent_obj = models.Enterprise.objects.get(appid=appid)
name = ''
set_avator = ''
openid = ''
else:
if not user_id:
user_id = 1
user_obj = models.Userprofile.objects.get(id=user_id)
name = b64decode(user_obj.name)
set_avator = user_obj.set_avator
openid = user_obj.openid
ent_obj = models.Enterprise.objects.get(id=user_obj.enterprise_id)
data = {
'id': ent_obj.id,
'APPID': ent_obj.appid,
'APPSECRET': ent_obj.appsecret,
'access_token': ent_obj.access_token,
'create_datetime': ent_obj.create_datetime,
'user_name': name,
'user_set_avator': set_avator,
'openid': openid,
}
return data
def wechat_login(request):
response = Response.ResponseObj()
if request.method == "POST":
login_timestamp = request.POST.get('login_timestamp')
objs = models.UserProfile.objects.filter(
login_timestamp=login_timestamp)
if objs:
obj = objs[0]
inviter = 0
if obj.inviter:
inviter = 1
response.code = 200
role_obj = models.Role.objects.filter(id=obj.role_id)
data_list = []
for i in role_obj[0].permissions.all():
data_list.append(i.name)
response.data = {
'token': obj.token,
'id': obj.id,
'role_id': obj.role_id,
'number_child_users': obj.number_child_users,
'small_program_number': obj.small_program_number,
'role_name': obj.role.name,
'name': base64_encryption.b64decode(obj.name),
'head_portrait': obj.head_portrait,
'permissions_list': data_list,
'inviter': inviter
}
obj.last_login_datetime = datetime.datetime.now()
obj.save()
else:
response.code = 402
response.msg = "请求异常"
return JsonResponse(response.__dict__)
def goods_classify(request):
response = Response.ResponseObj()
user_id = request.GET.get('user_id')
if request.method == "GET":
forms_obj = SelectForm(request.GET)
if forms_obj.is_valid():
current_page = forms_obj.cleaned_data['current_page']
length = forms_obj.cleaned_data['length']
order = request.GET.get('order', '-create_datetime')
field_dict = {}
q = conditionCom(request, field_dict)
objs = models.GoodsClassify.objects.filter(
q, oper_user_id=user_id).order_by(order)
if length != 0:
start_line = (current_page - 1) * length
stop_line = start_line + length
objs = objs[start_line:stop_line]
data_count = objs.count()
data_list = []
for obj in objs:
is_good = False
if obj.goods_set.all():
is_good = True
data_list.append({
'id':
obj.id,
'goods_classify':
obj.goods_classify,
'oper_user_id':
obj.oper_user_id,
'oper_user':
b64decode(obj.oper_user.name),
'create_datetime':
obj.create_datetime.strftime('%Y-%m-%d %H:%M:%S'),
'is_good':
is_good,
})
response.code = 200
response.msg = '查询成功'
response.data = {
'ret_data': data_list,
'count': data_count,
}
response.note = {
'id': '商品分类ID',
'goods_classify': '商品分类名称',
'is_good': '该分类中是否有商品',
'create_datetime': '该商品分类创建时间',
}
else:
response.code = 301
response.msg = json.loads(forms_obj.errors.as_json())
else:
response.code = 402
response.msg = "请求异常"
return JsonResponse(response.__dict__)
def summary_message_reminder_celery(request):
response = Response.ResponseObj()
try:
user_objs = models.Userprofile.objects.exclude(
message_remind=4
)
for user_obj in user_objs:
if is_send_msg(user_obj.id): # 如果此用户可以发送 消息
objs = models.summary_message_reminder.objects.select_related('user').filter(
is_send=0,
user_id=user_obj.id,
)
title_str = ''
for obj in objs:
title_str += '《{}》--{}查看{}次\n'.format(
obj.title,
b64decode(obj.customer.name),
obj.select_num
)
obj.is_send = 1
obj.save()
if title_str: # 如果有文字发送
# 区分普通用户和 会员用户 会员用户发送查看人名称
if user_obj.overdue_date >= datetime.date.today():
msg = '有人看了您多篇文章\n\n{}\n查看点击下方【天眼】\n{}'.format(title_str, xiajiantou) # 充值用户显示所有文章标题
else:
msg = '有人看了您多篇文章\n\n赶快点击下方【天眼】查看\n{}'.format(xiajiantou) # 未充值
user_info = get_ent_info(user_obj.id)
weixin_objs = WeChatApi(user_info)
post_data = {
"touser": user_info.get('openid'),
"msgtype": "text",
"text": {
"content": msg
}
}
# 发送客服消息
post_data = bytes(json.dumps(post_data, ensure_ascii=False), encoding='utf-8')
weixin_objs.news_service(post_data)
user_obj.last_message_remind_time = datetime.datetime.now()
user_obj.save()
response.code = 200
else:
continue
except Exception as e:
msg = '警告:{}, \n错误:{}, \n时间:{}'.format(
'celery_汇总消息 发送---警告',
e,
datetime.datetime.today()
)
celery_error_warning(msg)
return JsonResponse(response.__dict__)
def my_business_card(request):
response = Response.ResponseObj()
user_id = request.GET.get('user_id')
if request.method == "GET":
obj = models.Userprofile.objects.get(id=user_id)
name = b64decode(obj.name)
if not obj.introduction:
introduction = '我是{}, 热烈欢迎来到我的名片'.format(name)
else:
introduction = obj.introduction
article_list = []
article_objs = models.Article.objects.filter(create_user_id=user_id).order_by('-create_datetime')
article_count = article_objs.count()
if article_count > 3:
article_objs = article_objs[: 3]
for article_obj in article_objs:
article_list.append({
'article_id': article_obj.id,
'title': article_obj.title,
'cover_img': article_obj.cover_img + '?imageView2/2/w/200',
})
goods_list = []
goods_objs = models.Goods.objects.filter(goods_classify__oper_user_id=user_id).order_by('-create_datetime')
goods_objs_count = goods_objs.count()
if goods_objs_count > 3:
goods_objs = goods_objs[:3]
for goods_obj in goods_objs:
goods_list.append({
'goods_id': goods_obj.id,
'cover_img': goods_obj.cover_img + '?imageView2/2/w/200',
'goods_name': goods_obj.goods_name,
'price': goods_obj.price,
})
data_list = {
'user_id': obj.id,
'introduction':introduction,
'user_name': name,
'set_avator': obj.set_avator + '?imageView2/2/w/100',
'article_list': article_list,
'goods_list': goods_list,
}
response.code = 200
response.msg = '查询成功'
response.data = data_list
else:
response.code = 402
response.msg = "请求异常"
return JsonResponse(response.__dict__)
def purchase_membership(objs):
renewal_list = []
for obj in objs:
renewal_list.append({
'consumption_type':
'充值会员',
'consumer_user':
b64decode(obj.create_user.name),
'create_date':
obj.create_date.strftime('%Y-%m-%d %H:%M:%S'),
'price':
obj.price,
'order_number':
obj.pay_order_no
})
return renewal_list
def withdrawal(objs):
withdrawal_amount_list = []
for obj in objs:
withdrawal_amount_list.append({
'consumption_type':
'提现',
'consumer_user':
b64decode(obj.user.name),
'create_date':
obj.create_date.strftime('%Y-%m-%d %H:%M:%S'),
'price':
obj.withdrawal_amount,
'order_number':
obj.dingdanhao
})
return withdrawal_amount_list
def user_oper(request, oper_type, o_id):
response = Response.ResponseObj()
user_id = request.GET.get('user_id')
if request.method == "POST":
# 修改用户角色 (即将废弃,被update取代)
if oper_type == 'update_role':
form_data = {
'role_id': request.POST.get('role_id'),
'user_id': user_id,
'o_id': o_id
}
form_obj = UpdateRoleForm(form_data)
if form_obj.is_valid():
role_id = form_obj.cleaned_data.get('role_id')
o_id = form_obj.cleaned_data.get('o_id')
models.UserProfile.objects.filter(id=o_id).update(
role_id=role_id)
response.code = 200
response.msg = '修改成功'
else:
response.code = 301
response.msg = json.loads(form_obj.errors.as_json())
elif oper_type == "update":
# 获取需要修改的信息
form_data = {
'o_id': o_id,
'role_id': request.POST.get('role_id'), # 角色id
'company_name': request.POST.get('company_name'), # 公司名称
'remark': request.POST.get('remark'), # 备注信息
'small_program_number':
request.POST.get('small_program_number'), # 小程序数量
'number_child_users':
request.POST.get('number_child_users'), # 子账号数量
}
forms_obj = UpdateForm(form_data)
if forms_obj.is_valid():
o_id = forms_obj.cleaned_data['o_id']
role_id = forms_obj.cleaned_data['role_id'] # 角色id
company_name = forms_obj.cleaned_data['company_name'] # 公司名称
remark = forms_obj.cleaned_data['remark'] # 备注信息
small_program_number = forms_obj.cleaned_data[
'small_program_number'] # 小程序数量
number_child_users = forms_obj.cleaned_data[
'number_child_users'] # 子账号数量
# 查询数据库 用户id
objs = models.UserProfile.objects.filter(id=o_id)
# 更新 数据
if objs:
objs.update(
role_id=role_id,
company_name=company_name,
remark=remark,
small_program_number=small_program_number,
number_child_users=number_child_users,
)
response.code = 200
response.msg = "修改成功"
else:
response.code = 303
response.msg = '不存在的数据'
else:
response.code = 301
response.msg = json.loads(forms_obj.errors.as_json())
# 转接 用户所有信息
elif oper_type == 'transfer_all_user_information':
cancel_transfer = request.POST.get('cancel_transfer') # 拒绝交接
form_data = {
'user_id': user_id,
'o_id': o_id,
# 'transfer_template_id': request.POST.get('transfer_template_id'),
}
transfer_objs = models.Transfer.objects.filter(
speak_to_people_id=user_id,
by_connecting_people_id=o_id,
whether_transfer_successful=2).order_by('-create_datetime')
if transfer_objs:
transfer_obj = transfer_objs[0]
if cancel_transfer:
transfer_obj.whether_transfer_successful = 5
code = 200
msg = '已拒绝交接'
else:
form_obj = TransferAllUserInformation(form_data)
if form_obj.is_valid():
o_id = form_obj.cleaned_data.get('o_id')
user_id = form_obj.cleaned_data.get('user_id')
applet_objs = models.ClientApplet.objects.filter(
user_id=user_id) # 小程序
models.CustomerOfficialNumber.objects.filter(
user_id=user_id).update(user_id=o_id) # 小程序版本
applet_objs.update(user_id=o_id)
models.TemplateClass.objects.filter(
create_user_id=user_id).update(
create_user_id=o_id) # 模板分类表
models.Template.objects.filter(
create_user_id=user_id).update(
create_user_id=o_id) # 模板表
models.PhotoLibraryGroup.objects.filter(
create_user_id=user_id).update(
create_user_id=o_id) # 图片分类
models.PhotoLibrary.objects.filter(
create_user_id=user_id).update(
create_user_id=o_id) # 图片
models.PageGroup.objects.filter(
create_user_id=user_id).update(
create_user_id=o_id) # 页面分组表
models.Page.objects.filter(
create_user_id=user_id).update(
create_user_id=o_id) # 页面表
models.CompomentLibraryClass.objects.filter(
create_user_id=user_id).update(
create_user_id=o_id) # 组件库分类
models.CompomentLibrary.objects.filter(
create_user_id=user_id).update(
create_user_id=o_id) # 组件库
code = 200
msg = '转接成功'
transfer_obj.whether_transfer_successful = 4
else:
code = 301
msg = json.loads(form_obj.errors.as_json())
transfer_obj.save()
else:
code = 301
msg = '已过期, 请重新获取二维码'
response.code = code
response.msg = msg
# 是否接受 团队邀请
elif oper_type == 'accept_team_invitationss':
new_user_id = request.POST.get('new_user_id') # 受邀请人ID
parent_id = request.POST.get('parent_id') # 父级用户ID
timestamp = request.POST.get('time_stamp') # 时间戳
refused_invite = request.POST.get('refused_invite') # 拒绝邀请
objs = models.InviteTheChild.objects.filter(
parent_id=parent_id, child_id=new_user_id,
timestamp=timestamp).order_by('-create_datetime')
obj = objs[0]
if objs:
if refused_invite:
obj.whether_transfer_successful = 5 # 拒绝
msg = '已拒绝'
else:
user_is_exists = request.POST.get(
'user_is_exists') # 是否已有用户 如果有 则删除所有数据
models.UserProfile.objects.filter(id=new_user_id).update(
inviter_id=parent_id)
if user_is_exists: # 删除所有数据
models.CustomerOfficialNumber.objects.filter(
user_id=new_user_id).delete()
models.ClientApplet.objects.filter(
user_id=new_user_id).delete()
models.PhotoLibrary.objects.filter(
create_user_id=new_user_id).delete()
models.PhotoLibraryGroup.objects.filter(
create_user_id=new_user_id).delete()
models.Page.objects.filter(
create_user_id=new_user_id).delete()
models.PageGroup.objects.filter(
create_user_id=new_user_id).delete()
models.Template.objects.filter(
create_user_id=new_user_id).delete()
models.TemplateClass.objects.filter(
create_user_id=new_user_id).delete()
models.CompomentLibrary.objects.filter(
create_user_id=new_user_id).delete()
models.CompomentLibraryClass.objects.filter(
create_user_id=new_user_id).delete()
msg = '已接受'
obj.whether_transfer_successful = 4
obj.save()
code = 200
else:
code = 301
msg = '已过期, 请重新扫描二维码'
response.code = code
response.msg = msg
# 删除团队成员
elif oper_type == 'delete_team_members':
form_data = {'o_id': o_id, 'user_id': user_id}
form_obj = DeleteTeamMembers(form_data)
if form_obj.is_valid():
user_id = form_obj.cleaned_data.get('user_id')
o_id = form_obj.cleaned_data.get('o_id')
models.UserProfile.objects.filter(id=o_id).update(
inviter_id=None)
response.code = 200
response.msg = '删除成功'
else:
response.code = 301
response.msg = json.loads(form_obj.errors.as_json())
# 修改企业名称
elif oper_type == 'modify_enterprise_name':
template_id = request.POST.get('template_id')
enterprise_name = request.POST.get('enterprise_name')
models.Template.objects.filter(id=template_id).update(
enterprise_name=enterprise_name)
response.code = 200
response.msg = '修改成功'
else:
# 获取团队成员
if oper_type == 'acquire_team_members':
forms_obj = SelectForm(request.GET)
if forms_obj.is_valid():
current_page = forms_obj.cleaned_data['current_page']
length = forms_obj.cleaned_data['length']
order = request.GET.get('order', '-create_datetime')
field_dict = {
'id': '',
'name': '__contains',
}
q = conditionCom(request, field_dict)
objs = models.UserProfile.objects.filter(
q, inviter_id=user_id).order_by(order)
count = objs.count()
if length != 0:
start_line = (current_page - 1) * length
stop_line = start_line + length
objs = objs[start_line:stop_line]
ret_data = []
for obj in objs:
ret_data.append({
'id':
obj.id,
'name':
base64_encryption.b64decode(obj.name),
'role_id':
obj.role_id,
'role_name':
obj.role.name,
'head_portrait':
obj.head_portrait,
'sex_id':
obj.sex,
'sex':
obj.get_sex_display(),
'create_datetime':
obj.create_datetime.strftime('%Y-%m-%d %H:%M:%S'),
})
# 查询成功 返回200 状态码
response.code = 200
response.msg = '查询成功'
response.data = {
'ret_data': ret_data,
'data_count': count,
}
else:
response.code = 301
response.msg = json.loads(forms_obj.errors.as_json())
else:
response.code = 402
response.msg = '请求异常'
return JsonResponse(response.__dict__)
def weixin_pay(request, oper_type, o_id):
response = Response.ResponseObj()
weixin_pay_api_obj = weixin_pay_api() # 实例 公共函数
user_id = request.GET.get('user_id')
if request.method == 'POST':
# 预支付
if oper_type == 'yuZhiFu':
pay_type = request.GET.get('pay_type') # 支付方式 余额支付/微信支付
try:
fee_objs = models.renewal_management.objects.filter(id=o_id)
if fee_objs:
models.renewal_log.objects.filter(
create_user_id=user_id,
isSuccess=0).delete() # 删除未付款的订单
userObjs = models.Userprofile.objects.filter(id=user_id)
user_obj = userObjs[0]
fee_obj = fee_objs[0]
price = int(fee_obj.price) # 支付钱数
get_the_length_display = fee_obj.get_the_length_display(
) # 续费时长 (几个月/几年)
renewal_number_days = fee_obj.renewal_number_days # 续费天数
overdue_date = (
user_obj.overdue_date +
datetime.timedelta(days=renewal_number_days)
) # 续费后 到期时间
dingdanhao = weixin_pay_api_obj.shengcheng_dingdanhao(
) # 订单号
order_objs = models.renewal_log.objects.filter(
pay_order_no=dingdanhao) # 查询订单日志
if not order_objs:
# 余额支付
if pay_type == 'balance_payment':
# 创建订单
ren_obj = models.renewal_log.objects.create(
pay_order_no=dingdanhao,
the_length=get_the_length_display, # 续费时长
renewal_number_days=renewal_number_days,
create_user_id=user_id,
price=price,
original_price=fee_obj.original_price, # 原价
overdue_date=overdue_date,
status=2,
)
if float(user_obj.make_money) >= price:
userObjs.update(make_money=F('make_money') -
price)
# 修改到期时间
userObjs.update(
overdue_date=overdue_date,
vip_type=2, # 更改为高级会员
)
ren_obj.isSuccess = 1
response.code = 200
response.msg = '支付成功'
else:
ren_obj.isSuccess = 0
response.code = 301
response.msg = '余额不足'
ren_obj.save()
# 微信支付
else:
data = get_ent_info(user_id) # 获取用户信息
weixin_obj = WeChatApi(data) # 获取用户公众号信息
appid = weixin_obj.APPID # appid
APPSECRET = weixin_obj.APPSECRET # 商户号
data = {
'total_fee': price, # 金额(分 为单位)
'openid': user_obj.openid, # 微信用户唯一标识
'appid': appid, # appid
'dingdanhao': dingdanhao # 生成订单号
}
# price = price * 100 # 单位 分
result = weixin_pay_api_obj.yuzhifu(data) # 预支付
return_code = result.get('return_code')
return_msg = result.get('return_msg')
prepay_id = result.get('prepay_id')['prepay_id']
if return_code == 'SUCCESS': # 判断预支付返回参数 是否正确
models.renewal_log.objects.create(
pay_order_no=dingdanhao,
the_length=get_the_length_display, # 续费时长
renewal_number_days=renewal_number_days,
create_user_id=user_id,
price=price,
original_price=fee_obj.
original_price, # 原价
overdue_date=overdue_date,
status=1)
# 返回数据
data_dict = {
'appId':
appid,
'timeStamp':
int(time.time()),
'nonceStr':
weixin_pay_api_obj.generateRandomStamping(
),
'package':
'prepay_id=' + prepay_id,
'signType':
'MD5'
}
SHANGHUKEY = weixin_pay_api_obj.SHANGHUKEY
stringSignTemp = weixin_pay_api_obj.shengchengsign(
data_dict, SHANGHUKEY)
data_dict['paySign'] = weixin_pay_api_obj.md5(
stringSignTemp).upper() # upper转换为大写
response.data = data_dict
response.code = 200
response.msg = '预支付请求成功'
else:
response.code = 301
response.msg = '支付失败, 原因:{}'.format(return_msg)
else:
response.code = 301
response.msg = '请选择一项会员'
except Exception as e:
if pay_type == 'balance_payment':
text = '余额支付'
else:
text = '微信支付'
msg = '警告:{}, \n错误:{}, \n时间:{}'.format(
'用户支付报错--->用户ID{}-充值ID{}-充值方式'.format(user_id, o_id, text),
e, datetime.datetime.today())
celery_error_warning(msg)
# 提现功能
elif oper_type == 'withdrawal':
try:
form_data = {
'user_id': user_id,
'withdrawal_amount':
request.GET.get('withdrawal_amount'), # 提现金额
}
form_objs = WithdrawalForm(form_data)
if form_objs.is_valid():
data = get_ent_info(user_id) # 获取用户信息
weixin_obj = WeChatApi(data) # 获取用户公众号信息
appid = weixin_obj.APPID # appid
APPSECRET = weixin_obj.APPSECRET # 商户号
print(request.META)
# 当前路径
os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# 获取访问用户IP
if request.META.get('HTTP_X_FORWARDED_FOR'):
ip = request.META['HTTP_X_FORWARDED_FOR']
else:
ip = request.META['REMOTE_ADDR']
user_obj, withdrawal_amount = form_objs.cleaned_data.get(
'withdrawal_amount')
dingdanhao = weixin_pay_api_obj.shengcheng_dingdanhao()
data = {
'withdrawal_amount': withdrawal_amount, # 提现金额
'dingdanhao': dingdanhao, # 订单号
'appid': appid, # appid
'openid': user_obj.openid, # openid
'user_id': user_id, # user_id
'user_name': b64decode(user_obj.name),
'make_money': user_obj.make_money,
'ip': ip,
}
response_data = weixin_pay_api_obj.withdrawal(data) # 提现
code = response_data.get('code')
return_msg = response_data.get('return_msg')
make_money = float(user_obj.make_money) # 用户待提钱数
withdrawal_amount = withdrawal_amount # 用户提现钱数
withdrawal_after = make_money - withdrawal_amount # 待提钱数减去提现钱数
if code == 200:
is_success = 1 # 是否提现成功
response.code = 200
# 减去提现的钱数
user_money_obj = models.Userprofile.objects.get(
id=user_id)
user_money_obj.make_money = F(
'make_money') - withdrawal_amount
user_money_obj.save()
else:
is_success = 0
response.code = 301
models.withdrawal_log.objects.create( # 创建提现记录
user_id=user_id,
withdrawal_befor=make_money, # 提现前 待提钱数
withdrawal_amount=withdrawal_amount, # 提现金额
withdrawal_after=withdrawal_after, # 提现后 待提钱数
is_success=is_success,
wechat_returns_data=return_msg,
dingdanhao=dingdanhao)
response.msg = return_msg
else:
response.code = 301
response.msg = json.loads(form_objs.errors.as_json())
except Exception as e:
msg = '警告:{}, \n错误:{}, \n时间:{}'.format(
'用户提现报错--->用户ID{}, 提现钱数{} '.format(
user_id, request.GET.get('withdrawal_amount')), e,
datetime.datetime.today())
celery_error_warning(msg)
else:
# 提现记录
if oper_type == 'withdrawal_record':
form_objs = SelectForm(request.GET)
if form_objs.is_valid():
current_page = form_objs.cleaned_data['current_page']
length = form_objs.cleaned_data['length']
user_obj = models.Userprofile.objects.get(id=user_id)
objs = models.withdrawal_log.objects.filter(
user_id=user_id).order_by('-create_date')
withdrawal_amount_sum_obj = objs.filter(
is_success=1).aggregate(nums=Sum('withdrawal_amount'))
data_count = objs.count()
if length != 0:
start_line = (current_page - 1) * length
stop_line = start_line + length
objs = objs[start_line:stop_line]
data_list = []
for obj in objs:
data_list.append({
'dingdanhao':
obj.dingdanhao, # 提现订单号
'withdrawal_amount':
obj.withdrawal_amount, # 提现金额
'create_date':
obj.create_date.strftime('%Y-%m-%d %H:%M:%S'), # 提现时间
'is_success':
obj.is_success, # 提现是否成功
'wechat_returns_data':
obj.wechat_returns_data, # 失败原因
})
withdrawal_amount_sum = 0
if withdrawal_amount_sum_obj:
withdrawal_amount_sum = withdrawal_amount_sum_obj.get(
'nums')
response.code = 200
response.msg = '查询成功'
response.data = {
'data_count': data_count,
'withdrawal_amount_sum': withdrawal_amount_sum,
'cumulative_amount': user_obj.cumulative_amount,
'make_money': user_obj.make_money,
'data_list': data_list,
}
response.note = {
'withdrawal_amount_sum': '已提现钱数',
'cumulative_amount': '累计现金',
'make_money': '当前待提余额',
'data_list': {
'dingdanhao': '提现订单号',
'withdrawal_amount': '提现金额',
'create_date': '提现时间',
'is_success': '提现是否成功',
'wechat_returns_data': '失败原因'
}
}
else:
response.code = 301
response.msg = json.loads(form_objs.errors.as_json())
# 支付记录
elif oper_type == 'payment_records':
form_objs = SelectForm(request.GET)
if form_objs.is_valid():
current_page = form_objs.cleaned_data['current_page']
length = form_objs.cleaned_data['length']
# user_obj = models.Userprofile.objects.get(id=user_id)
objs = models.renewal_log.objects.filter(
create_user_id=user_id,
isSuccess=1).order_by('-create_date')
data_count = objs.count()
if length != 0:
start_line = (current_page - 1) * length
stop_line = start_line + length
objs = objs[start_line:stop_line]
data_list = []
for obj in objs:
data_list.append({
'pay_order_no':
obj.pay_order_no, # 订单号
'price':
obj.price, # 价钱
'status_id':
obj.status, # 支付方式ID
'status':
obj.get_status_display(), # 支付方式
'the_length':
obj.the_length, # 时长
# 'overdue_date':obj.overdue_date.strftime('%Y-%m-%d %H:%M:%S'), # 过期时间
'create_date':
obj.create_date.strftime('%Y-%m-%d %H:%M:%S'), # 创建时间
})
response.code = 200
response.msg = '查询成功'
response.data = {
'data_count': data_count,
'data_list': data_list,
}
response.note = {
'data_list': {
'pay_order_no': '订单号',
'price': '支付金额',
'the_length': '时长',
'create_date': '下单时间',
}
}
else:
response.code = 301
response.msg = json.loads(form_objs.errors.as_json())
else:
response.code = 402
response.msg = '请求异常'
return JsonResponse(response.__dict__)
def day_eye_data(request):
response = Response.ResponseObj()
try:
for i in models.Userprofile.objects.all():
user_id = i.id
objs = models.SelectArticleLog.objects.filter(
inviter_id=user_id
).select_related(
'customer'
).values(
'customer_id', 'customer__name', 'customer__set_avator'
).annotate(Count('customer_id')).exclude(customer_id__isnull=True).distinct()
# 返回的数据
data_list = []
for obj in objs:
customer_id = obj.get('customer_id')
customer__name = ''
if obj.get('customer__name'):
customer__name = b64decode(obj.get('customer__name'))
article_objs = models.SelectArticleLog.objects.filter(
customer_id=customer_id,
inviter_id=user_id,
)
article_count = article_objs.values(
'customer_id',
'article_id',
'inviter_id'
).distinct().count()
data_list.append({
'customer_id': customer_id,
'customer__name': customer__name,
'customer__set_avator': obj.get('customer__set_avator'),
'text': '看了{}篇文章, 总共查看{}次'.format(
article_count, # 总共查看几篇文章
obj.get('customer_id__count') # # 总共查看几次
),
'status': 1, # 代表文章
'create_date': article_objs.order_by('-create_datetime')[0].create_datetime.strftime('%Y-%m-%d %H:%M:%S') # 代表文章
})
objs = models.customer_look_goods_log.objects.filter(
user_id=user_id
).select_related(
'customer'
).values(
'customer_id', 'customer__name', 'customer__set_avator'
).annotate(Count('customer_id')).exclude(customer_id__isnull=True).distinct()
for obj in objs:
customer_id = obj.get('customer_id')
customer__name = ''
if obj.get('customer__name'):
customer__name = b64decode(obj.get('customer__name'))
goods_objs = models.customer_look_goods_log.objects.filter(
customer_id=customer_id,
user_id=user_id,
)
goods_count = goods_objs.values(
'customer_id',
'goods_id',
'user_id',
).distinct().count()
data_list.append({
'customer_id': customer_id,
'customer__name': customer__name,
'customer__set_avator': obj.get('customer__set_avator'),
'text': '看了{}件商品, 总共查看{}次'.format(
goods_count, # 总共查看几篇文章
obj.get('customer_id__count') # # 总共查看几次
),
'status': 2, # 代表商品
'create_date': goods_objs.order_by('-create_datetime')[0].create_datetime.strftime('%Y-%m-%d %H:%M:%S') # 代表文章
})
for i in data_list: # 加入数据库
eye_objs = models.day_eye_celery.objects.filter(
user_id=user_id,
status=i.get('status'),
customer_id=i.get('customer_id'),
)
create_date = i.get('create_date')
if eye_objs:
if eye_objs[0].last_click_customer:
# 如果 查看时间 大于 用户最后一次点击 该客户时间 为新消息
if datetime.datetime.strptime(create_date, '%Y-%m-%d %H:%M:%S') >= eye_objs[0].last_click_customer:
is_new_msg = True
else:
is_new_msg = eye_objs[0].is_new_msg
else:
is_new_msg = True
eye_objs.update(
text = i.get('text'),
create_date = create_date,
is_new_msg = is_new_msg,
)
else:
models.day_eye_celery.objects.create(
user_id=user_id,
status=i.get('status'),
customer_id=i.get('customer_id'),
text=i.get('text'),
create_date=create_date,
is_new_msg=True, # 新查看消息提示
)
response.code = 200
except Exception as e:
msg = '警告:{}, \n错误:{}, \n时间:{}'.format(
'celery_天眼功能统计数据报错 warning警告！！！',
e,
datetime.datetime.today()
)
celery_error_warning(msg)
return JsonResponse(response.__dict__)
def view_log_oper(request, oper_type):
response = Response.ResponseObj()
user_id = request.GET.get('user_id')
if request.method == "POST":
pass
else:
# 查询日志
if oper_type == "get_view_data":
form_objs = SelectForm(request.GET)
if form_objs.is_valid():
current_page = form_objs.cleaned_data['current_page']
length = form_objs.cleaned_data['length']
order = request.GET.get('order', '-create_datetime')
field_dict = {
'id': '',
'client_applet_id': '',
'source': '',
}
q = conditionCom(request, field_dict)
objs = models.ViewCustomerSmallApplet.objects.select_related(
'customer').filter(q).values(
'customer_id', 'customer__name', 'source',
'customer__phone',
'customer__ip_address').annotate(Count('id'))
if length != 0:
start_line = (current_page - 1) * length
stop_line = start_line + length
objs = objs[start_line:stop_line]
ret_data = []
for obj in objs:
customer_id = obj.get('customer_id')
source = obj.get('source')
objs_detail = models.ViewCustomerSmallApplet.objects.filter(
customer_id=customer_id,
source=source).order_by('create_datetime')
ret_data.append({
'intention_degree':
0, # 意向度
'access_permissions':
'', # 访问权限
'visitors_id':
customer_id, # 访客ID
'visitors':
b64decode(obj.get('customer__name')), # 访客
'terminal':
obj.get('customer__ip_address'), # 终端
'mobile_phone':
obj.get('customer__phone'), # 手机
'source_id':
source, # 来源ID
'source':
objs_detail[0].get_source_display(), # 来源
'first_visit_to':
objs_detail[0].create_datetime.strftime(
'%Y-%m-%d %H:%M:%S'), # 首次访问时间
'last_active_time':
objs_detail.order_by('-create_datetime')
[0].create_datetime.strftime(
'%Y-%m-%d %H:%M:%S'), # 最近活跃时间
})
response.code = 200
response.msg = '查询成功'
response.data = {'count': '', 'ret_data': ret_data}
response.note = {
'intention_degree': '意向度',
'access_permissions': '访问权限',
'visitors_id': '访客ID',
'visitors': '访客',
'terminal': '终端',
'mobile_phone': '手机',
'source_id': '来源ID',
'source': '来源',
'first_visit_to': '首次访问时间',
'last_active_time': '最近活跃时间',
}
else:
response.code = 301
response.msg = form_objs.errors.as_json()
else:
response.code = 402
response.msg = "请求异常"
return JsonResponse(response.__dict__)
def wechat(request):
rc = redis.StrictRedis(host='redis_host',
port=6379,
db=7,
decode_responses=True)
signature = request.GET.get("signature")
timestamp = request.GET.get("timestamp")
nonce = request.GET.get("nonce")
echostr = request.GET.get("echostr")
appid = request.GET.get("appid")
# 该值做消息解密使用，当前未使用加密模式，参考微信开发文档 https://mp.weixin.qq.com/wiki?t=resource/res_main&id=mp1421135319
# EncodingAESKey = 'LFYzOBp42g5kwgSUWhGC9uRugSmpyetKfAsJa5FdFHX'
check_result = checkSignature(timestamp, nonce, signature)
print('check_result -->', check_result)
if check_result:
if request.method == "GET":
return HttpResponse(echostr)
else:
body_text = str(request.body, encoding="utf8")
print('body_text -->', body_text)
# 使用minidom解析器打开 XML 文档
DOMTree = xml.dom.minidom.parseString(body_text)
collection = DOMTree.documentElement
# 用户的 openid
openid = collection.getElementsByTagName(
"FromUserName")[0].childNodes[0].data
is_timestamp = rc.get(
openid) # 查询redis 这个用户 是否回调过 如果有 判断时间戳是否一致 有效期 30秒
if is_timestamp and is_timestamp == timestamp: # 重复回调
return HttpResponse('')
rc.set(openid, timestamp) # 插入数据
rc.expire(openid, 30) # 设置过期时间 30 秒
# 事件类型
msg_type = collection.getElementsByTagName(
"MsgType")[0].childNodes[0].data
# 发送消息时候时间戳
CreateTime = collection.getElementsByTagName(
"CreateTime")[0].childNodes[0].data
ent_obj = models.Enterprise.objects.get(appid=appid) # 获取该公众号信息
data = {
'id': ent_obj.id,
'APPID': ent_obj.appid,
'APPSECRET': ent_obj.appsecret,
'access_token': ent_obj.access_token,
'create_datetime': ent_obj.create_datetime,
}
inviter_user_id = ''
# 事件类型 关注/取关
if msg_type == 'event':
event = collection.getElementsByTagName(
"Event")[0].childNodes[0].data
# 扫描带参数的二维码
if event in ["subscribe", "SCAN"]:
# subscribe = 首次关注
# SCAN = 已关注
# 事件 Key 值
models.Customer.objects.filter(openid=openid).update(
subscribe=1) # 更改客户 是否关注
if collection.getElementsByTagName(
"EventKey")[0].childNodes:
event_key = collection.getElementsByTagName(
"EventKey")[0].childNodes[0].data
if event == "subscribe":
event_key = event_key.split("qrscene_")[-1]
event_key = json.loads(event_key)
inviter_user_id = event_key.get(
'inviter_user_id') # 邀请人id
print('event_key -->', event_key)
data = get_ent_info(
inviter_user_id) # 获取该用户 token appid等
weichat_api_obj = WeChatApi(data)
ret_obj = weichat_api_obj.get_user_info(openid=openid)
flag = False # 是否点过修改 成 我的名片 如果有创建文章 推送给用户
article_id = ''
if not inviter_user_id: # 如果没有推荐人 则查询 是否查看过文章 最后一次查看 该公司的用户
select_article_objs = models.SelectArticleLog.objects.filter(
inviter__enterprise__appid=appid,
customer__openid=openid).order_by(
'-create_datetime')
if select_article_objs:
select_article_obj = select_article_objs[0]
if select_article_obj.click_modify:
flag = True
select_article_obj.click_modify = 0 # 避免下次判断
select_article_obj.save()
article_id = select_article_obj.article_id
inviter_user_id = select_article_obj.inviter_id
user_id = updateUserInfo(openid,
inviter_user_id,
ret_obj,
msg='关注公众号',
enterprise_id=data.get('id'))
user_obj = models.Userprofile.objects.get(id=user_id)
if event == 'subscribe': # 首次关注
nickname = ret_obj.get('nickname') # 关注人名称
sex_obj = ret_obj.get('sex') # 性别
if sex_obj and int(sex_obj) == 2: # 女
sex = '美女'
else: # 男 未知
sex = '靓仔'
text = '点击下方【天眼】{emj_3}'.format(emj_3=xiajiantou)
if flag: # 客户未关注公众号情况下 点击了 修改成我的名片文章 关注公众号后 发送点击的文章
text = '您要修改的名片文章{emj_3}点击修改吧!'.format(
emj_3=xiajiantou)
post_data = {
"touser": openid,
"msgtype": "text",
"text": {
"content":
'欢迎关注{user_name}公众号！\n\n<{sex}-{name}>你终于来了!天眼已经在此等候多时!{emj_1}\n\n'
'分享文章后我会告诉您谁看了您的文章, 精准追踪客户\n\n'
'快进入天眼客户追踪神器吧！{emj_2}\n\n'
'{text}'.format(
user_name=user_obj.enterprise.name,
name=nickname,
emj_1=baiyan,
emj_2=zhayan,
text=text,
sex=sex)
}
}
post_data = bytes(json.dumps(post_data,
ensure_ascii=False),
encoding='utf-8')
weichat_api_obj.news_service(post_data)
if flag: # 查看了别人的文章
article_objs = models.Article.objects.filter(
id=article_id)
if article_objs:
article_obj = article_objs[0]
create_article_obj = models.Article.objects.create(
title=article_obj.title,
summary=article_obj.summary,
content=article_obj.content,
create_user_id=user_obj.id,
source_link=article_obj.source_link,
cover_img=article_obj.cover_img,
style=article_obj.style,
original_link=article_obj.original_link,
)
create_article_obj.classify = [39]
create_article_obj.save()
url = 'http://zhugeleida.zhugeyingxiao.com/tianyan/#/Article/Article_Detail?id={}&token={}&user_id={}&classify_type=1'.format(
create_article_obj.id, user_obj.token,
user_obj.id)
post_data = {
"touser": openid,
"msgtype":
"news", # 图文消息 图文消息条数限制在1条以内，注意，如果图文数超过1，则将会返回错误码45008。
"news": {
"articles": [{
"title":
create_article_obj.title,
"description":
b64decode(create_article_obj.summary),
"url":
url,
"picurl":
create_article_obj.cover_img +
'?imageView2/2/w/200'
}]
}
}
post_data = bytes(json.dumps(post_data,
ensure_ascii=False),
encoding='utf-8')
weichat_api_obj.news_service(post_data)
# 取消关注
elif event == "unsubscribe":
print('-------------取关')
models.Userprofile.objects.filter(openid=openid).update(
subscribe=False)
models.Customer.objects.filter(openid=openid).update(
subscribe=False)
# we_chat_public_send_msg_obj.sendTempMsg(post_data)
# 客户发送消息
elif msg_type == 'text':
Content = collection.getElementsByTagName(
"Content")[0].childNodes[0].data
user_objs = models.Userprofile.objects.filter(
openid=openid) # 获取用户ID
if not user_objs: # 如果没有这个用户
weichat_api_obj = WeChatApi(data)
ret_obj = weichat_api_obj.get_user_info(openid=openid)
updateUserInfo(openid, inviter_user_id, ret_obj)
user_obj = models.Userprofile.objects.get(
openid=openid) # 获取用户ID
else:
user_obj = user_objs[0]
user_obj.last_active_time = datetime.datetime.today() # 最后活跃时间
user_id = user_obj.id
pub_log_access(user_id,
msg='用户给公众号发送消息:{}'.format(Content)) # 记录访问日志
token = user_obj.token
data = get_ent_info(user_id) # 获取该用户appid等
weichat_api_obj = WeChatApi(data) # 实例化公众号操作
# 判断该人在同一时刻 发送多条只接受一条
send_msg_duplicate_obj = models.send_msg_duplicate.objects.filter(
user_id=user_id, create_date_time=CreateTime)
if not send_msg_duplicate_obj:
models.send_msg_duplicate.objects.create(
user_id=user_id, create_date_time=CreateTime)
else:
return HttpResponse('')
if 'http' in Content: # 获取文章内容 返回文章
print('Content=-===========》', Content)
# 判断 链接是否正常
post_data = {
"touser": openid,
"msgtype": "text",
"text": {
"content": '解码中,请稍等······'
}
}
weichat_api_obj.news_service(
bytes(json.dumps(post_data, ensure_ascii=False),
encoding='utf-8')) # 发送客服消息
try:
ret = requests.get(Content, timeout=5)
status_code = ret.status_code
except Exception:
post_data = {
"touser": openid,
"msgtype": "text",
"text": {
"content":
'链接请求不到了······{}'.format(b64decode('4p2V4p2X'))
}
}
weichat_api_obj.news_service(
bytes(json.dumps(post_data, ensure_ascii=False),
encoding='utf-8')) # 发送客服消息
return HttpResponse('')
if status_code != 200:
post_data = {
"touser": openid,
"msgtype": "text",
"text": {
"content":
'该链接存在异常请求状态码>{}'.format(status_code)
}
}
else:
# try:
# ret = requests.get(Content, timeout=5)
# ret.encoding = 'utf-8'
# except Exception:
# post_data = {
# "touser": openid,
# "msgtype": "text",
# "text": {
# "content": '这个链接没有文章{}'.format(b64decode('4p2X'))
# }
# }
# weichat_api_obj.news_service(bytes(json.dumps(post_data, ensure_ascii=False), encoding='utf-8')) # 发送客服消息
# return HttpResponse('')
title = re.compile(r'var msg_title = (.*);').findall(
ret.text)[0].replace('"', '') # 标题
article_objs = models.Article.objects.filter(
title=title, create_user_id=user_id)
if not article_objs: # 判断数据库是否有 该文章
data_dict = get_article(Content) # 获取文章
summary = data_dict.get('summary') # 摘要
data_dict['create_user_id'] = user_id # 增加创建人
id = add_article_public(
data_dict, 39) # 创建文章 第二个参数为 classify_id 默认为其他
cover_img = data_dict.get('cover_img') # 封面
else:
article_obj = article_objs[0]
id = article_obj.id
summary = article_obj.summary
cover_img = article_obj.cover_img
url = 'http://zhugeleida.zhugeyingxiao.com/tianyan/#/Article/Article_Detail?id={}&token={}&user_id={}&classify_type=1'.format(
id, token, user_id)
post_data = {
"touser": openid,
"msgtype":
"news", # 图文消息 图文消息条数限制在1条以内，注意，如果图文数超过1，则将会返回错误码45008。
"news": {
"articles": [{
"title":
title,
"description":
b64decode(summary),
"url":
url,
"picurl":
cover_img + '?imageView2/2/w/200'
}]
}
}
else: # 收到其他文字 发送随机五篇文章
timestamp = str(int(time.time()))
rand_str = str_encrypt(timestamp + token)
share_url = 'http://zhugeleida.zhugeyingxiao.com/tianyan/api/article/popula_articles/0?length=5&rand_str={}×tamp={}&user_id={}'.format(
rand_str, timestamp, user_id)
ret = requests.get(share_url) # 请求随机文章五篇
ret.encoding = 'utf8'
ret_json = ret.json().get('data')
content = ''
for i in ret_json.get('ret_data'): # 循环出推荐文章 链接为文章详情链接
url = 'http://zhugeleida.zhugeyingxiao.com/tianyan/#/Article/Article_Detail?id={}&token={}&user_id={}&classify_type=1'.format(
i.get('id'), token, user_id)
pinjie_content = '{}<a href="{url}">{title}</a>'.format(
b64decode('4p6h'), # emoji解码 →箭头
title=i.get('title'),
url=url)
content += ' \n{} \n'.format(
pinjie_content) # 拼接A标签 跳转链接
post_data = {
"touser": openid,
"msgtype": "text",
"text": {
"content":
'天眼将一直为您推送消息 \n{} \n点击下方天眼,更多内容等你哦!'.format(
content)
}
}
print('--------------------post_data-----> ', post_data)
# 发送客服消息
post_data = bytes(json.dumps(post_data, ensure_ascii=False),
encoding='utf-8')
weichat_api_obj.news_service(post_data)
return HttpResponse("")
else:
return HttpResponse(False)
def team_oper(request, oper_type, o_id):
# print('oper_type -->', oper_type)
response = Response.ResponseObj()
user_id = request.GET.get('user_id')
if request.method == "POST":
# 添加团队
if oper_type == "add":
form_data = {
'create_user_id': user_id,
'name': request.POST.get('name'),
}
# 创建 form验证 实例（参数默认转成字典）
forms_obj = AddForm(form_data)
if forms_obj.is_valid():
print("验证通过")
# print(forms_obj.cleaned_data)
# 添加数据库
# print('forms_obj.cleaned_data-->',forms_obj.cleaned_data)
obj = models.Team.objects.create(**forms_obj.cleaned_data)
obj.userprofileteam_set.create(user_id=user_id,
team_id=obj.id,
type=2)
response.code = 200
response.msg = "添加成功"
response.data = {'id': obj.id}
else:
response.code = 301
response.msg = json.loads(forms_obj.errors.as_json())
# 修改团队名称
elif oper_type == "update":
# 获取需要修改的信息
form_data = {
'o_id': o_id, # 团队id
'user_id': user_id,
'name': request.POST.get('name'),
}
forms_obj = UpdateForm(form_data)
if forms_obj.is_valid():
# print("验证通过")
# print(forms_obj.cleaned_data)
o_id = forms_obj.cleaned_data['o_id']
name = forms_obj.cleaned_data['name']
# 查询更新 数据
models.Team.objects.filter(id=o_id).update(name=name, )
response.code = 200
response.msg = "修改成功"
else:
print("验证不通过")
# print(forms_obj.errors)
response.code = 301
# print(forms_obj.errors.as_json())
# 字符串转换 json 字符串
response.msg = json.loads(forms_obj.errors.as_json())
# 删除团队成员
elif oper_type == "delete_member":
delete_user_id = request.POST.get('delete_user_id') # 要移除的成员id
form_data = {
'o_id': o_id, # 团队id
'user_id': user_id,
'delete_user_id': delete_user_id,
}
forms_obj = DeleteMemberForm(form_data)
if forms_obj.is_valid():
# print("验证通过")
# print(forms_obj.cleaned_data)
team_id = forms_obj.cleaned_data['o_id']
delete_user_id_list = forms_obj.cleaned_data['delete_user_id']
print('team_id -->', team_id)
print('delete_user_id -->', delete_user_id)
# 删除团队中的成员
models.UserprofileTeam.objects.filter(
team_id=team_id, type=1,
user_id__in=delete_user_id_list).delete()
response.code = 200
response.msg = "删除成功"
else:
print("验证不通过")
response.code = 301
response.msg = json.loads(forms_obj.errors.as_json())
# 设置普通成员成为管理员
elif oper_type == "set_management":
print('request.POST -->', request.POST)
print('request.GET -->', request.GET)
set_user_id = request.POST.get('set_user_id')
print('set_user_id -->', set_user_id)
form_data = {
'o_id': o_id, # 团队id
'user_id': user_id,
'set_user_id': set_user_id,
}
forms_obj = SetManagementForm(form_data)
if forms_obj.is_valid():
set_user_id_list = forms_obj.cleaned_data.get('set_user_id')
team_id = forms_obj.cleaned_data.get('o_id')
# 先将所有成员改成普通用户
models.UserprofileTeam.objects.filter(team_id=team_id).update(
type=1)
# 修改成员类型为管理员
models.UserprofileTeam.objects.filter(
team_id=team_id,
user_id__in=set_user_id_list).update(type=2)
response.code = 200
response.msg = "修改成功"
else:
response.code = 301
response.data = json.loads(forms_obj.errors.as_json())
# 删除团队
elif oper_type == 'delete':
member_objs = models.UserprofileTeam.objects.filter(team_id=o_id)
user_id_list = [
i.get('user_id')
for i in member_objs.filter(type=2).values('user_id')
]
user_list = [
i.get('user_id')
for i in member_objs.filter(type=1).values('user_id')
] # 普通用户
if int(user_id) in user_id_list: # 该团队管理员列表
models.Article.objects.filter(ownership_team_id=o_id).update(
ownership_team_id=None)
member_objs.delete()
models.Team.objects.filter(id=o_id).delete()
response.code = 200
response.msg = '删除团队成功'
else:
if int(user_id) in user_list:
member_objs.filter(user_id=user_id).delete()
response.code = 200
response.msg = '退出团队成功'
else:
response.code = 301
response.msg = '权限不足'
else:
# 查看团队人员列表
if oper_type == "select_user_list":
form_data = {
'team_id': o_id,
'current_page': request.GET.get('current_page', 1),
'length': request.GET.get('length', 10),
}
forms_obj = SelectUserListForm(form_data)
if forms_obj.is_valid():
print('forms_obj.cleaned_data -->', forms_obj.cleaned_data)
current_page = forms_obj.cleaned_data['current_page']
length = forms_obj.cleaned_data['length']
team_id = forms_obj.cleaned_data['team_id']
order = request.GET.get('order', 'create_datetime')
field_dict = {
'id': '',
'type': '',
# 'user__name': '__contains',
'create_datetime': '',
}
q = conditionCom(request, field_dict)
print('q -->', q)
objs = models.UserprofileTeam.objects.select_related(
'user').filter(q).filter(team_id=team_id).order_by(order)
count = objs.count()
if length != 0:
start_line = (current_page - 1) * length
stop_line = start_line + length
objs = objs[start_line:stop_line]
# 返回的数据
ret_data = []
for obj in objs:
# 将查询出来的数据 加入列表
print('base64_encryption.b64encode(obj.user.name) -->',
base64_encryption.b64encode(obj.user.name))
ret_data.append({
'id':
obj.user_id,
'user_type_name':
obj.get_type_display(),
'user_type':
obj.type,
'name':
base64_encryption.b64decode(obj.user.name),
'set_avator':
obj.user.set_avator,
'create_datetime':
obj.create_datetime.strftime('%Y-%m-%d %H:%M:%S'),
})
# 查询成功 返回200 状态码
response.code = 200
response.msg = '查询成功'
response.data = {
'ret_data': ret_data,
'data_count': count,
}
response.note = {
'id': "用户id",
'name': "用户名称",
'user_type': "用户在团队中的类型/角色id, 1 ==> 普通用户 2 ==> 管理员",
'user_type_name': "用户在团队中的类型/角色名称",
'set_avator': "用户头像",
'create_datetime': "用户加入时间",
}
else:
response.code = 301
response.data = json.loads(forms_obj.errors.as_json())
return JsonResponse(response.__dict__)
def user(request):
response = Response.ResponseObj()
if request.method == "GET":
forms_obj = SelectForm(request.GET)
if forms_obj.is_valid():
user_id = request.GET.get('user_id')
current_page = forms_obj.cleaned_data['current_page']
length = forms_obj.cleaned_data['length']
print('forms_obj.cleaned_data -->', forms_obj.cleaned_data)
order = request.GET.get('order', '-create_datetime')
field_dict = {
'id': '',
'name': '__contains',
'create_datetime': '',
}
q = conditionCom(request, field_dict)
print('q -->', q)
objs = models.Userprofile.objects.filter(q).order_by(order)
count = objs.count()
if length != 0:
start_line = (current_page - 1) * length
stop_line = start_line + length
objs = objs[start_line:stop_line]
ret_data = []
for obj in objs:
# 返回的数据
team_list = []
team_objs = models.UserprofileTeam.objects.filter(
user_id=obj.id)
for team_obj in team_objs:
team_list.append(team_obj.team_id)
brand_list = [
i['name'] for i in obj.brand_classify.values('name')
]
qr_code = ''
if obj.qr_code:
qr_code = obj.qr_code + '?imageView2/2/w/100'
set_avator = ''
inviter_id = ''
inviter_name = ''
if obj.inviter:
inviter_name = b64decode(obj.inviter.name)
inviter_id = obj.inviter_id
set_avator = obj.inviter.set_avator + '?imageView2/2/w/100'
# 将查询出来的数据 加入列表
ret_data.append({
'id':
obj.id,
'name':
b64decode(obj.name),
'phone_number':
obj.phone_number,
'signature':
obj.signature,
'show_product':
obj.show_product,
'register_date':
obj.register_date.strftime('%Y-%m-%d'),
'overdue_date':
obj.overdue_date.strftime('%Y-%m-%d'),
'set_avator':
obj.set_avator,
'qr_code':
qr_code,
'brand_list':
brand_list,
'team_list':
team_list,
'vip_type':
obj.get_vip_type_display(),
'my_references_id':
inviter_id, # 邀请人ID
'my_references_name':
inviter_name, # 我的推荐人名称
'my_references_set':
set_avator # 我的推荐人头像
})
# 查询成功 返回200 状态码
response.code = 200
response.msg = '查询成功'
response.data = {
'ret_data': ret_data,
'data_count': count,
}
response.note = {
'id': "用户id",
'name': "姓名",
'phone_number': "手机号",
'signature': "个性签名",
'show_product': "文章底部是否显示产品",
'register_date': "注册时间",
'overdue_date': "过期时间",
'set_avator': "头像",
'qr_code': "微信二维码",
'vip_type': "会员类型",
'brand_list': "公司/品牌列表",
'team_list': "团队ID数组",
'my_references_id': '邀请人ID',
'my_references_name': '我的推荐人名称',
'my_references_set': '我的推荐人头像',
}
else:
print("forms_obj.errors -->", forms_obj.errors)
response.code = 402
response.msg = "请求异常"
response.data = json.loads(forms_obj.errors.as_json())
return JsonResponse(response.__dict__)
def day_eye_oper(request, oper_type, o_id):
response = Response.ResponseObj()
user_id = request.GET.get('user_id')
forms_obj = SelectForm(request.GET)
if forms_obj.is_valid():
current_page = forms_obj.cleaned_data['current_page']
length = forms_obj.cleaned_data['length']
order = request.GET.get('order', '-create_datetime')
if request.method == "POST":
form_data = {
'o_id': o_id,
'user_id': user_id,
'customer_id': request.POST.get('customer_id'),
'remote_type': request.POST.get('remote_type'),
'title': request.POST.get('title'),
'create_date': request.POST.get('create_date'),
'remote': request.POST.get('remote')
}
# 添加客户信息备注
if oper_type == "add":
form_obj = AddForm(form_data)
if form_obj.is_valid():
remote = form_obj.cleaned_data.get('remote')
customer_id = form_obj.cleaned_data.get('customer_id')
data = {
'user_id': user_id,
'customer_id': customer_id,
'remote': remote
}
models.customer_information_the_user.objects.create(**data)
response.code = 200
response.msg = '保存成功'
else:
response.code = 301
response.msg = json.loads(form_obj.errors.as_json())
# 修改客户信息备注
elif oper_type == 'update':
form_obj = UpdateForm(form_data)
if form_obj.is_valid():
o_id = form_obj.cleaned_data.get('o_id')
remote = form_obj.cleaned_data.get('remote')
models.customer_information_the_user.objects.filter(
id=o_id).update(remote=remote)
response.code = 200
response.msg = '保存成功'
else:
response.code = 301
response.msg = json.loads(form_obj.errors.as_json())
# 删除客户信息备注
elif oper_type == 'delete':
customer_id = request.POST.get('customer_id')
if customer_id:
objs = models.customer_information_the_user.objects.filter(
user_id=user_id, customer_id=customer_id)
else:
objs = models.customer_information_the_user.objects.filter(
id=o_id)
if not objs:
response.code = 301
response.msg = '刪除数据不存在'
else:
objs.delete()
response.code = 200
response.msg = '删除成功'
# 添加客户资料
elif oper_type == 'add_customer_info':
pass
# 修改客户资料 个人信息等
elif oper_type == 'update_customer_info':
print(
'request.POST=============================000000000-=-------------> ',
request.POST)
customer_info = request.POST.get('customer_info')
objs = models.user_comments_customer_information.objects.filter(
user_id=user_id, customer_id=o_id)
print(
'request.POST=============================000000000-=-------------> ',
type(customer_info), customer_info)
customer_info = eval(customer_info)
if objs:
objs.update(customer_info=json.dumps(customer_info))
else:
objs.create(customer_info=customer_info,
user_id=user_id,
customer_id=o_id)
response.code = 200
response.msg = '保存成功'
response.note = {
'customer_info': '用户所有信息',
'customer_sex': '用户性别 默认微信性别',
'customer_set_avator': '用户头像 默认微信头像',
'customer_name': '用户姓名 备注 默认微信名称',
'customer_wechat': '用户微信名称',
'customer_phone': '用户电话',
'customer_professional': '用户职业',
'customer_birthday': '用户生日',
'customer_remake': '用户备注',
'customer_demand': '用户需求',
'customer_label': {
'xueli': '学历ID',
'diqu': '地区名称',
'guanxi': '关系',
'qinmidu': '亲密度',
'yingxiangli': '影响力',
'qituxin': '企图心',
'shiyetaidu': '事业态度',
'renmaiquan': '人脉圈',
'jingjinengli': '经济能力',
},
}
else:
# 查询客户信息备注
if oper_type == 'get_customer_note':
field_dict = {
'id': '',
'customer_id': '',
'user_id': '',
}
q = conditionCom(request, field_dict)
objs = models.customer_information_the_user.objects.filter(
q).order_by(order)
if length != 0:
start_line = (current_page - 1) * length
stop_line = start_line + length
objs = objs[start_line:stop_line]
count = objs.count()
ret_data = []
num = 0
for obj in objs:
create_datetime = obj.create_datetime.strftime(
'%Y-%m-%d %H:%M:%S')
ret_data.append({'create_datetime': create_datetime})
ret_data[num]['remote'] = obj.remote
ret_data[num]['id'] = obj.id
num += 1
response.code = 200
response.msg = '查询成功'
response.data = {
'count': count,
'ret_data': ret_data,
}
response.note = {
'create_datetime': '创建时间',
'remote': '备注',
}
# 谁看了我 (文章详情)
elif oper_type == 'day_eye_detail':
user_id = forms_obj.cleaned_data['user_id']
# 更新 用户点击客户详情时间
day_celery_objs = models.day_eye_celery.objects.filter(
status=1, user_id=user_id, customer_id=o_id)
if day_celery_objs:
day_celery_objs.update(
last_click_customer=datetime.datetime.today(),
is_new_msg=False)
article_objs = models.SelectArticleLog.objects.filter(
inviter_id=user_id, customer_id=o_id)
info_objs = article_objs.order_by(order)
objs = article_objs.values('article_id', 'article__title',
'article__cover_img').annotate(
Count('id'))
count = objs.count()
ret_data = []
for obj in objs:
article_id = obj.get('article_id')
article_obj = article_objs.filter(
article_id=article_id).order_by(order)[:1]
time_detail = [] # 查看时长及时间
for info_obj in info_objs:
if int(info_obj.article_id) == int(article_id):
time_length = '1秒'
create_datetime = info_obj.create_datetime
if info_obj.close_datetime:
time_length = get_min_s(
create_datetime, info_obj.close_datetime)
time_detail.append({
'time_length':
time_length,
'select_datetime':
create_datetime.strftime('%Y-%m-%d %H:%M:%S'),
})
create_datetime = article_obj[0].create_datetime
after_time = get_min_s(create_datetime,
datetime.datetime.today(),
ms=1)
ret_data.append({
'article_id':
article_id,
'article__title':
obj.get('article__title'),
'article_info':
'看了' + str(obj.get('id__count')) + '次-' + after_time +
'前',
'time_detail':
time_detail,
'article__cover_img':
obj.get('article__cover_img'),
'create_datetime':
create_datetime, # 排序用
})
data_list = sorted(ret_data,
key=lambda x: x['create_datetime'],
reverse=True)
is_new_goods_msg = False
goods_objs = models.day_eye_celery.objects.filter(
status=2, user_id=user_id, customer_id=o_id)
if goods_objs:
if goods_objs[0].is_new_msg:
is_new_goods_msg = True
response.code = 200
response.msg = '查询成功'
response.data = {
'ret_data': data_list,
'data_count': count,
'is_new_goods_msg': is_new_goods_msg,
}
response.note = {
'article_id': "文章ID",
'article__title': "文章标题",
'article_info': "看了几次 最后一次查看时间",
'time_length': "时长",
'select_datetime': "查看时间",
'article__cover_img': "文章图片",
'create_datetime': "创建时间",
'is_new_goods_msg': "是否有商品新消息",
}
# 按文章查看(天眼功能)列表页
elif oper_type == 'view_by_article':
user_id, message = forms_obj.cleaned_data['user_id']
objs = models.SelectArticleLog.objects.filter(
inviter_id=user_id).values(
'article_id', 'article__title').distinct().annotate(
Count('id')).exclude(customer_id__isnull=True)
count = objs.count()
ret_data = []
for obj in objs:
article_obj = models.SelectArticleLog.objects.filter(
article_id=obj['article_id']).order_by(order)
cover_img = article_obj[0].article.cover_img # 文章封面
create_datetime = article_obj[0].create_datetime
after_time = get_min_s(create_datetime,
datetime.datetime.today(),
ms=1)
ret_data.append({
'article_id': obj['article_id'],
'article__title': obj['article__title'],
'id__count': obj['id__count'],
'after_time': after_time + '前',
'cover_img': cover_img + '?imageView2/2/w/200',
'create_datetime': create_datetime,
})
ret_data = sorted(ret_data,
key=lambda x: x['create_datetime'],
reverse=True)
if length != 0:
start_line = (current_page - 1) * length
stop_line = start_line + length
ret_data = ret_data[start_line:stop_line]
response.code = 200
response.msg = '查询成功'
response.data = {
'ret_data': ret_data,
'count': count,
'message': message,
}
response.note = {
'article_id': '文章ID',
'article__title': '文章标题',
'id__count': '查看该文章人 总数',
'cover_img': '文章封面',
'after_time': '最后查看日期',
}
# 按文章查看(详情)
elif oper_type == 'view_by_article_detail':
article_obj = models.SelectArticleLog.objects.filter(
inviter_id=user_id,
article_id=o_id,
customer_id__isnull=False)
objs = article_obj.values(
'customer_id', 'customer__name',
'customer__set_avator').distinct().annotate(Count('id'))
if length != 0:
start_line = (current_page - 1) * length
stop_line = start_line + length
objs = objs[start_line:stop_line]
count = objs.count()
ret_data = []
for obj in objs:
objs = article_obj.filter(
customer_id=obj['customer_id'])[:1]
create_datetime = objs[0].create_datetime
after_time = get_min_s(create_datetime,
datetime.datetime.today(),
ms=1)
ret_data.append({
'customer_id':
obj['customer_id'],
'customer__set_avator':
obj['customer__set_avator'] + '?imageView2/2/w/200',
'customer__name':
b64decode(obj['customer__name']),
'article_info':
'看了' + str(obj['id__count']) + '次-' + after_time + '前',
})
response.code = 200
response.msg = '查询成功'
response.data = {
'ret_data': ret_data,
'count': count,
}
response.note = {
'customer_id': '客户ID',
'customer__name': '客户名称',
'article_info': '该人查看该文章 总数/ 时长',
}
# 查询客户资料
elif oper_type == 'get_customer_info':
objs = models.user_comments_customer_information.objects.filter(
user_id=user_id, customer_id=o_id)
if not objs:
customer_info = {
'customer_sex': '',
'customer_set_avator': '',
'customer_name': '',
'customer_wechat': '',
'customer_phone': '',
'customer_professional': '',
'customer_birthday': '',
'customer_remake': '',
'customer_demand': [],
'customer_label': {
'xueli': '初中',
'diqu': '北京',
'guanxi': '朋友',
'qinmidu': 1,
'yingxiangli': 1,
'qituxin': 1,
'shiyetaidu': 1,
'renmaiquan': 1,
'jingjinengli': 1,
},
}
models.user_comments_customer_information.objects.create(
user_id=user_id,
customer_id=o_id,
customer_info=customer_info)
objs = models.user_comments_customer_information.objects.filter(
user_id=user_id, customer_id=o_id)
obj = objs[0]
info = eval(obj.customer_info)
customer_sex = obj.customer.sex
if info.get('customer_sex'):
customer_sex = info.get('customer_sex')
customer_set_avator = obj.customer.set_avator
if info.get('customer_set_avator'):
customer_set_avator = info.get('customer_set_avator')
customer = b64decode(obj.customer.name)
customer_name = customer
if info.get('customer_name'):
customer_name = info.get('customer_name')
customer_label = info.get('customer_label')
print('customer_label-------> ', customer_label)
try:
customer_demand = eval(info.get('customer_demand'))
except Exception:
customer_demand = info.get('customer_demand')
ret_data = {
'customer_sex':
customer_sex,
'customer_set_avator':
customer_set_avator,
'customer_name':
customer_name,
'customer_wechat':
customer,
'customer_phone':
info.get('customer_phone'),
'customer_professional':
info.get('customer_professional'),
'customer_birthday':
info.get('customer_birthday'),
'customer_remake':
info.get('customer_remake'),
'customer_demand':
customer_demand,
'customer_label': {
'xueli': customer_label.get('xueli'),
'diqu': customer_label.get('diqu'),
'guanxi': customer_label.get('guanxi'),
'qinmidu': customer_label.get('qinmidu'),
'yingxiangli': customer_label.get('yingxiangli'),
'qituxin': customer_label.get('qituxin'),
'shiyetaidu': customer_label.get('shiyetaidu'),
'renmaiquan': customer_label.get('renmaiquan'),
'jingjinengli': customer_label.get('jingjinengli'),
},
'create_datetime':
obj.create_datetime.strftime('%Y-%m-%d %H:%M:%S')
}
response.code = 200
response.msg = '查询成功'
response.data = {'ret_data': ret_data}
response.note = {
'customer_sex': '用户性别 默认微信性别',
'customer_set_avator': '用户头像 默认微信头像',
'customer_name': '用户姓名 备注 默认微信名称',
'customer_wechat': '用户微信名称',
'customer_phone': '用户电话',
'customer_professional': '用户职业',
'customer_birthday': '用户生日',
'customer_remake': '用户备注',
'customer_demand': '用户需求',
'customer_label': {
'xueli': '学历ID',
'diqu': '地区名称',
'guanxi': '关系',
'qinmidu': '亲密度',
'yingxiangli': '影响力',
'qituxin': '企图心',
'shiyetaidu': '事业态度',
'renmaiquan': '人脉圈',
'jingjinengli': '经济能力',
}
}
# 查看客户详情(客户信息)
elif oper_type == 'info_detail':
# info_objs = models.SelectArticleLog.objects.filter(inviter_id=user_id, customer_id=o_id).order_by(order)
# 谁看了我详情 右上角星星数据
info_data = {
'xueli': '初中',
'diqu': '北京',
'guanxi': '朋友',
'qinmidu': 1,
'yingxiangli': 1,
'qituxin': 1,
'shiyetaidu': 1,
'renmaiquan': 1,
'jingjinengli': 1,
'customer_demand': []
}
information_objs = models.user_comments_customer_information.objects.filter(
user_id=user_id, customer_id=o_id)
if information_objs:
information_obj = information_objs[0]
try:
customer_info = eval(information_obj.customer_info)
except Exception:
customer_info = information_obj.customer_info
customer_label = customer_info.get('customer_label')
try:
customer_demand = json.loads(
customer_info.get('customer_demand'))
except Exception:
customer_demand = customer_info.get('customer_demand')
info_data = {
'xueli': customer_label.get('xueli'),
'diqu': customer_label.get('diqu'),
'guanxi': customer_label.get('guanxi'),
'qinmidu': customer_label.get('qinmidu'),
'yingxiangli': customer_label.get('yingxiangli'),
'qituxin': customer_label.get('qituxin'),
'shiyetaidu': customer_label.get('shiyetaidu'),
'renmaiquan': customer_label.get('renmaiquan'),
'jingjinengli': customer_label.get('jingjinengli'),
'customer_demand': customer_demand,
}
avg_stars_list = []
for k, v in info_data.items():
if k in [
'qinmidu', 'yingxiangli', 'qituxin', 'shiyetaidu',
'renmaiquan', 'jingjinengli'
]:
avg_stars_list.append(int(v))
avg_stars = sum(avg_stars_list) / 6 # 右上角星星 平均值
obj = models.Customer.objects.get(id=o_id)
# 客户基本信息
customer_info = {
'customer_id': obj.id,
'customer__name': b64decode(obj.name),
'customer__set_avator': obj.set_avator,
'info_data': info_data,
'avg_stars': avg_stars,
}
is_remake_count = models.customer_information_the_user.objects.filter(
user_id=user_id, customer_id=o_id).count()
is_remake = False
if is_remake_count >= 1:
is_remake = True
response.code = 200
response.msg = '查询成功'
response.data = {
'customer_info': customer_info,
'is_remake': is_remake
}
response.note = {
'customer_id': "客户id",
'customer__name': "客户姓名",
'customer__set_avator': "客户头像",
'is_remake': "该客户是否有备注(如果有那么可删除)",
'qinmidu': '亲密度',
'yingxiangli': '影响力',
'qituxin': '企图心',
'shiyetaidu': '事业态度',
'renmaiquan': '人脉圈',
'jingjinengli': '经济能力',
'avg_stars': '星星平均值',
}
# 谁看了我(商品详情)
elif oper_type == 'day_eye_goods_detail':
# 更新 用户点击客户详情时间
day_celery_objs = models.day_eye_celery.objects.filter(
status=2, user_id=user_id, customer_id=o_id)
if day_celery_objs:
day_celery_objs.update(
last_click_customer=datetime.datetime.today(),
is_new_msg=False)
objs = models.customer_look_goods_log.objects.filter(
user_id=user_id,
customer_id=o_id).select_related('goods').values(
'goods_id',
'goods__cover_img',
'goods__goods_name',
).annotate(Count('id'))
data_list = []
for obj in objs:
goods_id = obj.get('goods_id')
detail_objs = models.customer_look_goods_log.objects.filter(
user_id=user_id, customer_id=o_id,
goods_id=goods_id).order_by('-create_datetime')
time_detail = []
for detail_obj in detail_objs: # 详情
time_length = '1秒'
if detail_obj.close_datetime:
time_length = get_min_s(detail_obj.create_datetime,
detail_obj.close_datetime)
time_detail.append({
'create_datetime':
detail_obj.create_datetime.strftime(
'%Y-%m-%d %H:%M:%S'),
'time_length':
time_length
})
create_datetime = detail_objs[0].create_datetime
time_length = get_min_s(create_datetime,
datetime.datetime.today())
data_list.append({
'goods_id':
goods_id,
'goods__cover_img':
obj.get('goods__cover_img'),
'goods__goods_name':
obj.get('goods__goods_name'),
'text':
'看了{}次-{}前'.format(obj.get('id__count'), time_length),
'time_detail':
time_detail,
'create_datetime':
create_datetime
})
data_list = sorted(data_list,
key=lambda x: x['create_datetime'],
reverse=True)
response.code = 200
response.msg = '查询成功'
response.data = {'data_list': data_list}
else:
response.code = 402
response.msg = '请求异常'
else:
response.code = 301
response.msg = json.loads(forms_obj.errors.as_json())
return JsonResponse(response.__dict__)
def user_oper(request, oper_type, o_id):
response = Response.ResponseObj()
user_id = request.GET.get('user_id')
print('request.POST -->', request.POST)
if request.method == "POST":
# 设置推荐分类
if oper_type == "update_recommend_classify":
classify_id = request.POST.get('classify_id[]')
if classify_id:
recommend_classify_list = [
int(i) for i in json.loads(classify_id)
]
print("recommend_classify_list -->", recommend_classify_list)
user_obj = models.Userprofile.objects.get(id=user_id)
user_obj.recommend_classify = recommend_classify_list
response.code = 200
response.msg = "设置成功"
else:
response.code = 301
response.msg = "分类id传参异常"
# 修改头像
elif oper_type == "update_head_portrait":
img_path = request.POST.get('img_path')
if img_path:
models.Userprofile.objects.filter(id=user_id).update(
set_avator=img_path)
response.code = 200
response.msg = "修改成功"
else:
response.code = 301
response.msg = "头像不能传参异常"
# 修改姓名
elif oper_type == "update_name":
name = request.POST.get('name')
if name:
if len(name) <= 9:
name = b64encode(name)
models.Userprofile.objects.filter(id=user_id).update(
name=name)
response.code = 200
response.msg = "修改成功"
else:
response.code = 301
response.msg = '名字最大长度为8'
else:
response.code = 301
response.msg = "姓名传参异常"
# 修改手机号
elif oper_type == "update_phone_number":
phone_number = request.POST.get('phone_number')
if verify_mobile_phone_number(phone_number):
models.Userprofile.objects.filter(id=user_id).update(
phone_number=phone_number)
response.code = 200
response.msg = "修改成功"
else:
response.code = 301
response.msg = "请填写正确手机号"
# 修改微信二维码
elif oper_type == "update_qr_code":
qr_code = request.POST.get('qr_code')
if qr_code:
models.Userprofile.objects.filter(id=user_id).update(
qr_code=qr_code)
response.code = 200
response.msg = "修改成功"
else:
response.code = 301
response.msg = "微信二维码传参异常"
# 修改个性签名
elif oper_type == "update_signature":
signature = request.POST.get('signature')
if signature:
models.Userprofile.objects.filter(id=user_id).update(
signature=signature)
response.code = 200
response.msg = "修改成功"
else:
response.code = 301
response.msg = "个性签名传参异常"
# 修改文章底部是否显示产品
elif oper_type == "update_show_product":
show_product = request.POST.get('show_product')
flag = re.match(r"^[01]$", show_product)
if show_product and flag:
models.Userprofile.objects.filter(id=user_id).update(
show_product=int(show_product))
response.code = 200
response.msg = "修改成功"
else:
response.code = 301
response.msg = "是否显示产品传参异常"
# 设置消息提醒
elif oper_type == 'message_remind_setting':
objs = models.Userprofile.objects.filter(id=user_id)
objs.update(message_remind=o_id)
response.code = 200
response.msg = '修改成功'
else:
# 查询我的会员 有效期 和剩余天数/会员类型
if oper_type == "member_info":
obj = models.Userprofile.objects.get(id=user_id)
# vip 类型
vip_type = obj.get_vip_type_display()
# 时间对象 - 年月日时分秒
now_datetime_obj = datetime.datetime.now()
# 时间对象 - 年月日
now_date_obj = datetime.date(now_datetime_obj.year,
now_datetime_obj.month,
now_datetime_obj.day)
# 计算剩余天数
remaining_days = (obj.overdue_date - now_date_obj).days
# 如果已经过期，则剩余过期时间为0，vip类型为vip已过期
if remaining_days <= 0:
if remaining_days == 0:
remaining_days = '今'
else:
remaining_days = 0
obj.vip_type = 0
obj.save()
obj = models.Userprofile.objects.get(id=user_id)
vip_type = obj.get_vip_type_display()
response.code = 200
response.data = {
'vip_type': vip_type,
'overdue_date': obj.overdue_date.strftime('%Y-%m-%d'),
'remaining_days': str(remaining_days) + '天'
}
response.note = {
'vip_type': "vip类型",
'overdue_date': "有效期至",
'remaining_days': "剩余天数"
}
# 使用微信头像
elif oper_type == 'use_wechat_avatar':
objs = models.Userprofile.objects.filter(id=user_id)
path = requests_img_download(objs[0].headimgurl)
set_avator = update_qiniu(path)
objs.update(set_avator=set_avator)
response.code = 200
response.msg = '修改成功'
# 推广赚钱 展示数据
elif oper_type == 'affiliate':
user_pub_objs = models.Userprofile.objects
response_data = {}
user_obj = user_pub_objs.get(id=user_id)
response_data[
'cumulative_amount'] = user_obj.cumulative_amount # 累计钱数
response_data['make_money'] = user_obj.make_money # 待提钱数
invite_objs = user_pub_objs.filter(inviter_id=user_id)
invite_friend_list = [
i.get('id') for i in invite_objs.values('id')
] # 该邀请人 邀请的好友ID
print('invite_friend_list----------> ', invite_friend_list)
# data_list = []
# for i in invite_friend_list:
# data_list.insert(0, i)
# data_list.extend([i.get('id') for i in models.Userprofile.objects.filter(inviter_id=i).values('id')])
# print('data_list--------------> ', data_list)
invite_objs = models.Userprofile.objects.filter(
id__in=invite_friend_list)
response_data['invite_number_count'] = invite_objs.count() # 邀请人数量
# 查询充值自己分销的钱数
number_clinch_deal_objs = models.distribute_money_log.objects.filter(
inviter_id=user_id).order_by('-create_date')
response_data[
'number_clinch_count'] = number_clinch_deal_objs.count(
) # 成交人数
if o_id and int(o_id) == 1: # 邀请人数详情
invite_number_list = []
for invite_number_obj in invite_objs:
# 该用户未充值展示的话
prepaid_text = '用户未开通会员, 邀请付款有现金奖励{}!'.format(qian)
if invite_number_obj.renewal_log_set.count(
) >= 1: # 判断该用户是否充值
money_objs = models.distribute_money_log.objects.filter(
inviter_id=user_id, user_id=invite_number_obj.id)
if money_objs:
money = money_objs[0].money
prepaid_text = '成为会员, 加入账户{}元!{}'.format(
money, qian)
invite_number_list.append({
'create_user__set_avator':
invite_number_obj.set_avator,
'name':
b64decode(invite_number_obj.name),
'prepaid_text':
prepaid_text,
})
response_data['invite_number_list'] = invite_number_list
elif o_id and int(o_id) == 2: # 成交人数
number_clinch_deal_list = []
for number_clinch_deal_obj in number_clinch_deal_objs:
number_clinch_deal_list.append({
'user_set_avator':
number_clinch_deal_obj.user.set_avator,
'user_name':
b64decode(number_clinch_deal_obj.user.name),
'price':
number_clinch_deal_obj.price,
'money':
number_clinch_deal_obj.money,
})
response_data[
'number_clinch_deal_list'] = number_clinch_deal_list
response.code = 200
response.msg = '查询成功'
response.data = response_data
response.note = {
'number_clinch_deal_list': {
'user_set_avator': '充值人头像',
'user_name': '充值人名称',
'price': '充值钱数',
'money': '应得钱数',
},
"invite_number_count": '邀请人数量',
"cumulative_amount": '累计钱数',
"make_money": '待提钱数',
"number_clinch_count": '成交人数',
"invite_number_list": '邀请人详情',
}
# 推广赚钱 二维码截图
elif oper_type == 'affiliate_screenshots':
user_obj = models.Userprofile.objects.get(id=user_id)
img_path = user_obj.promote_earning_qr_code_pictures
expire_date = user_obj.generate_models_qr_code_pictures_time
if img_path and expire_date > datetime.date.today(): # 如果有 图片
pass
else:
if img_path:
os.remove(img_path) # 删除原图
img_path, expire_date = tuiguang(user_id)
user_obj.promote_earning_qr_code_pictures = img_path
user_obj.generate_models_qr_code_pictures_time = expire_date
user_obj.save()
response.code = 200
response.msg = '生成成功'
response.data = {'path': img_path}
# 查询消息提醒设置
elif oper_type == 'get_message_remind':
user_obj = models.Userprofile.objects.get(id=user_id)
objs = models.Userprofile.message_remind_status
data_list = []
for obj in objs:
is_choose = False
if obj[0] == user_obj.message_remind:
is_choose = True
data_list.append({
'id': obj[0],
'name': obj[1],
'is_choose': is_choose
})
response.code = 200
response.msg = '查询成功'
response.data = {'data_list': data_list}
# 复制昵称
elif oper_type == 'copy_nickname':
obj = models.Customer.objects.get(id=o_id)
response.code = 200
response.msg = '查询成功'
response.data = {'nickname': b64decode(obj.name)}
# 判断该用户是否到期 (到期后不能转发任何东西)
elif oper_type == 'is_whether':
obj = models.Userprofile.objects.get(id=user_id)
now = datetime.date.today()
flag = False
if obj.overdue_date >= now:
flag = True
response.code = 200
response.data = {'flag': flag}
# 判断是否有手机号
elif oper_type == 'is_phone':
obj = models.Userprofile.objects.get(id=user_id)
flag = False
if obj.phone_number:
flag = True
response.code = 200
response.msg = '查询成功'
response.data = {'phone': flag}
else:
response.code = 402
response.msg = '请求异常'
return JsonResponse(response.__dict__)
def renewal(request):
response = Response.ResponseObj()
if request.method == "GET":
forms_obj = SelectForm(request.GET)
if forms_obj.is_valid():
user_id = request.GET.get('user_id')
current_page = forms_obj.cleaned_data['current_page']
length = forms_obj.cleaned_data['length']
print('forms_obj.cleaned_data -->', forms_obj.cleaned_data)
order = request.GET.get('order', '-create_date')
field_dict = {
'id': '',
'price': '__contains',
'the_length': '',
'renewal_number_days': '',
'create_date': '',
'create_user_id': '',
}
user_obj = models.Userprofile.objects.get(id=user_id)
q = conditionCom(request, field_dict)
print('q -->', q)
objs = models.renewal_management.objects.filter(
q, create_user_id=user_obj.enterprise_id).order_by(order)
count = objs.count()
if length != 0:
start_line = (current_page - 1) * length
stop_line = start_line + length
objs = objs[start_line:stop_line]
# 返回的数据
ret_data = []
for obj in objs:
# 将查询出来的数据 加入列表
ret_data.append({
'id':
obj.id,
'price':
obj.price,
'original_price':
obj.original_price,
'the_length_id':
obj.the_length,
'the_length':
obj.get_the_length_display(),
'create_user_id':
obj.create_user_id,
'create_user__name':
b64decode(obj.create_user.name),
'create_date':
obj.create_date.strftime('%Y-%m-%d %H:%M:%S')
})
# 查询成功 返回200 状态码
response.code = 200
response.msg = '查询成功'
response.data = {
'ret_data': ret_data,
'data_count': count,
}
response.note = {
'id': "id",
'price': '钱数',
'the_length_id': '时长ID(一个月， 一年....)',
'the_length': '时长',
'create_user_id': '创建人ID',
'create_user__name': '创建人名字',
'original_price': '原价',
'create_date': '创建时间',
}
else:
print("forms_obj.errors -->", forms_obj.errors)
response.code = 402
response.msg = "请求异常"
response.data = json.loads(forms_obj.errors.as_json())
return JsonResponse(response.__dict__)
def template(request):
response = Response.ResponseObj()
if request.method == "GET":
forms_obj = SelectForm(request.GET)
if forms_obj.is_valid():
current_page = forms_obj.cleaned_data['current_page']
length = forms_obj.cleaned_data['length']
print('forms_obj.cleaned_data -->', forms_obj.cleaned_data)
is_all = request.GET.get('is_all') #
order = request.GET.get('order', '-create_datetime')
field_dict = {
'id': '',
'name': '__contains',
'template_class_id': '',
'create_user_id': '',
'create_datetime': '',
'template_class__class_type': '',
}
q = conditionCom(request, field_dict)
user_id = request.GET.get('user_id')
user_obj = models.UserProfile.objects.get(id=user_id)
if user_obj.inviter:
user_id = user_obj.inviter_id
obj = models.UserProfile.objects.get(id=user_id)
if obj.role_id in [7, '7'] and not is_all:
q.add(Q(create_user_id=user_id), Q.AND)
else:
# q.add(Q(create_user__role_id__in=admin_list), Q.AND)
q.add(Q(create_user__role_id__in=[6, 8]), Q.AND)
print('q----------> ', q)
objs = models.Template.objects.select_related(
'template_class', 'create_user').filter(q).order_by(order)
count = objs.count()
if length != 0 and not request.GET.get('id'):
start_line = (current_page - 1) * length
stop_line = start_line + length
objs = objs[start_line:stop_line]
# 返回的数据
ret_data = []
for obj in objs:
template_class_id = ''
template_class_name = ''
template_class_type = ''
if obj.template_class:
template_class_id = obj.template_class_id
template_class_name = obj.template_class.name
template_class_type = obj.template_class.class_type
is_authorization = False
apple_objs = obj.clientapplet_set.all()
if apple_objs and apple_objs[0].is_authorization:
is_authorization = True
xcx_appid = ''
xcx_id = ''
if apple_objs and apple_objs[0].template:
xcx_id = apple_objs[0].id
xcx_appid = apple_objs[0].appid
# 将查询出来的数据 加入列表
dict_data = {
'id':
obj.id,
'name':
obj.name,
'template_class_type':
template_class_type,
'is_authorization':
is_authorization,
'share_qr_code':
obj.share_qr_code,
'logo_img':
obj.logo_img,
'xcx_id':
xcx_id,
'qrcode':
obj.qrcode,
'xcx_qrcode':
obj.xcx_qrcode,
'baidu_xcx_qrcode':
obj.baidu_xcx_qrcode,
'xcx_appid':
xcx_appid,
'thumbnail':
obj.thumbnail,
'template_class_name':
template_class_name,
'template_class_id':
template_class_id,
'create_user__username':
base64_encryption.b64decode(obj.create_user.name),
'create_datetime':
obj.create_datetime.strftime('%Y-%m-%d %H:%M:%S'),
}
if request.GET.get('id'):
if user_obj.role_id in admin_list: # 管理员角色的公共组件从redis中取出
# objs_two = models.Template.objects.select_related('create_user').filter(create_user__role_id__in=admin_list)
# data = []
# for i in objs_two:
# if i.common_components:
# data.extend(json.loads(i.common_components))
# dict_data['common_components'] = json.dumps(data)
redis_obj = get_redis_obj()
redis_key = "xcx::template::add_modify_common_components"
dict_data['common_components'] = redis_obj.get(
redis_key)
else:
dict_data['common_components'] = obj.common_components
ret_data.append(dict_data)
# 查询成功 返回200 状态码
response.code = 200
response.msg = '查询成功'
response.data = {
'ret_data': ret_data,
'data_count': count,
}
response.note = {
'id': "模板id",
'name': '模板名称',
'create_datetime': '创建时间',
'share_qr_code': '分享二维码',
'logo_img': 'logo图片',
'is_authorization': '是否授权',
"搜索条件": {
"name": "模板名称,支持模糊搜索",
"template_class_id": "模板分类id",
"create_user_id": "创建人id",
}
}
else:
response.code = 402
response.msg = "请求异常"
response.data = json.loads(forms_obj.errors.as_json())
return JsonResponse(response.__dict__)
def fund_record_enquiry_oper(request, oper_type):
response = Response.ResponseObj()
user_id = request.GET.get('user_id')
pub_user_obj = models.Enterprise.objects.get(id=user_id)
role = int(pub_user_obj.role)
if request.method == "GET":
forms_obj = SelectForm(request.GET)
if forms_obj.is_valid():
current_page = forms_obj.cleaned_data['current_page']
length = forms_obj.cleaned_data['length']
# 总资金记录
if oper_type == 'total_fund_record':
# 一级分成钱数
# one_division_money = models.distribute_money_log.objects.filter(
# inviter__enterprise_id=user_id,
# status=1
# ).aggregate(Sum('money')).get('money__sum')
#
# # 二级分成钱数
# two_division_money = models.distribute_money_log.objects.filter(
# inviter__enterprise_id=user_id,
# status=2
# ).aggregate(Sum('money')).get('money__sum')
status = request.GET.get('status')
"""
status 区分 会员充值 和 提现记录 和 全部数据
all 全部数据
order 会员充值数据 (订单)
withdrawal 提现数据
"""
# 续费记录
renewal_objs = models.renewal_log.objects.filter(
create_user__enterprise_id=user_id,
isSuccess=1).order_by('-create_date')
# 提现记录
withdrawal_amount_objs = models.withdrawal_log.objects.filter(
user__enterprise_id=user_id,
is_success=1).order_by('-create_date')
total_amount_renewal = 0
total_withdrawal_amount = 0
total_amount_renewal_num = renewal_objs.aggregate(
Sum('price')).get('price__sum') # 续费总金额
total_withdrawal_amount_num = withdrawal_amount_objs.aggregate(
Sum('withdrawal_amount')).get(
'withdrawal_amount__sum') # 提现总金额
if total_amount_renewal_num:
total_amount_renewal = total_amount_renewal_num
if total_withdrawal_amount_num:
total_withdrawal_amount = total_withdrawal_amount_num
# 提现 数据
if status == 'withdrawal':
total_amount_funds = total_withdrawal_amount
total_number_orders = withdrawal_amount_objs.count()
data_list = withdrawal(withdrawal_amount_objs)
# 订单 数据
elif status == 'order':
total_amount_funds = total_amount_renewal
total_number_orders = renewal_objs.count()
data_list = purchase_membership(renewal_objs)
# 全部数据 (订单 提现)
else:
total_amount_funds = total_amount_renewal - total_withdrawal_amount # 资金总额
total_number_orders = renewal_objs.count(
) + withdrawal_amount_objs.count() # 订单总数
withdrawal_amount_list = purchase_membership(renewal_objs)
renewal_list = withdrawal(withdrawal_amount_objs)
renewal_list.extend(withdrawal_amount_list)
data_list = sorted(renewal_list,
key=lambda x: x['create_date'],
reverse=True)
count = len(data_list)
if length != 0:
start_line = (current_page - 1) * length
stop_line = start_line + length
data_list = data_list[start_line:stop_line]
data_dict = {
'total_amount_funds': total_amount_funds,
'total_number_orders': total_number_orders,
'data_list': data_list,
'count': count,
}
ret_data = {}
for k, v in data_dict.items():
if v is None:
v = 0
ret_data[k] = v
response.code = 200
response.msg = '查询成功'
response.data = ret_data
response.note = {
'total_amount_funds':
'资金总额',
'count':
'数据总数',
'total_number_orders':
'订单总数',
'data_list': [
{
'consumption_type': '消费类型',
'consumer_user': '******',
'create_date': '消费时间',
'price': '消费金额',
'order_number': '订单号',
},
],
}
# 销售数据
elif oper_type == 'sales_data':
objs = models.distribute_money_log.objects.filter(
inviter__enterprise_id=user_id).order_by('-create_date')
total_number_orders = objs.count() # 总订单
primary_distribution_orders = objs.filter(
status=1).count() # 一级订单
Secondary_distribution_orders = objs.filter(
status=2).count() # 二级订单
data_list = []
for obj in objs:
data_list.append({
'distribution_level':
obj.get_status_display(),
'name':
b64decode(obj.user.name),
'inviter__name':
b64decode(obj.inviter.name),
'price':
obj.price,
'money':
obj.money,
'create_date':
obj.create_date.strftime('%Y-%m-%d %H:%M:%S'),
})
count = len(data_list)
if length != 0:
start_line = (current_page - 1) * length
stop_line = start_line + length
data_list = data_list[start_line:stop_line]
ret_data = {
'total_number_orders': total_number_orders,
'primary_distribution_orders': primary_distribution_orders,
'Secondary_distribution_orders':
Secondary_distribution_orders,
'data_list': data_list,
'count': count,
}
response.code = 200
response.msg = '查询成功'
response.data = ret_data
response.note = {
'total_number_orders':
'总订单',
'primary_distribution_orders':
'一级订单',
'Secondary_distribution_orders':
'二级订单',
'count':
'数据总数',
'data_list': [{
'distribution_level': '分销级别',
'name': '充值人名称',
'price': '充值金额',
'money': '分销金额',
'create_date': '创建时间',
'inviter__name': '分销人名称',
}],
}
# 提现数据
elif oper_type == 'withdrawal_data':
objs = models.withdrawal_log.objects.filter(
user__enterprise_id=user_id,
is_success=1).order_by('-create_date')
total_amount_withdrawal = objs.count()
data_list = []
for obj in objs:
is_success = '提现失败'
if obj.is_success:
is_success = '提现成功'
data_list.append({
'create_date':
obj.create_date.strftime('%Y-%m-%d %H:%M:%S'),
'withdrawal_befor':
obj.withdrawal_befor, # 提现前 余额
'withdrawal_amount':
obj.withdrawal_amount, # 提现 金额
'withdrawal_after':
obj.withdrawal_after, # 提现后 余额
'is_success':
is_success,
'wechat_returns_data':
obj.wechat_returns_data,
'name':
b64decode(obj.user.name),
'order_number':
obj.dingdanhao
})
count = len(data_list)
if length != 0:
start_line = (current_page - 1) * length
stop_line = start_line + length
data_list = data_list[start_line:stop_line]
response.code = 200
response.msg = '查询成功'
response.data = {
'total_amount_withdrawal': total_amount_withdrawal,
'data_list': data_list,
'count': count,
}
response.note = {
'total_amount_withdrawal':
'销售总额',
'count':
'数据总数',
'data_list': [{
'create_date': '提现时间',
'withdrawal_befor': '提现前 余额',
'withdrawal_amount': '提现 金额',
'withdrawal_after': '提现后 余额',
'is_success': '是否成功',
'wechat_returns_data': '失败原因',
'name': '提现人名称',
'order_number': '提现订单号'
}]
}
else:
response.code = 301
response.msg = json.loads(forms_obj.error.as_json())
else:
if oper_type == '':
print('--')
else:
response.code = 402
response.msg = '请求异常'
return JsonResponse(response.__dict__)
def wechat_oper(request, oper_type):
response = Response.ResponseObj()
# print('request.GET---------------> ', request.GET)
user_id = request.GET.get('user_id')
if request.method == "POST":
pass
else:
# 邀请成员页面展示信息
if oper_type == "invite_members":
# print('request.GET=====invite_members------------invite_members------------invite_members====', request.GET)
team_id = request.GET.get('team_id')
inviter_user_id = request.GET.get('inviter_user_id') # 用户ID
redirect_uri = '{host_url}api/invite_members/invitation_page/{o_id}'.format(
host_url=host_url,
o_id=team_id, # 团队ID
)
if inviter_user_id: # 多次转发
redirect_url = forwarding_article(
pub=1,
redirect_uri=redirect_uri,
inviter_user_id=inviter_user_id)
user_id = inviter_user_id
else: # 首次转发
# 第一次链接 接收邀请页面
redirect_url = forwarding_article(pub=1,
redirect_uri=redirect_uri,
user_id=user_id)
obj = models.UserprofileTeam.objects.select_related(
'team', 'user').get(team_id=team_id, user_id=user_id)
team_name = obj.team.name # 团队名称
user_name = base64_encryption.b64decode(obj.user.name) # 客户名称
set_avator = obj.user.set_avator # 客户头像
response.code = 200
response.data = {
"open_weixin_url": redirect_url,
"team_id": team_id,
"team_name": team_name,
"user_name": user_name,
"set_avator": set_avator
}
response.note = {
"open_weixin_url": "分享邀请成员URL",
"team_name": "团队名称",
"user_name": "邀请人名称",
"set_avator": "邀请人头像"
}
# 用户分享文章①
elif oper_type == 'forwarding_article':
article_id = request.GET.get('article_id')
inviter_user_id = request.GET.get(
'inviter_user_id') # 二级以上文章转发 需要传递用户ID
pub = 'article_' + str(article_id)
if inviter_user_id: # 二次转发及以上
open_weixin_url = forwarding_article(
pub=pub, inviter_user_id=inviter_user_id)
else: # 首次转发
open_weixin_url = forwarding_article(
user_id=user_id,
pub=pub,
)
response.code = 200
response.msg = '转发成功'
response.data = {'open_weixin_url': open_weixin_url}
# 用户分享微店宝贝①
elif oper_type == 'share_micro_store':
micro_store_baby = request.GET.get('micro_store_baby') # 宝贝ID
inviter_user_id = request.GET.get(
'inviter_user_id') # 二级以上微店宝贝转发 需要传递用户ID
pub = 'micro_' + str(micro_store_baby)
if inviter_user_id:
open_weixin_url = forwarding_article(
inviter_user_id=inviter_user_id,
pub=pub,
)
else:
open_weixin_url = forwarding_article(
user_id=user_id,
pub=pub,
)
response.code = 200
response.msg = '转发成功'
response.data = {'open_weixin_url': open_weixin_url}
# 用户分享名片①
elif oper_type == 'share_business_card':
inviter_user_id = request.GET.get(
'inviter_user_id') # 二级以上微店宝贝转发 需要传递用户ID
pub = 'card'
if inviter_user_id:
open_weixin_url = forwarding_article(
inviter_user_id=inviter_user_id,
pub=pub,
)
else:
open_weixin_url = forwarding_article(
user_id=user_id,
pub=pub,
)
response.code = 200
response.msg = '转发成功'
response.data = {'open_weixin_url': open_weixin_url}
# 分享的链接 跳转②
elif oper_type == 'redirect_url':
share_url = request.GET.get('share_url')
redirect_uri = request.GET.get('redirect_uri')
scope = request.GET.get('scope')
state = request.GET.get('state')
response_type = request.GET.get('response_type')
if redirect_uri:
redirect_url = str(share_url) + '&redirect_uri=' + str(
redirect_uri) + '&response_type=' + str(
response_type) + '&scope=' + str(
scope) + '&state=' + str(state)
else:
redirect_url = share_url
return redirect(redirect_url)
return JsonResponse(response.__dict__)
def customer_invite_members(request, oper_type, o_id):
response = Response.ResponseObj()
print('rinvite_qrcodeequest.GET-----------> ', request.GET)
print('rinvite_qrcodeequest.GET-----------> ', oper_type)
print('reinvite_qrcodequest.POST-----------> ', o_id)
# 客户点击确认邀请
if oper_type == 'invite_members':
code = request.GET.get('code')
code_objs = models.save_code.objects.filter(save_code=code)
if not code_objs:
models.save_code.objects.create(save_code=code)
team_id = o_id # 团队id
inviter_user_id = request.GET.get('state') # 邀请人id
data = get_ent_info(inviter_user_id)
weichat_api_obj = weixin_gongzhonghao_api.WeChatApi(data)
ret_obj = weichat_api_obj.get_openid(code)
openid = ret_obj.get('openid')
user_id = updateUserInfo(openid, inviter_user_id, ret_obj)
# 添加该成员到团队中
objs = models.UserprofileTeam.objects.filter(team_id=team_id,
user_id=user_id)
if not objs:
models.UserprofileTeam.objects.create(team_id=team_id,
user_id=user_id)
obj = models.Userprofile.objects.get(id=user_id)
# 此处跳转到天眼首页
url = 'http://zhugeleida.zhugeyingxiao.com/tianyan/#/?token={token}&user_id={user_id}&classify_type=1'.format(
token=obj.token, user_id=user_id)
response.code = 200
response.msg = "邀请成功"
return redirect(url)
# 邀请成员页面跳转 显示确认邀请页面
elif oper_type == 'invitation_page':
user_id = request.GET.get('state')
obj = models.UserprofileTeam.objects.select_related(
'team', 'user').get(team_id=o_id, user_id=user_id)
team_name = obj.team.name # 团队名称
user_name = base64_encryption.b64decode(obj.user.name) # 客户名称
set_avator = obj.user.set_avator # 客户头像
url = '{host_url}api/invite_members/invite_members/{o_id}'.format(
host_url=host_url,
o_id=o_id, # 团队ID
)
url = forwarding_article(pub=1, user_id=user_id, redirect_uri=url)
redirect_url = '{host_url}#/share_invited_member?team_name={team_name}&user_name={user_name}&set_avator={set_avator}&inviter_user_id={inviter_user_id}&team_id={team_id}&open_weixin_url={open_weixin_url}'.format(
host_url=host_url,
team_name=team_name,
user_name=user_name,
set_avator=set_avator,
open_weixin_url=url,
team_id=o_id,
inviter_user_id=user_id,
)
print('redirect_url============================> ', redirect_url)
print('redirect_url============================> ',
unquote(redirect_url))
return redirect(redirect_url)
return JsonResponse(response.__dict__)
def posters_oper(request, oper_type, o_id):
response = Response.ResponseObj()
user_id = request.GET.get('user_id')
if request.method == "POST":
form_data = {
'o_id': o_id,
'create_user_id': user_id,
'posters_url': request.POST.get('posters_url'),
'posters_status': request.POST.get('posters_status', 1),
}
# 添加海报
if oper_type == "add":
forms_obj = AddForm(form_data)
if forms_obj.is_valid():
print("验证通过")
obj = models.Posters.objects.create(**forms_obj.cleaned_data)
response.code = 200
response.msg = "添加成功"
response.data = {'id': obj.id}
else:
print("验证不通过")
response.code = 301
response.msg = json.loads(forms_obj.errors.as_json())
# 修改海报
elif oper_type == "update":
forms_obj = UpdateForm(form_data)
if forms_obj.is_valid():
print("验证通过")
o_id, objs = forms_obj.cleaned_data['o_id']
posters_url = forms_obj.cleaned_data['posters_url']
posters_status = forms_obj.cleaned_data['posters_status']
objs.update(posters_url=posters_url,
posters_status=posters_status)
response.code = 200
response.msg = "修改成功"
else:
print("验证不通过")
response.code = 301
response.msg = json.loads(forms_obj.errors.as_json())
# 删除海报
elif oper_type == "delete":
# 删除 ID
objs = models.Posters.objects.filter(id=o_id)
if objs:
objs.delete()
response.code = 200
response.msg = "删除成功"
else:
response.code = 302
response.msg = '删除ID不存在'
# 修改海报信息
# elif oper_type == 'update_poster_info':
# form_data = {
# 'title': request.POST.get('title'), # 正标题
# 'subtitle': request.POST.get('subtitle'), # 副标题
# 'name': request.POST.get('name'), # 姓名
# 'phone': request.POST.get('phone'), # 电话
# 'time': request.POST.get('time'), # 时间
# 'place': request.POST.get('place'), # 地点
# }
#
# PosterObj = UpdatePosterInfoForm(form_data)
# if PosterObj.is_valid():
# objs = models.Userprofile.objects.filter(id=user_id)
# objs.update(posters_info=PosterObj.data)
# response.code = 200
# response.msg = '修改成功'
# else:
# response.code = 301
# response.msg = json.loads(PosterObj.errors.as_json())
else:
# 海报打水印
if oper_type == 'play_watermark':
posters_status = request.GET.get('posters_status') # 水印类型
posters_objs = models.Posters.objects.filter(id=o_id)
if posters_objs:
img_path = posters_objs[0].posters_url # 海报地址
posters_status = int(posters_status)
if posters_status == 1:
obj = models.Userprofile.objects.get(id=user_id)
data = {
'img_path': img_path,
'heading': obj.set_avator + '?imageView2/2/w/300',
'name': b64decode(obj.name),
'phone': obj.phone_number,
'posters_status': posters_status,
}
watermark_objs = watermark(data) # 实例化
path = watermark_objs.posters_play_watermark()
response.code = 200
response.data = {'path': path}
else:
place = request.GET.get('place') # 地址
time = request.GET.get('time') # 时间
fu_title = request.GET.get('subtitle') # 副标题
zhu_title = request.GET.get('title') # 主标题
name = request.GET.get('name') # 姓名
phone = request.GET.get('phone') # 电话
data = {
'posters_status': posters_status,
'img_path': img_path,
'name': name,
'phone': phone,
'zhu_title': zhu_title,
'fu_title': fu_title,
'time': time,
'place': place,
}
form = posterInfoForm(data)
if form.is_valid():
watermark_objs = watermark(data) # 实例化
path = watermark_objs.posters_play_watermark()
response.code = 200
response.msg = '生成成功'
response.data = {'path': path}
else:
response.code = 301
response.msg = json.loads(form.errors.as_json())
else:
response.code = 301
response.msg = '海报被删除'
else:
response.code = 402
response.msg = "请求异常"
return JsonResponse(response.__dict__)
def comment_management(request, oper_type):
response = Response.ResponseObj()
user_id = request.GET.get('user_id')
if request.method == 'POST':
# 手机端添加接口 (获取用户的评论内容提交到接口保存)③
if oper_type == "mobile_phone_reviews":
iccid = request.POST.get('iccid')
imsi = request.POST.get('imsi')
objs = models.XiaohongshuPhone.objects.filter(
iccid=iccid,
imsi=imsi
)
if not objs:
response.code = 301
response.msg = '该设备不存在'
else:
obj = objs[0]
user_objs = obj.xiaohongshuuserprofile_set.all()
if not user_objs:
response.code = 301
response.msg = '该设备 未关联小红书客户'
else:
xhs_user_id = user_objs[0].id
form_data = {
'xhs_user_id': xhs_user_id, # 小红书用户
'head_portrait': request.POST.get('head_portrait'), # 头像
'nick_name': request.POST.get('nick_name'), # 昵称
'comments_status': request.POST.get('comments_status'), # 评论类型
'comments_content': request.POST.get('comments_content'), # 评论内容
'article_picture_address': request.POST.get('article_picture_address'), # 文章图片地址
'article_notes_id': request.POST.get('article_notes_id'), # 文章笔记
'screenshots_address': request.POST.get('screenshots_address'), # 截图地址
}
forms_obj = mobilePhoneReviews(form_data)
if forms_obj.is_valid():
forms_data = forms_obj.cleaned_data
article_picture_address = forms_data.get('article_picture_address')
nick_name = forms_data.get('nick_name')
comments_content = forms_data.get('comments_content')
response.code = 200
rule_not_message_flag = True # 是否创建
rule_not_message = ['通知消息', '已被删除', '违规', '收藏', '新增关注', '评记']
for i in rule_not_message:
if i in comments_content:
rule_not_message_flag = False
break
article_notes_id = forms_data.get('article_notes_id')
if rule_not_message_flag and article_picture_address: # 如果没有截图不记录
objs = models.littleRedBookReviewForm.objects.filter(
xhs_user_id=xhs_user_id,
nick_name=nick_name,
comments_content=comments_content
)
print("**forms_obj.cleaned_data -->", forms_obj.cleaned_data)
if not objs and forms_data.get('comments_content') != "该评论已被删除":
obj = models.littleRedBookReviewForm.objects.create(**forms_obj.cleaned_data)
# 异步传递给小红书后台
form_data['link'] = forms_data.get('screenshots_address')
form_data['name'] = forms_data.get('nick_name')
form_data['content'] = forms_data.get('comments_content')
form_data['head_portrait'] = forms_data.get('head_portrait')
form_data['comment_id'] = obj.id
form_data['id'] = article_notes_id
form_data['transfer_type'] = 1 # 传递到小红书后台
form_data['platform'] = obj.xhs_user.platform
asynchronous_transfer_data.delay(form_data)
response.msg = '创建成功'
else:
response.msg = '通知消息, 未收录'
else:
response.code = 301
response.msg = json.loads(forms_obj.errors.as_json())
create_xhs_admin_response(request, response, 3) # 创建请求日志(手机)
# 创建回复评论 小红书后台添加接口 (博主回复内容)④
elif oper_type == 'reply_comment':
form_data = {
'comment_id': request.POST.get('comment_id'), # 回复哪个评论ID
'comment_type': request.POST.get('comment_type'), # (回复评论类型 1回复评论 2 回复私信)
'comment_response': request.POST.get('comment_response'), # 回复评论内容
}
forms_obj = ReplyCommentForm(form_data)
if forms_obj.is_valid():
comment_type = forms_obj.cleaned_data.get('comment_type')
is_perform = True
# if comment_type in [2, '2']:
# is_perform = False
data = {
'comment_id': forms_obj.cleaned_data.get('comment_id'),
'comment_response': forms_obj.cleaned_data.get('comment_response'),
'comment_type': comment_type,
'is_perform': is_perform,
}
print(data)
obj = models.commentResponseForm.objects.create(**data)
response.code = 200
response.msg = '创建成功'
response.data = obj.id
else:
response.code = 301
response.msg = json.loads(forms_obj.errors.as_json())
create_xhs_admin_response(request, response, 2) # 创建请求日志(小红书后台请求后台)
# 刪除评论(小红书请求)
elif oper_type == 'delete_comment':
form_data = {
'comment_id': request.POST.get('comment_id'), # 删除哪个评论ID
}
form_obj = DeleteComment(form_data)
if form_obj.is_valid():
comment_id, objs = form_obj.cleaned_data.get('comment_id')
delete = 2
if objs[0].comments_content in ['该评论已被删除', '该评论违规']:
models.commentResponseForm.objects.filter(comment=objs).delete()
delete = 3
msg = '删除成功'
code = 0
else:
code = 200
msg = '操作成功, 等待删除...'
objs.update(delete=delete)
response.code = code
response.msg = msg
else:
response.code = 301
response.msg = json.loads(form_obj.errors.as_json())
create_xhs_admin_response(request, response, 2) # 创建请求日志(小红书后台请求后台)
# 手机端 删除评论是否完成
elif oper_type == 'reply_comment_is_delete':
id = request.POST.get('comment_id') # 删除的消息ID
objs = models.littleRedBookReviewForm.objects.filter(
id=id
)
if objs:
models.commentResponseForm.objects.filter(comment_id=id).delete()
objs.update(
delete=3
)
data = {
'transfer_type': 4,
'id': id
}
asynchronous_transfer_data.delay(data)
create_xhs_admin_response(request, response, 3) # 创建请求日志(手机端)
response.code = 200
response.msg = '操作完成'
# 手机端 通知回复消息完成时间⑥
elif oper_type == 'reply_comment_is_success':
now = datetime.datetime.today()
form_data = {
'id': request.POST.get('comment_id'), # 回复的消息ID
'comment_completion_time': request.POST.get('comment_completion_time', now), # 完成时间
}
form_objs = ReplyCommentIsSuccess(form_data)
if form_objs.is_valid():
comment_id = form_objs.cleaned_data.get('id')
comment_completion_time = form_objs.cleaned_data.get('comment_completion_time')
objs = models.commentResponseForm.objects.filter(id=comment_id)
objs.update(
comment_completion_time=comment_completion_time
)
response.code = 200
response.msg = '成功'
# 异步传递给小红书后台
form_data['transfer_type'] = 2
form_data['platform'] = objs[0].comment.xhs_user.platform
asynchronous_transfer_data.delay(form_data)
else:
response.code = 301
response.msg = json.loads(form_objs.errors.as_json())
create_xhs_admin_response(request, response, 3) # 创建请求日志(手机端)
# 关联 笔记链接 和 文章截图②
elif oper_type == 'associated_screenshots':
form_data = {
'notes_url': request.POST.get('notes_url'), # 笔记回链
'screenshots': request.POST.get('screenshots') # 文章截图
}
print('form_data-----------> ', form_data)
code = 301
form_obj = AssociatedScreenshots(form_data)
if form_obj.is_valid():
forms_data = form_obj.cleaned_data
screenshots = forms_data.get('screenshots')
screenshots = screenshots.split('?')[0]
notes_url, biji_id = forms_data.get('notes_url')
objs = models.noteAssociationScreenshot.objects.filter(
screenshots=screenshots,
notes_id=biji_id
)
if not objs:
models.noteAssociationScreenshot.objects.create(
screenshots=screenshots,
notes_id=biji_id
)
code = 200
msg = '关联成功'
response.data = biji_id
else:
code = 200
msg = '重复关联'
response.data = biji_id
else:
iccid = request.POST.get('iccid')
imsi = request.POST.get('imsi')
phone_objs = models.XiaohongshuPhone.objects.filter(iccid=iccid, imsi=imsi)
device_number = '设备不存在, iccid:{}, imsi:{}'.format(iccid, imsi)
if phone_objs:
device_number = phone_objs[0].name
content = '{datetime}关联笔记截图异常, \n设备号:{device_number}, \n笔记回链:{notes_url}'.format(
datetime=datetime.datetime.today(),
device_number=device_number,
notes_url=form_data.get('notes_url')
)
send_error_msg(content, 2)
msg = json.loads(form_obj.errors.as_json())
response.code = code
response.msg = msg
create_xhs_admin_response(request, response, 3) # 创建请求日志(手机端)
# 修改 回复(管理/私信) 是否开放
elif oper_type == 'whether_the_modification_open':
comment_id = request.POST.get('comment_id')
objs = models.commentResponseForm.objects.filter(id=comment_id)
if objs:
obj = objs[0]
obj.is_perform = bool(1-obj.is_perform)
obj.save()
response.code = 200
response.msg = '修改成功'
else:
response.code = 301
response.msg = '修改的任务不存在'
# 回复评论管理 发布异常(手机)
elif oper_type == 'comment_management_changed_publish_exceptions':
comment_id = request.POST.get('comment_id')
objs = models.commentResponseForm.objects.filter(
id=comment_id,
comment_completion_time__isnull=True
)
if objs:
objs.update(
is_error=True,
comment_completion_time=datetime.datetime.today()
)
response.code = 200
response.msg = '发布异常成功'
else:
response.code = 301
response.msg = '该任务不存在或已发布'
# 回复评论管理 发布正常(后台)
elif oper_type == 'reply_comment_management_release_normal':
comment_id = request.POST.get('comment_id')
objs = models.commentResponseForm.objects.filter(id=comment_id)
if objs:
objs.update(
is_error=False,
comment_completion_time=None,
)
response.code = 200
response.msg = '重新发布成功'
else:
response.code = 301
response.msg = '该任务不存在'
# 评论改为删除异常 (手机)
elif oper_type == 'comment_post_exception_instead':
comment_id = request.POST.get('comment_id')
objs = models.littleRedBookReviewForm.objects.filter(id=comment_id)
if objs and objs[0].is_error == False:
objs.update(is_error=True)
response.code = 200
response.msg = '删除异常成功'
else:
if objs:
response.msg = '该评论不存在'
else:
response.msg = '该评论已经为删除异常'
response.code = 301
"""当 手机找不到 评论 和 回复评论 时 改为发布异常"""
else:
order = request.GET.get('order', '-create_datetime')
# 查询 截图和 笔记是否关联①
if oper_type == 'determine_correlation':
flag = False
iccid = request.GET.get('iccid')
imsi = request.GET.get('imsi')
screenshots = request.GET.get('screenshots') # 文章截图
# notes_url = request.GET.get('notes_url') # 笔记回链
biji_id = ''
if screenshots:
objs = models.noteAssociationScreenshot.objects.filter(
screenshots=screenshots,
notes__user_id__phone_id__iccid=iccid,
notes__user_id__phone_id__imsi=imsi,
)
if objs:
obj = objs[0]
biji_id = obj.notes_id
flag = True
response.code = 200
response.msg = '查询完成'
response.data = {
'flag': flag,
'biji_id': biji_id
}
else:
response.code = 301
response.msg = '参数异常'
create_xhs_admin_response(request, response, 3) # 创建请求日志(手机端)
# 查询回复任务（手机）⑤
elif oper_type == 'query_reply_task':
form_data = {
'imsi': request.GET.get('imsi'),
'iccid': request.GET.get('iccid'),
'platform': request.GET.get('platform', 1),
}
form_obj = QueryReplyTask(form_data)
if form_obj.is_valid():
iccid = form_obj.cleaned_data.get('iccid')
platform = form_obj.cleaned_data.get('platform')
objs = models.commentResponseForm.objects.select_related('comment').filter(
comment__xhs_user__phone_id_id=iccid,
comment_completion_time__isnull=True,
comment__isnull=False,
comment_response__isnull=False,
is_perform=True,
is_error=False,
comment__xhs_user__platform=platform
).order_by('create_datetime')
if objs:
obj = objs[0]
comment_response = obj.comment_response
ret_data = {
'comment_type': obj.comment_type,
'comments_content': obj.comment.comments_content,
'nick_name': obj.comment.nick_name,
'article_picture_address': obj.comment.article_picture_address,
'screenshots_address': obj.comment.screenshots_address,
'id': obj.id,
'platform': obj.comment.xhs_user.platform,
'comment_response': comment_response,
'create_datetime': obj.create_datetime.strftime('%Y-%m-%d %H:%M:%S'),
}
response.msg = '查询成功'
response.data = ret_data
response.note = {
'id': '回复评论ID',
'comment_response': '回复评论内容',
'create_datetime': '创建时间',
'screenshots_address': '文章截图',
'nick_name': '昵称',
'comments_content': '评论内容',
'comment_type': '评论类型 1为回复评论 2为回复私信',
}
else:
response.msg = '无任务'
response.code = 200
else:
response.code = 301
response.msg = json.loads(form_obj.errors.as_json())
create_xhs_admin_response(request, response, 3) # 创建请求日志(手机端)
# 查询删除评论任务(手机)
elif oper_type == 'query_delete_comment':
form_data = {
'imsi': request.GET.get('imsi'),
'iccid': request.GET.get('iccid'),
'platform': request.GET.get('platform'),
}
form_obj = QueryDeleteComment(form_data)
if form_obj.is_valid():
iccid = form_obj.cleaned_data.get('iccid')
platform = form_obj.cleaned_data.get('platform')
objs = models.littleRedBookReviewForm.objects.filter(
xhs_user__phone_id_id=iccid,
delete=2,
is_error=False,
xhs_user__platform=platform
)
data = {}
if objs:
obj = objs[0]
data = {
'id': obj.id,
'comments_content':obj.comments_content,
'screenshots_address':obj.screenshots_address,
'phone_name':obj.xhs_user.phone_id.name,
'user_name':obj.nick_name,
'platform':obj.xhs_user.platform,
}
else:
response.msg = '无任务'
response.code = 200
response.data = data
response.note = {
'id': '删除评论ID',
'comments_content': '删除评论',
'screenshots_address': '截图',
'phone_name': '设备名称',
'user_name': '小红书博主名称',
}
else:
response.code = 301
response.msg = json.loads(form_obj.errors.as_json())
create_xhs_admin_response(request, response, 3) # 创建请求日志(手机端)
# 查询评论（胡蓉后台）
elif oper_type == 'query_comments':
forms_obj = SelectForm(request.GET)
if forms_obj.is_valid():
current_page = forms_obj.cleaned_data['current_page']
length = forms_obj.cleaned_data['length']
field_dict = {
'id': '',
'comments_status': '',
'xhs_user_id': '',
'xhs_user__phone_id__name': '__contains',
'delete': '',
'xhs_user__name': '__contains',
'comments_content': '__contains',
'article_notes__isnull': '',
}
q = conditionCom(request, field_dict)
objs = models.littleRedBookReviewForm.objects.filter(q).order_by(order)
count = objs.count()
if length != 0:
start_line = (current_page - 1) * length
stop_line = start_line + length
objs = objs[start_line: stop_line]
ret_data = []
for obj in objs:
article_notes_title = ''
article_notes_id = ''
if obj.article_notes:
article_notes_id = obj.article_notes_id
article_notes_title = b64decode(obj.article_notes.title)
ret_data.append({
'id': obj.id,
'phone_name': obj.xhs_user.phone_id.name,
'phone_id': obj.xhs_user.phone_id_id,
'phone_number': obj.xhs_user.phone_id.phone_num,
'xhs_user_id': obj.xhs_user_id,
'xhs_user_name': obj.xhs_user.name,
'head_portrait': obj.head_portrait,
'screenshots_address': obj.screenshots_address,
'nick_name': obj.nick_name,
'comments_status_id': obj.comments_status,
'comments_status': obj.get_comments_status_display(),
'comments_content': obj.comments_content,
'article_picture_address': obj.article_picture_address,
'delete_id': obj.delete,
'delete': obj.get_delete_display(),
'article_notes_id': article_notes_id,
'article_notes_title': article_notes_title,
'create_datetime': obj.create_datetime.strftime('%Y-%m-%d %H:%M:%S'),
})
response.note = {
'xhs_user_id': '小红书用户ID',
'xhs_user_name': '小红书用户名称',
'head_portrait': '头像',
'nick_name': '昵称',
'comments_status_id': '评论类型ID',
'screenshots_address': '截图地址',
'comments_status': '评论类型',
'comments_content': '评论内容',
'article_picture_address': '文章图片地址',
'article_notes_id': '笔记ID',
'create_datetime': '创建时间',
}
response.code = 200
response.msg = '查询成功'
response.data = {
'ret_data':ret_data,
'count':count,
'comments_choices': [{'id':i[0], 'name':i[1]} for i in models.littleRedBookReviewForm.comments_choices],
'delete_choices': [{'id':i[0], 'name':i[1]} for i in models.littleRedBookReviewForm.delete_choices],
}
else:
response.code = 301
response.msg = json.loads(forms_obj.errors.as_json())
# 查询回复评论（胡蓉后台）
elif oper_type == 'query_reply_comment':
forms_obj = SelectForm(request.GET)
if forms_obj.is_valid():
current_page = forms_obj.cleaned_data['current_page']
length = forms_obj.cleaned_data['length']
field_dict = {
'id': '',
'comment_id': '',
'comment_type': '',
'comment_response': '',
'comment_completion_time': '__isnull',
'comment__xhs_user__name': '__contains',
'comment__xhs_user__phone_id__name': '__contains',
}
q = conditionCom(request, field_dict)
objs = models.commentResponseForm.objects.filter(q).order_by(order)
count = objs.count()
if length != 0:
start_line = (current_page - 1) * length
stop_line = start_line + length
objs = objs[start_line: stop_line]
ret_data = []
for obj in objs:
comment_completion_time = obj.comment_completion_time
if comment_completion_time:
comment_completion_time = obj.comment_completion_time.strftime('%Y-%m-%d %H:%M:%S')
phone_id = ''
phone_name = ''
phone_number = ''
if obj.comment.xhs_user.phone_id:
phone_id = obj.comment.xhs_user.phone_id_id
phone_name = obj.comment.xhs_user.phone_id.name
phone_number = obj.comment.xhs_user.phone_id.phone_num
try:
comment_response = str(base64.b64decode(obj.comment_response), 'utf8')
except Exception:
comment_response = obj.comment_response
ret_data.append({
'id': obj.id,
'phone_id': phone_id,
'phone_name': phone_name,
'phone_number': phone_number,
'xhs_user_name': obj.comment.xhs_user.name,
'nick_name': obj.comment.nick_name,
'head_portrait': obj.comment.head_portrait,
'comments_content': obj.comment.comments_content,
'comment_id': obj.comment_id,
'comment_response':comment_response,
'comment_type_id':obj.comment_type,
'comment_type':obj.get_comment_type_display(),
'is_perform':obj.is_perform,
'is_error':obj.is_error,
'comment_completion_time': comment_completion_time,
'create_datetime':obj.create_datetime.strftime('%Y-%m-%d %H:%M:%S')
})
response.code = 200
response.msg = '查询成功'
response.data = {
'ret_data': ret_data,
'count': count,
'comment_type_choices': [{'id':i[0], 'name':i[1]} for i in models.commentResponseForm.comment_type_choices]
}
# 查询评论最后一次更新时间
elif oper_type == 'query_when_comments_were_last_updated':
form_data = {
'iccid':request.GET.get('iccid'),
'imsi': request.GET.get('imsi')
}
objs = models.XiaohongshuPhone.objects.filter(**form_data)
if objs:
obj = objs[0]
comment_last_updated = obj.comment_last_updated
deletionTime = (datetime.datetime.today() - datetime.timedelta(hours=12)) # 当前时间减去12小时
more_than_12_hours = False
if comment_last_updated:
comment_last_updated = comment_last_updated.strftime('%Y-%m-%d %H:%M:%S')
if deletionTime > obj.comment_last_updated:
more_than_12_hours = True
else:
more_than_12_hours = True
response.data = {
'comment_last_updated': comment_last_updated,
'more_than_12_hours': more_than_12_hours,
}
response.note = {
'comment_last_updated': '最后一次提交评论时间',
'more_than_12_hours': '最后一次提交评论时间 是否超过12小时 True已超过 False未超过',
}
response.code = 200
# 手动关联评论/笔记 (胡蓉后台)
elif oper_type == 'manually_associate_comments_notes':
article_notes_id = request.GET.get('article_notes_id')
comment_id = request.GET.get('comment_id')
code = 301
objs = models.littleRedBookReviewForm.objects.filter(id=comment_id)
if objs:
if not models.XiaohongshuBiji.objects.filter(id=article_notes_id):
msg = '笔记不存在'
else:
objs.update(article_notes_id=article_notes_id)
code = 200
msg = '修改成功'
form_data = {
'transfer_type': 7,
'id': article_notes_id,
'comment_id': comment_id,
}
asynchronous_transfer_data.delay(form_data)
else:
msg = '评论不存在'
response.code = code
response.msg = msg
else:
response.code = 402
response.msg = '请求异常'
return JsonResponse(response.__dict__)
def external_login(request):
response = Response.ResponseObj()
external_token = request.GET.get('token') # 平台token
source = request.GET.get('source') # 来自哪个平台
userId = request.GET.get('userId') # 来自哪个平台
login_type = 2
is_login_flag = True
if source == 'dingdong': # 叮咚营销宝
pass
else:
is_login_flag = False
response.code = 402
response.msg = '请求错误'
if is_login_flag: # 验证通过
user_data = {
'role_id': 7, # 默认普通用户
'token': external_token,
'login_type': login_type,
'ding_dong_marketing_treasure_user_id': userId,
}
objs = models.UserProfile.objects.filter(token=external_token)
if objs:
obj = objs[0]
else:
get_user_info_url = 'http://a.yingxiaobao.org.cn/api/user/info/{}?token={}&user_id={}'.format(
userId, external_token, userId)
ret = requests.get(get_user_info_url)
info_data = ret.json().get('data')
user_data['username'] = base64_encryption.b64encode(
info_data.get('username'))
user_data['head_portrait'] = info_data.get('head_portrait')
obj = models.UserProfile.objects.create(**user_data)
role_obj = models.Role.objects.filter(id=obj.role_id)
data_list = []
for i in role_obj[0].permissions.all():
data_list.append(i.name)
inviter = 0
if obj.inviter:
inviter = 1
try:
username = base64_encryption.b64decode(obj.username)
except Exception:
username = obj.username
response.code = 200
response.msg = '登录成功'
response.data = {
'username': username,
'token': obj.token,
'id': obj.id,
'role_id': obj.role_id,
'role_name': obj.role.name,
'head_portrait': obj.head_portrait,
'permissions_list': data_list,
'inviter': inviter,
}
return JsonResponse(response.__dict__)
def customer_view_articles_send_msg(request):
response = Response.ResponseObj()
try:
check_type = request.POST.get('check_type')
title = request.POST.get('title')
customer_id = request.POST.get('customer_id')
user_id = request.POST.get('user_id')
if is_send_msg(user_id):
user_obj = models.Userprofile.objects.get(id=user_id)
customer_obj = models.Customer.objects.get(id=customer_id)
# 区分普通用户和 会员用户 会员用户发送查看人名称
if user_obj.overdue_date >= datetime.date.today():
msg = '有人看了您的{}\n\n《{}》\n查看人:{}\n\n查看点击下方【天眼】\n{}'.format(
check_type, title, b64decode(customer_obj.name), xiajiantou
)
else:
msg = '有人看了您的{}\n\n《{}》\n\n查看点击下方【天眼】\n{}'.format(
check_type, title, xiajiantou
)
user_info = get_ent_info(user_id)
weixin_objs = WeChatApi(user_info)
post_data = {
"touser": user_info.get('openid'),
"msgtype": "text",
"text": {
"content":msg
}
}
# 发送客服消息
print('-------------记录最后一次发送时间')
post_data = bytes(json.dumps(post_data, ensure_ascii=False), encoding='utf-8')
weixin_objs.news_service(post_data)
user_obj.last_message_remind_time = datetime.datetime.now()
user_obj.save()
response.code = 200
else:
send_msg_objs = models.summary_message_reminder.objects.filter(
user_id=user_id,
customer_id=customer_id,
title=title,
check_type=check_type,
is_send=0
)
if send_msg_objs:
send_msg_objs.update(
select_num = F('select_num') + 1
)
else:
models.summary_message_reminder.objects.create(
user_id=user_id,
customer_id=customer_id,
title=title,
check_type=check_type,
)
except Exception as e:
msg = '警告:{}, \n错误:{}, \n时间:{}'.format(
'celery_客户查看 文章/微店 给用户发送消息---警告',
e,
datetime.datetime.today()
)
celery_error_warning(msg)
return JsonResponse(response.__dict__)
def article(request):
response = Response.ResponseObj()
user_id = request.GET.get('user_id')
team_list = request.GET.get('team_list')
if request.method == "GET":
forms_obj = SelectForm(request.GET)
if forms_obj.is_valid():
redis_key = 'tianyan_article_fixed_{}'.format(user_id)
rc = redis.StrictRedis(host='redis_host',
port=6379,
db=7,
decode_responses=True)
current_page = forms_obj.cleaned_data['current_page']
length = forms_obj.cleaned_data['length']
field_dict = {
'id': '',
'title': '__contains',
'classify': '',
'create_user_id': '__in',
'create_datetime': '',
'source_link': '',
}
q = conditionCom(request, field_dict)
user_obj = models.Userprofile.objects.get(id=user_id)
"""
用户查看文章页面时 点击别的操作 会刷新页面 需求： 点击别的操作不刷新页面 数据还是原来的 只有点击刷新 才变页面数据
解决方法：{
每个人一个ID 如：article_fixed_{user_id}，
每次查询 未传 fixed_content 参数情况下 推荐查询 记录本次数据 返回查询码，
传递 fixed_content 参数 查询上次数据，
传递 fixed_content 参数 且 传递add_fixed_content参数 单做查询 插入原有固定数据 证明翻页
redis-hash数据 name:tianyan_article_fixed_content key:tianyan_article_fixed_{user_id}
}
"""
fixed_content = request.GET.get(
'fixed_content') # 固定内容键 查询上次查询过的数据
add_fixed_content = request.GET.get(
'add_fixed_content') # 下拉固定内容 添加固定内容
if fixed_content and not add_fixed_content: # 查询上次内容 且未下拉
data = rc.hget('tianyan_article_fixed_content', redis_key)
ret_data = eval(data)
count = len(ret_data)
if length != 0:
start_line = (current_page - 1) * length
stop_line = start_line + length
ret_data = ret_data[start_line:stop_line]
else:
classify_type = forms_obj.cleaned_data.get(
'classify_type') # 分类类型，1 => 推荐, 2 => 品牌
classify_id_list = []
if classify_type:
classify_objs = None
if classify_type == 1: # 推荐分类
classify_objs = user_obj.recommend_classify.all()
classify_id_list = [obj.id for obj in classify_objs]
if len(classify_id_list) > 0:
q.add(Q(**{'classify__in': classify_id_list}),
Q.AND)
elif classify_type == 2: # 品牌分类
classify_objs = user_obj.brand_classify.all()
classify_id_list = [obj.id for obj in classify_objs]
q.add(Q(**{'classify__in': classify_id_list}), Q.AND)
# 团队
if team_list and len(team_list) >= 1:
article_list = []
team_objs = models.UserprofileTeam.objects.filter(
user_id=user_id) # 查询出该用户所有团队
team_id_list = []
for i in team_objs:
team_id_list.append(i.team_id)
# 查询出该团队所有用户 去重
team_objs = models.UserprofileTeam.objects.filter(
team_id__in=team_id_list).values('user_id').distinct()
team_user_list = []
for team_obj in team_objs:
team_user_list.append(team_obj['user_id'])
# 查询 该团队所有用户文章
team_user_objs = models.Article.objects.filter(
create_user_id__in=team_user_list,
ownership_team_id__in=team_id_list) # 查询该团队 所有文章
for i in team_user_objs:
article_list.append(i.id)
q.add(Q(**{'id__in': article_list}), Q.AND)
is_use_redis = False # 是否进行redis操作
if classify_type and classify_type == 2: # 我的品牌
order_by = '-create_datetime'
elif classify_type and classify_type == 1 and len(
classify_id_list) <= 0: # 推荐为空
q.add(
Q(classify__create_user__isnull=True)
& Q(classify__isnull=False),
Q.AND) # 没有选择推荐的用户默认 推荐系统标签的
order_by = '?'
is_use_redis = True
elif team_list: # 团队
# q.add(Q(create_user_id=user_id), Q.OR)
order_by = '-like_num'
else:
is_use_redis = True
order_by = '?'
objs = models.Article.objects.filter(q, ).order_by(order_by)
print('q -->', q, order_by)
count = objs.count()
if length != 0:
start_line = (current_page - 1) * length
stop_line = start_line + length
objs = objs[start_line:stop_line]
ret_data = []
id = request.GET.get('id')
# 返回的数据
for obj in objs:
is_like = False # 是否点赞
log_obj = models.SelectClickArticleLog.objects.filter(
article_id=obj.id, user_id=user_id)
if log_obj:
is_like = True
classify_id_list = []
classify_name_list = []
if obj.classify:
classify_id_list = [
obj.get('id') for obj in obj.classify.values('id')
]
classify_name_list = [
obj.get('name')
for obj in obj.classify.values('name')
]
summary = obj.summary
if obj.summary:
summary = b64decode(obj.summary)
result_data = {
'id':
obj.id,
'title':
obj.title,
'summary':
summary,
'look_num':
obj.look_num,
'like_num':
obj.like_num,
'classify_id_list':
classify_id_list,
'classify_name_list':
classify_name_list,
'create_user_id':
obj.create_user_id,
'cover_img':
obj.cover_img,
'is_like':
is_like, # 是否点赞
'create_datetime':
obj.create_datetime.strftime('%Y-%m-%d %H:%M:%S'),
}
if id: # 如果查询详情 返回文章内容 查询全部不返回 否则数据过大
result_data[
'top_advertising'] = user_obj.top_advertising # 头部广告
result_data[
'end_advertising'] = user_obj.end_advertising # 底部广告
is_oneself_article = False
if user_id == obj.create_user_id:
is_oneself_article = True
result_data['is_oneself_article'] = is_oneself_article
result_data['content'] = json.loads(obj.content)
result_data['style'] = obj.style
# 个人信息
result_data['name'] = b64decode(user_obj.name) # 用户名称
result_data[
'phone_number'] = user_obj.phone_number # 用户电话
result_data['signature'] = user_obj.signature # 用户签名
result_data['set_avator'] = user_obj.set_avator # 用户头像
brand_name_list = []
for i in user_obj.brand_classify.all():
brand_name_list.append(i.name)
result_data['brand_name'] = brand_name_list # 用户品牌
result_data['qr_code'] = user_obj.qr_code # 用户微信二维码
# 用户查看文章 客户字段为空 判断今天是否看过此文章 看过不记录
now = datetime.datetime.today().strftime(
'%Y-%m-%d') + ' 00:00:00'
log_objs = models.SelectArticleLog.objects.filter(
article_id=id,
inviter_id=user_id,
create_datetime__gte=now)
if not log_objs:
models.SelectArticleLog.objects.create(
article_id=id, inviter_id=user_id)
# 记录查看次数
obj.look_num = F('look_num') + 1
obj.save()
# 热卖商品 我的里面设置是否展示
goods_list = []
if user_obj.show_product:
good_objs = models.Goods.objects.filter(
goods_classify__oper_user_id=user_id)
good_count = good_objs.count()
if good_count >= 2:
good_objs = good_objs[0:2]
elif good_count <= 0:
good_objs = good_objs
else:
good_objs = good_objs[0:1]
for good_obj in good_objs:
goods_list.append({
'id':
good_obj.id,
# 'goods_describe': good_obj.goods_describe, # 商品描述
'price':
good_obj.price, # 商品价格
'goods_name':
good_obj.goods_name, # 商品名称
'cover_img':
good_obj.cover_img, # 封面图
})
result_data['goods_list'] = goods_list
if team_list and len(
team_list) >= 1: # 如果查询 团队 则返回 文章创建人头像和名称
result_data['create_user__name'] = obj.create_user.name
result_data[
'create_user__set_avator'] = obj.create_user.set_avator
team_list_name = []
# if obj.ownership_team:
team_list_name.append(obj.ownership_team.name)
# else:
# team_list_name.append('创建')
result_data['team_list_name'] = team_list_name
# 将查询出来的数据 加入列表
ret_data.append(result_data)
if is_use_redis: # 进行redis缓存
if not add_fixed_content: # 加入redis
rc.hset('tianyan_article_fixed_content', redis_key,
str(ret_data))
else:
data = rc.hget('tianyan_article_fixed_content',
redis_key) # 查询出所有缓存数据
rc_data = eval(data)
for i in ret_data: # 判断缓存是否有该数据 没有插入
if i not in rc_data:
rc_data.append(i)
rc.hset('tianyan_article_fixed_content', redis_key,
str(rc_data)) # 最终数据缓存进 redis
ret_data = eval(
rc.hget('tianyan_article_fixed_content',
redis_key)) # 查询数据
if length != 0:
start_line = (current_page - 1) * length
stop_line = start_line + length
ret_data = ret_data[start_line:stop_line]
response.code = 200
response.msg = '查询成功'
response.data = {
'ret_data': ret_data,
'data_count': count,
'rc': redis_key, # redis_key
}
response.note = {
'id': "文章id",
'title': "文章标题",
'content': "文章内容",
'look_num': "查看次数",
'like_num': "点赞(喜欢)次数",
'classify_id_list': "所属分类id",
'classify_name_list': "所属分类名称",
'create_datetime': "创建时间",
'cover_img': "封面图",
'create_user_id': "创建人ID",
'create_user__name': "创建人姓名",
'create_user__set_avator': "创建人头像",
'name': "用户名称",
'phone_number': "用户电话",
'signature': "用户个性签名",
'set_avator': "用户头像",
'brand_name': "用户品牌名称",
'qr_code': "用户微信二维码",
'is_oneself_article': "是否是自己的文章",
}
else:
response.code = 301
response.data = json.loads(forms_obj.errors.as_json())
else:
response.code = 402
response.msg = "请求异常"
return JsonResponse(response.__dict__)
def user(request):
response = Response.ResponseObj()
if request.method == "GET":
forms_obj = SelectForm(request.GET)
if forms_obj.is_valid():
user_id = request.GET.get('user_id')
current_page = forms_obj.cleaned_data['current_page']
length = forms_obj.cleaned_data['length']
print('forms_obj.cleaned_data -->', forms_obj.cleaned_data)
order = request.GET.get('order', '-create_datetime')
field_dict = {
'id': '',
}
q = conditionCom(request, field_dict)
print('q -->', q)
objs = models.UserProfile.objects.select_related('role').filter(
q, openid__isnull=False)
exclude_role_admin = request.GET.get('exclude_role_admin',
False) # 是否排除管理员角色
if exclude_role_admin:
role_admin_id_list = [6, 8] # 管理员角色id
objs = objs.exclude(role_id__in=role_admin_id_list)
exclude_role_client = request.GET.get('exclude_role_client',
False) # 是否排除普通用户角色
if exclude_role_client:
role_client_id_list = [7] # 普通用户角色id
objs = objs.exclude(role_id__in=role_client_id_list)
inviter_id_is_null = request.GET.get('inviter_id_is_null', False)
if inviter_id_is_null:
objs = objs.filter(inviter_id__isnull=True)
objs = objs.order_by(order)
count = objs.count()
if length != 0:
start_line = (current_page - 1) * length
stop_line = start_line + length
objs = objs[start_line:stop_line]
ret_data = []
for obj in objs:
inviter = 0
if obj.inviter:
inviter = 1
role_obj = models.Role.objects.filter(id=obj.role_id)
data_list = []
for i in role_obj[0].permissions.all():
data_list.append(i.name)
last_login_datetime = ''
if obj.last_login_datetime:
last_login_datetime = obj.last_login_datetime.strftime(
'%Y-%m-%d %H:%M:%S')
ret_data.append({
'id':
obj.id,
'name':
base64_encryption.b64decode(obj.name),
'role_id':
obj.role_id,
'role_name':
obj.role.name,
'head_portrait':
obj.head_portrait,
'token':
obj.token,
'sex_id':
obj.sex,
'sex':
obj.get_sex_display(),
'company_name':
obj.company_name,
'permissions_list':
data_list,
'inviter':
inviter,
'remark':
obj.remark,
'small_program_number':
obj.small_program_number,
'number_child_users':
obj.number_child_users,
'last_login_datetime':
last_login_datetime,
'create_datetime':
obj.create_datetime.strftime('%Y-%m-%d %H:%M:%S'),
})
# 查询成功 返回200 状态码
response.code = 200
response.msg = '查询成功'
response.data = {
'ret_data': ret_data,
'data_count': count,
}
response.note = {
'id': "用户id",
'name': "微信昵称",
'role_id': "角色id",
'role_name': "角色名称",
'head_portrait': "头像",
'sex_id': "性别id",
'sex': "性别",
'company_name': "公司名称",
'remark': "备注",
'last_login_datetime': "最后登录时间",
'create_datetime': "创建时间",
'number_child_users': "可创建子账号数量",
'small_program_number': "可创建小程序数量",
}
else:
print("forms_obj.errors -->", forms_obj.errors)
response.code = 402
response.msg = "请求异常"
response.data = json.loads(forms_obj.errors.as_json())
return JsonResponse(response.__dict__)
def article_customer_oper(request, oper_type):
response = Response.ResponseObj()
inviter_user_id = request.GET.get('inviter_user_id') # 用户ID
customer_id = request.GET.get('user_id') # 客户ID
if request.method == 'GET':
# 客户查询文章详情
if oper_type == 'article':
id = request.GET.get('id') # 文章ID
objs = models.Article.objects.filter(id=id)
if objs:
obj = objs[0]
user_obj = models.Userprofile.objects.get(id=inviter_user_id)
is_like = False # 是否点赞
log_obj = models.SelectClickArticleLog.objects.filter(
article_id=obj.id, customer_id=customer_id)
if log_obj:
is_like = True
result_data = {
'id':
obj.id,
'title':
obj.title,
'summary':
obj.summary,
'look_num':
obj.look_num,
'like_num':
obj.like_num,
'create_user_id':
obj.create_user_id,
'cover_img':
obj.cover_img,
'create_datetime':
obj.create_datetime.strftime('%Y-%m-%d %H:%M:%S'),
}
result_data['content'] = json.loads(obj.content)
result_data['style'] = obj.style
result_data['top_advertising'] = user_obj.top_advertising
result_data['end_advertising'] = user_obj.end_advertising
# 个人信息
result_data['name'] = b64decode(user_obj.name) # 用户名称
result_data['phone_number'] = user_obj.phone_number # 用户电话
result_data['signature'] = user_obj.signature # 用户签名
result_data[
'set_avator'] = user_obj.set_avator + '?imageView2/2/w/100' # 用户头像
brand_name_list = []
for i in user_obj.brand_classify.all():
brand_name_list.append(i.name)
result_data['brand_name'] = brand_name_list # 用户品牌
qr_code = ''
if user_obj.qr_code:
qr_code = user_obj.qr_code + '?imageView2/2/w/100'
result_data['qr_code'] = qr_code # 用户微信二维码
result_data['is_like'] = is_like # 是否点赞
# 随机获取三篇文章
popula_articles_list = randomly_query_three_articles(
inviter_user_id, id)
# 查询最热商品=======================
goods_list = []
if user_obj.show_product: # 如果客户 打开文章底部显示热卖
goods_list = get_hot_commodity(inviter_user_id)
article_log_obj = models.SelectArticleLog.objects.create(
customer_id=customer_id,
article_id=id,
inviter_id=inviter_user_id)
# 记录查看次数
obj.look_num = F('look_num') + 1
obj.save()
# 给用户发送消息
customer_view_articles_send_msg.delay({
'check_type':
'文章',
'user_id':
inviter_user_id,
'title':
obj.title,
'customer_id':
customer_id,
})
is_own_article = False
# 判断是否是自己的文章
customer_openid = article_log_obj.customer.openid
user_objs = models.Userprofile.objects.filter(
openid=customer_openid)
if user_objs:
if int(user_objs[0].id) == int(inviter_user_id):
is_own_article = True
response.code = 200
response.msg = '查询成功'
response.data = {
'goods_list': goods_list,
'popula_articles': popula_articles_list,
'result_data': result_data,
'is_own_article': is_own_article,
}
response.note = {
'popula_articles热门文章': {
'title': '标题',
'cover_img': '封面',
'url': '链接'
},
'result_data_文章内容': {
'id': '文章ID',
'title': '文章标题',
'summary': '文章摘要',
'look_num': '文章查看人数',
'like_num': '文章点赞人数',
'create_user_id': '文章创建人ID',
'cover_img': '文章封面',
'create_datetime': '文章创建时间',
'content': '文章内容',
'style': '文章样式',
'top_advertising': '顶部内容',
'end_advertising': '底部内容',
'name': '用户名称',
'phone_number': '用户电话',
'signature': '用户签名',
'set_avator': '用户头像',
'brand_name': '用户品牌',
'qr_code': '用户微信二维码',
'is_like': '是否点赞',
},
'goods_list_热门商品': {
# 'goods_describe': '商品描述',
'price': '商品价格',
'goods_name': '商品名称',
'cover_img': '封面图',
'url': '跳转链接'
},
'is_own_article': '是否为自己的文章',
}
else:
response.code = 400
response.msg = '页面丢失'
# 客户查询微店分类
elif oper_type == 'goods_classify':
objs = models.GoodsClassify.objects.filter(
oper_user_id=inviter_user_id).order_by('-create_datetime')
data_list = []
for obj in objs:
is_good = False
if obj.goods_set.all():
is_good = True
data_list.append({
'id':
obj.id,
'goods_classify':
obj.goods_classify,
'oper_user_id':
obj.oper_user_id,
'oper_user':
b64decode(obj.oper_user.name),
'create_datetime':
obj.create_datetime.strftime('%Y-%m-%d %H:%M:%S'),
'is_good':
is_good,
})
response.code = 200
response.msg = '查询成功'
response.data = {
'ret_data': data_list,
'count': objs.count(),
}
response.note = {
'id': '分类ID',
'goods_classify': '分类名称',
'oper_user_id': '分类归属人ID',
'oper_user': '******',
'create_datetime': '创建时间',
'is_good': '该分类下是否有商品',
}
# 客户查询商品
# 查询微店
elif oper_type == 'small_shop':
forms_obj = select_form(request.GET)
if forms_obj.is_valid():
current_page = forms_obj.cleaned_data['current_page']
length = forms_obj.cleaned_data['length']
field_dict = {
'id': '',
'goods_classify_id': '',
'goods_name': '__contains',
}
q = conditionCom(request, field_dict)
objs = models.Goods.objects.filter(
q, goods_classify__oper_user_id=inviter_user_id)
count = objs.count()
if length != 0:
start_line = (current_page - 1) * length
stop_line = start_line + length
objs = objs[start_line:stop_line]
ret_data = []
for obj in objs:
try:
goods_describe = eval(obj.goods_describe)
except Exception:
goods_describe = obj.goods_describe
# 将查询出来的数据 加入列表
ret_data.append({
'id':
obj.id,
'goods_classify_id':
obj.goods_classify_id, # 分类ID
'goods_classify':
obj.goods_classify.goods_classify, # 分类名称
'goods_name':
obj.goods_name, # 商品名称
'price':
obj.price, # 商品价格
'inventory':
obj.inventory, # 商品库存
'freight':
obj.freight, # 商品运费
'goods_describe':
goods_describe, # 商品描述
'point_origin':
obj.point_origin, # 商品发货地
'goods_status_id':
obj.goods_status, # 商品状态ID
'goods_status':
obj.get_goods_status_display(), # 商品状态
'cover_img':
obj.cover_img, # 商品封面图片
'create_datetime':
obj.create_datetime.strftime('%Y-%m-%d %H:%M:%S'),
})
# 查询详情记录
id = request.GET.get('id')
if id:
goods_obj = models.Goods.objects.get(id=id)
models.customer_look_goods_log.objects.create(
goods_id=id,
customer_id=customer_id,
user_id=inviter_user_id)
# 给用户发送消息
customer_view_articles_send_msg.delay({
'check_type':
'商品',
'user_id':
inviter_user_id,
'title':
goods_obj.goods_name,
'customer_id':
customer_id,
})
response.code = 200
response.msg = '查询成功'
response.data = {'ret_data': ret_data, 'count': count}
response.note = {
'id': "文章id",
'goods_classify': '商品分类',
'goods_name': '分类名称',
'price': '商品价格',
'inventory': '商品库存',
'freight': '商品运费',
'goods_describe': '商品描述',
'point_origin': '商品发货地',
'goods_status': '商品状态',
'create_datetime': '商品创建时间',
}
else:
response.code = 301
response.msg = json.loads(forms_obj.errors.as_json())
# 客户记录 文章查看时长/商城查看时长
elif oper_type == 'record_length':
status = request.GET.get('status')
public_id = request.GET.get('public_id')
# close_date = request.GET.get('close_date')
"""
inviter_user_id 为分享人ID
status == 1 为记录文章日志
status == 2 为记录微店日志
user_id 为客户ID
close_date 最后一次时间 每几秒请求一次 以最后一次请求为关闭时间
"""
form_data = {
'status': status,
'public_id': public_id,
'user_id': customer_id,
'inviter_user_id': inviter_user_id,
'close_date': datetime.datetime.now(),
}
form_objs = RecordLengthForm(form_data)
if form_objs.is_valid():
response.code = 200
response.msg = '日志记录成功'
else:
response.code = 301
response.msg = json.loads(form_objs.errors.as_json())
# 客户查询 用户名片
elif oper_type == 'business_card':
obj = models.Userprofile.objects.get(id=inviter_user_id)
name = b64decode(obj.name)
if not obj.introduction:
introduction = '我是{}, 欢迎来到我的名片'.format(name)
else:
introduction = obj.introduction
article_list = randomly_query_three_articles(inviter_user_id)
goods_list = get_hot_commodity(inviter_user_id)
data_list = {
'user_id': obj.id,
'introduction': introduction,
'user_name': name,
'set_avator': obj.set_avator + '?imageView2/2/w/100',
'article_list': article_list,
'goods_list': goods_list,
}
response.code = 200
response.msg = '查询成功'
response.data = data_list
else:
# 客户点赞
if oper_type == 'give_like':
form_data = {
'article_id': request.POST.get('article_id'),
'customer_id': request.GET.get('user_id')
}
form_obj = GiveALike(form_data)
if form_obj.is_valid():
customer_id = form_obj.cleaned_data.get('customer_id')
article_id = form_obj.cleaned_data.get('article_id')
response = give_like(customer_id=customer_id,
article_id=article_id) # 点赞
else:
response.code = 301
response.msg = json.loads(form_obj.errors.as_json())
# 客户 点击 更换成我的名片
elif oper_type == 'change_my_business_card':
obj = models.Customer.objects.get(id=customer_id)
article_id = request.POST.get('article_id')
article_objs = models.Article.objects.filter(id=article_id)
if article_objs:
article_obj = article_objs[0]
if obj.subscribe: # 已关注公众号
user_obj = models.Userprofile.objects.get(
openid=obj.openid)
if_article_objs = models.Article.objects.filter(
create_user_id=user_obj.id, title=article_obj.title)
if not if_article_objs: # 没有创建
create_article_obj = models.Article.objects.create(
title=article_obj.title,
summary=article_obj.summary,
content=article_obj.content,
create_user_id=user_obj.id,
source_link=article_obj.source_link,
cover_img=article_obj.cover_img,
style=article_obj.style,
original_link=article_obj.original_link,
)
create_article_obj.classify = [39]
create_article_obj.save()
article_id = create_article_obj.id
else:
if_article_obj = if_article_objs[0]
article_id = if_article_obj.id
msg = '跳转页面'
code = 200
response.data = {
'article_id': article_id,
'user_id': user_obj.id,
'token': user_obj.token,
}
else: # 未关注公众号
select_article_objs = models.SelectArticleLog.objects.filter(
customer_id=customer_id,
article_id=article_id).order_by('-create_datetime')
if select_article_objs:
select_article_obj = select_article_objs[0]
select_article_obj.click_modify = 1
select_article_obj.save()
weChat_qr_code = select_article_obj.inviter.enterprise.weChat_qr_code
else:
weChat_qr_code = article_obj.create_user.enterprise.weChat_qr_code
msg = '未关注公众号'
code = 301
response.data = {'weChat_qr_code': weChat_qr_code}
else:
code = 301
msg = '该文章已被删除'
response.code = code
response.msg = msg
# 获取自己 用户 的 token （以客户身份进入自己分享的文章 可直接修改 点击修改 获取自己用户token 登录天眼）
elif oper_type == 'get_my_token':
obj = models.Customer.objects.get(id=customer_id)
user_objs = models.Userprofile.objects.filter(openid=obj.openid)
if user_objs:
user_obj = user_objs[0]
data = {
'id': user_obj.id,
'token': user_obj.token,
}
response.code = 200
response.msg = '查询成功'
response.data = {'ret_data': data}
else:
response.code = 301
response.msg = '修改失败'
else:
response.code = 402
response.msg = '请求异常'
return JsonResponse(response.__dict__)
def team_management_oper(request, oper_type):
response = Response.ResponseObj()
user_id = request.GET.get('user_id')
if request.method == "POST":
# 更改团队权限
if oper_type == 'update_team':
players_id = request.POST.get('players_id') # 队员ID
template_list = request.POST.get('template_list') # 权限模板列表
objs = models.UserProfile.objects.filter(id=players_id)
if objs:
objs.update(select_template_list=template_list)
response.code = 200
response.msg = '修改成功'
else:
response.code = 301
response.msg = '队员错误'
# 踢出团员
elif oper_type == 'delete_team':
players_id = request.POST.get('players_id') # 队员ID
objs = models.UserProfile.objects.filter(id=players_id)
if objs:
obj = objs[0]
if int(obj.inviter_id) == int(user_id):
obj.inviter_id = None
obj.select_template_list = []
obj.save()
response.code = 200
response.msg = '操作成功'
else:
response.code = 301
response.msg = '权限不足'
else:
response.code = 301
response.msg = '队员错误'
else:
# 获取角色对应的权限
if oper_type == "get_team_data":
forms_obj = SelectForm(request.GET)
if forms_obj.is_valid():
current_page = forms_obj.cleaned_data['current_page']
length = forms_obj.cleaned_data['length']
order = request.GET.get('order', '-create_datetime')
field_dict = {
'id': '',
}
q = conditionCom(request, field_dict)
objs = models.UserProfile.objects.filter(
q, inviter_id=user_id).order_by(order)
count = objs.count()
if length != 0 and not request.GET.get('id'):
start_line = (current_page - 1) * length
stop_line = start_line + length
objs = objs[start_line:stop_line]
ret_data = []
for obj in objs:
data = {
'id': obj.id,
'name': b64decode(obj.name),
'head_portrait': obj.head_portrait,
}
if request.GET.get('id'):
template_objs = models.Template.objects.filter(
id__in=json.loads(obj.select_template_list))
template_list = []
for template_obj in template_objs:
template_list.append({
'id': template_obj.id,
'name': template_obj.name,
})
data['template_list'] = template_list
ret_data.append(data)
response.code = 200
response.msg = '查询成功'
response.data = {'count': count, 'ret_data': ret_data}
else:
response.code = 301
response.msg = json.loads(forms_obj.errors.as_json())
else:
response.code = 402
response.msg = "请求异常"
return JsonResponse(response.__dict__)
def day_eye(request):
response = Response.ResponseObj()
if request.method == "GET":
forms_obj = SelectForm(request.GET)
if forms_obj.is_valid():
current_page = forms_obj.cleaned_data['current_page']
length = forms_obj.cleaned_data['length']
user_id, message = forms_obj.cleaned_data['user_id']
objs = models.day_eye_celery.objects.filter(
user_id=user_id).order_by('-create_date')
count = objs.count()
if length != 0:
start_line = (current_page - 1) * length
stop_line = start_line + length
objs = objs[start_line:stop_line]
ret_data = []
data_list = []
for obj in objs:
if obj.customer_id not in data_list:
data_list.append(obj.customer_id)
for customer_id in data_list:
eye_objs = models.day_eye_celery.objects.filter(
user_id=user_id,
customer_id=customer_id).order_by('-create_date')
flag = False
for eye_obj in eye_objs:
if eye_obj.is_new_msg:
flag = True
obj = eye_objs[0]
ret_data.append({
'customer_id': obj.customer_id,
'customer__name': b64decode(obj.customer.name),
'customer__set_avator': obj.customer.set_avator,
'text': obj.text,
'status': obj.status,
'is_new_msg': flag,
})
# 查询成功 返回200 状态码
response.code = 200
response.msg = '查询成功'
response.data = {
'ret_data': ret_data,
'count': count,
'message': message,
}
response.note = {
'customer_id': "查看人ID",
'customer__name': "查看人姓名",
'customer__set_avator': '客户头像',
'text': '显示的文字',
'status': '区分 文章还是商品',
'message': '展示的文字/判断是否为空 为空不显示',
}
else:
print("forms_obj.errors -->", forms_obj.errors)
response.code = 301
response.data = json.loads(forms_obj.errors.as_json())
return JsonResponse(response.__dict__)
