def order_count():
"""
订单统计
:return:
"""
ut = UtilTime()
lastday = ut.today.replace(days=-1)
startdate = ut.string_to_timestamp(ut.arrow_to_string(lastday,format_v="YYYY-MM-DD")+' 00:00:00')
enddate = ut.string_to_timestamp(ut.arrow_to_string(lastday,format_v="YYYY-MM-DD")+' 23:59:59')
with transaction.atomic():
print("订单统计，日期：{}...".format(ut.arrow_to_string(lastday,format_v="YYYY-MM-DD")))
for user in Users.objects.filter(rolecode='2001',status='0',createtime__lt=enddate):
orders = Order.objects.filter(userid=user.userid,createtime__gte=startdate,createtime__lte=enddate)
ordercount_insert=dict()
ordercount_insert["tot_order_count"] = orders.count()
ordercount_insert["today_success_order_count"] = 0
ordercount_insert["today_amount"] = 0.0
ordercount_insert["userid"] = user.userid
for order in orders:
if order.status=='0':
ordercount_insert["today_success_order_count"] += 1
ordercount_insert["today_amount"] += float(order.amount)
ordercount_insert["today_rate"] = ordercount_insert["today_success_order_count"] * 1.0 / ordercount_insert["tot_order_count"] \
if ordercount_insert["tot_order_count"] else 0.0
ordercount_insert["today"] = ut.arrow_to_string(lastday,format_v="YYYY-MM-DD")
OrderCount.objects.create(**ordercount_insert)
def get_date(obj):
if obj.get("type") == "appoint":
return obj.get("value")
else:
ut = UtilTime()
return ut.timestamp * 1000 \
if obj.get("format", None) == 'timestamp' else \
ut.arrow_to_string(arrow_s=ut.today, format_v=obj.get("format", None)) if obj.get("format", None) \
else ut.arrow_to_string(arrow_s=ut.today)
def run(self):
print("红包回调处理开启!")
while True:
redisRes = self.redis_client.brpop(self.lKey)[1]
if not redisRes:
continue
self.ordercode = redisRes.decode('utf-8').split("|")[0]
self.other_ordercode = redisRes.decode('utf-8').split("|")[1]
self.session = redisRes.decode('utf-8').split("|")[2]
self.endtime = redisRes.decode('utf-8').split("|")[3]
if UtilTime().timestamp >= int(self.endtime):
continue
try:
ut = UtilTime()
start_time = ut.arrow_to_string(format_v="YYYY-MM-DD")
end_time = ut.arrow_to_string(ut.today.shift(days=-3),format_v="YYYY-MM-DD")
flag,s= WeiboCallBack(sessionRes=json.loads(self.session),cookieKey='pccookie',isSession=True)\
.queryOrderForWeibo(ordercode=self.ordercode,start_time=start_time,end_time=end_time)
if not flag:
self.redisdataCall("查询失败!{}".format(s))
continue
else:
if not len(s):
self.redisdataCall("查询无数据!{}".format(s))
continue
else:
if s[0]['status'] == '2':
pass
elif s[0]['status'] == '4':
self.redisdataCall("交易关闭!{}".format(s))
continue
elif s[0]['status'] == '1':
self.redisdataCall()
continue
else:
self.redisdataCall("未知状态!{}".format(s))
continue
request_data = {"orderid": self.ordercode}
result = request('POST', url=urllib.parse.unquote(
'{}/callback_api/lastpass/jingdong_callback'.format(url_join())), data=request_data,json=request_data, verify=False)
if result.text != 'success':
logger.info("请求对方服务器错误! {}".format(self.ordercode))
except Exception as e:
self.redisdataCall(str(e))
continue
def pass_count(self,request):
query_format = str()
query_params = list()
ut = UtilTime()
if request.query_params_format.get("today"):
today = request.query_params_format.get("today")
startdate = ut.string_to_timestamp(today+' 00:00:01',format_v="YYYY-MM-DD")
enddate = ut.string_to_timestamp(today+' 23:59:59',format_v="YYYY-MM-DD")
else:
today = ut.arrow_to_string(format_v="YYYY-MM-DD")
startdate = ut.string_to_timestamp(today+' 00:00:01')
enddate = ut.string_to_timestamp(today+' 23:59:59')
query_format = query_format + " and t1.createtime>=%s and t1.createtime<=%s"
query_params.append(startdate)
query_params.append(enddate)
if request.query_params_format.get("paypassid"):
query_format = query_format + " and t2.paypassid =%s"
query_params.append(request.query_params_format.get("paypassid"))
orders = Order.objects.raw("""
SELECT t1.* FROM `order` as t1
INNER JOIN `paypass` as t2 ON t1.paypass = t2.paypassid and t2.status='0'
WHERE 1=1 %s
"""% (query_format), query_params)
pass_order_dict={}
for order in orders :
if order.paypass not in pass_order_dict:
pass_order_dict[order.paypass]={
"id": order.paypass,
"name" : order.paypassname,
"amount" : 0.0,
"order_count":0,
"order_success_count":0,
"rate" : 0.0,
"today" : today[:10]
}
pass_order_dict[order.paypass]['order_count'] += 1
if order.status == '0':
pass_order_dict[order.paypass]['amount'] += float(order.amount)
pass_order_dict[order.paypass]['order_success_count'] += 1
data = []
for key in pass_order_dict:
pass_order_dict[key]['rate'] = "{}%".format(round(pass_order_dict[key]['order_success_count'] * 100.0 / pass_order_dict[key]['order_count'] \
if pass_order_dict[key]['order_count'] else 0.0 ,2))
data.append(pass_order_dict[key])
return {"data": data}
def order_valid_task():
"""
订单过期处理,每天凌晨3点处理昨天的过期情况
:return:
"""
with transaction.atomic():
ut = UtilTime()
# last_day_time = ut.string_to_timestamp(ut.arrow_to_string(ut.today.replace(days=-1), format_v="YYYY-MM-DD") + ' 00:00:01')
today_time = ut.string_to_timestamp(ut.arrow_to_string(ut.today,format_v="YYYY-MM-DD")+' 00:00:01')
Order.objects.filter(createtime__lte=today_time,status="1").update(status="3",down_status='3')
def get_today_bal(self, obj):
tot = 0
ut = UtilTime()
today = ut.arrow_to_string(ut.today, format_v="YYYY-MM-DD")
today_start = ut.string_to_timestamp(today + ' 00:00:01')
today_end = ut.string_to_timestamp(today + ' 23:59:59')
for item in Order.objects.filter(createtime__lte=today_end,
createtime__gte=today_start,
status="0"):
tot = float(tot) + float(item.myfee)
return round(tot, 2)
def get_today(self, obj):
tot = 0
ut = UtilTime()
today = ut.arrow_to_string(ut.today, format_v="YYYY-MM-DD")
today_start = ut.string_to_timestamp(today + ' 00:00:01')
today_end = ut.string_to_timestamp(today + ' 23:59:59')
for item in PayCallList.objects.filter(name=obj.name,
createtime__lte=today_end,
createtime__gte=today_start,
status="0"):
tot = float(tot) + float(item.amount)
return tot
def ordercount(self, request, *args, **kwargs):
data = {
"amount_tot": 0.0,
"amount": 0.0,
"order_tot": 0,
"order": 0,
"rate_tot": 0.0,
"rate": 0.0
}
start_datetime = send_toTimestamp(
datetime.datetime.now().strftime('%Y-%m-%d') + ' 00:00:01')
end_datetime = send_toTimestamp(
datetime.datetime.now().strftime('%Y-%m-%d') + ' 23:59:59')
#流水统计,订单比数统计,成功率
QuerySet = Order.objects.all()
if self.request.user.rolecode in ["1000", "1001"]:
pass
elif self.request.user.rolecode == '2001':
QuerySet = QuerySet.filter(userid=self.request.user.userid)
elif request.user.rolecode == "3001":
userlink = UserLink.objects.filter(
userid_to=self.request.user.userid)
if not userlink.exists():
QuerySet = Order.objects.filter(userid=0)
else:
QuerySet = QuerySet.filter(
userid__in=[item.userid for item in userlink])
else:
raise PubErrorCustom("用户类型有误!")
is_all = 0.0
is_ok = 0.0
is_all_today = 0.0
is_ok_today = 0.0
for item in QuerySet:
is_all += 1
if start_datetime <= item.createtime <= end_datetime:
is_all_today += 1
if item.status == '0':
is_ok += 1
data['amount_tot'] += float(item.confirm_amount)
data['order_tot'] += 1
if start_datetime <= item.createtime <= end_datetime:
data['amount'] += float(item.confirm_amount)
data['order'] += 1
is_ok_today += 1
data['rate_tot'] = round(is_ok / is_all * 100.0, 3) if is_all else 0
data['rate'] = round(is_ok_today / is_all_today *
100.0, 3) if is_all_today else 0
data1 = [
{
"title": '当天商户流水',
"subtitle": '实时',
"count": '¥{}'.format(round(data["amount"], 2)),
"allcount": '¥{}'.format(round(data["amount_tot"], 2)),
"text": '总流水',
"color": 'rgb(27, 201, 142)',
"key": '商'
},
{
"title": '当天订单数',
"subtitle": '实时',
"count": '{}'.format(data["order"]),
"allcount": '{}'.format(data["order_tot"]),
"text": '总订单比数',
"color": 'rgb(230, 71, 88)',
"key": '订'
},
{
"title": '当天订单成功率',
"subtitle": '实时',
"count": '{}%'.format(data["rate"]),
"allcount": '{}%'.format(data["rate_tot"]),
"text": '总成功率',
"color": 'rgb(178, 159, 255)',
"key": '成'
},
]
ut = UtilTime()
item_count = 7
data2 = []
data3 = []
day = ut.today.replace(days=-7)
while item_count:
day = ut.replace(arrow_v=day, days=1)
day_string = ut.arrow_to_string(arrow_s=day,
format_v="YYYY-MM-DD")[0:10]
amount = 0.0
for item in QuerySet.filter(
createtime__lte=ut.string_to_arrow(day_string +
' 23:59:59').timestamp,
createtime__gte=ut.string_to_arrow(day_string +
' 00:00:01').timestamp,
status='0'):
amount += float(item.confirm_amount)
data2.append(day_string.replace('-', '')[4:])
data3.append(amount)
item_count -= 1
data4 = {'value': data3, 'key': data2, 'top': ['订单金额']}
return {"data": {"data1": data1, "data4": data4}}
def business_count(self, request):
query_format = str()
query_params = list()
ut = UtilTime()
if request.query_params_format.get("today"):
today = request.query_params_format.get("today")
startdate = ut.string_to_timestamp(today + ' 00:00:01')
enddate = ut.string_to_timestamp(today + ' 23:59:59')
else:
today = ut.arrow_to_string(format_v="YYYY-MM-DD")
startdate = ut.string_to_timestamp(today + ' 00:00:01')
enddate = ut.string_to_timestamp(today + ' 23:59:59')
query_format = query_format + " and t1.createtime>=%s and t1.createtime<=%s"
query_params.append(startdate)
query_params.append(enddate)
if request.query_params_format.get("userid"):
query_format = query_format + " and t2.userid =%s"
query_params.append(request.query_params_format.get("userid"))
orders = Order.objects.raw(
"""
SELECT t1.* FROM `order` as t1
INNER JOIN `user` as t2 ON t1.userid = t2.userid and t2.status='0'
WHERE 1=1 %s
""" % (query_format), query_params)
pass_order_dict = {}
for order in orders:
if order.userid not in pass_order_dict:
pass_order_dict[order.userid] = dict()
if order.paytype not in pass_order_dict[order.userid]:
pass_order_dict[order.userid][order.paytype] = {
"id": order.userid,
"typeid": order.paytype,
"name": order.paytypename,
"amount": 0.0,
"order_count": 0,
"order_success_count": 0,
"rate": 0.0,
"today": today[:10],
"tech_cost": 0.0
}
pass_order_dict[order.userid][order.paytype]['order_count'] += 1
if order.status == '0':
pass_order_dict[order.userid][
order.paytype]['amount'] += float(order.amount)
pass_order_dict[order.userid][
order.paytype]['order_success_count'] += 1
pass_order_dict[order.userid][
order.paytype]['tech_cost'] += float(order.tech_cost)
data = []
for userid in pass_order_dict:
for type in pass_order_dict[userid]:
pass_order_dict[userid][type]['rate'] = "{}%".format(
round(pass_order_dict[userid][type]['order_success_count'] * 100.0 / pass_order_dict[userid][type]['order_count'] \
if pass_order_dict[userid][type]['order_count'] else 0.0, 2))
pass_order_dict[userid][type]['endamount'] = float(
pass_order_dict[userid][type]['amount']) - float(
pass_order_dict[userid][type]['tech_cost'])
data.append(pass_order_dict[userid][type])
return {"data": data}
class RedisCaCheHandler(RedisCaCheHandlerBase):
def __init__(self, **kwargs):
#必查询字段
self.must_params = list(set([] + kwargs.get('must_params', [])))
#查询时过滤字段
self.filter_params = list(
set(['google_token', 'passwd', 'pay_passwd'] +
kwargs.get('filter_params', [])))
#带条件查询字段
self.condition_params = list(
set([] + kwargs.get('condition_params', [])))
#请求的值
self.filter_value = kwargs.get('filter_value') if kwargs.get(
'filter_value') else {}
#唯一key
self.must_key = kwargs.get('must_key') if kwargs.get(
'must_key') else ""
#唯一key value
self.must_key_value = kwargs.get('must_key_value') if kwargs.get(
'must_key_value') else ""
#方法
if not kwargs.get("method"):
raise PubErrorCustom("方法不能为空")
self.method = kwargs.get("method")
#表
if not kwargs.get("table"):
raise PubErrorCustom("表不能为空")
self.table = kwargs.get("table")
#序列化
self.serialiers = kwargs.get("serialiers")
self.ut = UtilTime()
kwargs.setdefault('key', self.table)
super().__init__(**kwargs)
def filter(self):
#查前端请求的带条件字段
self.condition_params_web = list(
set([] + self.filter_value.get('conditions', []))
) if self.filter_value else []
self.res = self.redis_dict_get_all()
if not self.res:
self.res = []
#特殊处理字段
createtime = self.filter_value.pop(
'createtime') if self.filter_value.get('createtime') else None
data = []
for key in self.res:
isOk = True
#必查字段处理
for item in self.must_params:
if not self.res[key].get(item, None):
isOk = False
break
if str(self.res[key].get(item, None)) != self.filter_value.get(
'rolecode', None):
isOk = False
break
if not isOk:
continue
#带条件查询字段
for item in self.condition_params:
rValue = self.filter_value.pop(
item[0]) if self.filter_value.get(item[0], None) else None
if item[1] == 'like':
if rValue and item in str(
self.res.get(key)) and str(rValue) not in str(
self.res.get(key).get(item)):
isOk = False
break
elif item[1] == '>':
if rValue and item in str(
self.res.get(key)) and str(rValue) > str(
self.res.get(key).get(item)):
isOk = False
break
elif item[1] == '>=':
if rValue and item in str(
self.res.get(key)) and str(rValue) >= str(
self.res.get(key).get(item)):
isOk = False
break
elif item[1] == '<':
if rValue and item in str(
self.res.get(key)) and str(rValue) < str(
self.res.get(key).get(item)):
isOk = False
break
elif item[1] == '<=':
if rValue and item in str(
self.res.get(key)) and str(rValue) <= str(
self.res.get(key).get(item)):
isOk = False
break
else:
raise PubErrorCustom("标识有误!")
if not isOk:
continue
#其他查询字段
for item in self.filter_value:
rValue = self.filter_value.get(item, None)
if rValue and item in str(
self.res.get(key)) and str(rValue) != str(
self.res.get(key).get(item)):
isOk = False
break
if not isOk:
continue
#特殊字段处理
if not self.timeHandler(createtime, self.res, key):
continue
#前端条件过滤查询
for item in self.condition_params_web:
if '=' in item:
s = item.split('=')
if not (str(self.res[key].get(s[0])) == str(s[1])):
isOk = False
break
elif '≠' in item:
s = item.split('≠')
if not (str(self.res[key].get(s[0])) != str(s[1])):
isOk = False
break
elif 'like' in item:
s = item.split('like')
if not (str(s[1]) in str(self.res[key].get(s[0]))):
isOk = False
break
elif '>' in item:
s = item.split('>')
try:
if not (float(self.res[key].get(s[0])) > float(s[1])):
isOk = False
break
except ValueError:
if not (str(self.res[key].get(s[0])) > str(s[1])):
isOk = False
break
elif '≥' in item:
s = item.split('≥')
try:
if not (float(self.res[key].get(s[0])) >= float(s[1])):
isOk = False
break
except ValueError:
if not (str(self.res[key].get(s[0])) >= str(s[1])):
isOk = False
break
elif '<' in item:
s = item.split('<')
try:
if not (float(self.res[key].get(s[0])) < float(s[1])):
isOk = False
break
except ValueError:
if not (str(self.res[key].get(s[0])) < str(s[1])):
isOk = False
break
elif '≤' in item:
s = item.split('≤')
try:
if not (float(self.res[key].get(s[0])) <= float(s[1])):
isOk = False
break
except ValueError:
if not (str(self.res[key].get(s[0])) <= str(s[1])):
isOk = False
break
elif '∈' in item:
s = item.split('∈')
if not (str(self.res[key].get(s[0])) in str(s[1])):
isOk = False
break
if not isOk:
continue
for item in self.filter_params:
if item in self.res[key]:
self.res[key].pop(item)
data.append(self.res[key])
data.sort(key=lambda k: (k.get('createtime', 0)), reverse=True)
return data
def save(self):
res = eval("{}(self.filter_value,many=False).data".format(
self.serialiers))
self.redis_dict_insert(res.get(self.must_key), res)
def delete(self):
self.redis_dict_del(self.must_key_value)
def insertAll(self):
res = eval("{}(self.filter_value,many=True).data".format(
self.serialiers))
self.redis_dict_delall()
for item in res:
self.redis_dict_insert(item[self.must_key], item)
def timeHandler(self, timeValue, res, key):
if timeValue and str(timeValue) != '-1':
times = timeValue.split(',')
if len(times) > 1:
start_date = self.ut.string_to_timestamp(times[0] +
' 00:00:01')
end_date = self.ut.string_to_timestamp(times[1] + ' 23:59:59')
else:
today = self.ut.arrow_to_string(self.ut.string_to_arrow(
times[0], format_v="YYYY-MM-DD").replace(days=1),
format_v="YYYY-MM-DD")
if today == self.ut.arrow_to_string(format_v="YYYY-MM-DD"):
start_date = self.ut.string_to_timestamp(times[0] +
' 00:00:01')
end_date = self.ut.string_to_timestamp(times[0] +
" 23:59:59")
elif today < self.ut.arrow_to_string(format_v="YYYY-MM-DD"):
start_date = self.ut.string_to_timestamp(times[0] +
' 00:00:01')
end_date = self.ut.string_to_timestamp(
self.ut.arrow_to_string(format_v="YYYY-MM-DD") +
" 23:59:59")
else:
start_date = self.ut.string_to_timestamp(times[0] +
' 00:00:01')
end_date = self.ut.string_to_timestamp(times[0] +
" 23:59:59")
if res[key]['createtime'] < start_date or res[key][
'createtime'] > end_date:
return False
return True
def run(self):
return eval("self.{}()".format(self.method))
class weiboSysRun(object):
def __init__(self,isQueryTask=True):
self.ut = UtilTime()
self.wbOUser = None
self.wbOTask = None
if isQueryTask:
wbOTasks = WeiboTask.objects.filter(umark='0',status='1',date=self.ut.arrow_to_string(format_v="YYYY-MM-DD")).order_by('sort')
if not wbOTasks.exists():
logger.error("无任务可执行!")
return
self.wbOTask = wbOTasks[0]
try:
self.wbOUser = WeiboUser.objects.get(uid=self.wbOTask.uid,status='0')
except WeiboUser.DoesNotExist:
logger.error("无可用组长!")
return
self.robnumber = self.wbOTask.robnumber
self.minamount = self.wbOTask.minamount
self.maxamount = self.wbOTask.maxamount
def pay(self,order):
"""
生成微博支付订单
:param order: 订单表
:return:
"""
amount = float(order.amount)
if not(self.minamount <= amount <= self.maxamount):
raise PubErrorCustom("金额范围在 {}-{}".format(self.minamount,self.maxamount))
#计算单价
price = amount / self.robnumber
print(price)
if round(price,2) * self.robnumber !=amount:
raise PubErrorCustom("该金额不正确")
print("单价:{},总价{},红包个数{}".format(price,amount,self.robnumber))
wbPayClass = WeiboPay(sessionRes=json.loads(self.wbOUser.session))
url,ordercode, = wbPayClass.pay(price=price,num=self.robnumber,amount=amount)
wapurl,payordercode = wbPayClass.getPayId(url)
html = wbPayClass.createorder(wapurl)
order.isjd = '0'
order.jd_ordercode = ordercode
order.jd_payordercode = payordercode
order.jd_data = json.dumps({
"payurl": url,
"userid": self.wbOUser.userid, #码商ID
"status": "0", # 0-待支付,1-已支付,未发红包,2-已发红包,3-红包被抢
"num": self.robnumber, # 红包个数
"ok_num": 0, # 已抢个数
"run_username": [], # 抢红包的人的集合
})
order.save()
self.payafter(order,self.wbOUser.session)
return html
def payafter(self,order,session):
from apps.weibohongbao.weiboCallback import callback
"""
微博订单回调通知
:param ordercode:系统订单号
:return:
"""
weiboHandler = callback()
weiboHandler.redis_client.lpush(weiboHandler.lKey, "{}|allwin|{}|allwin|{}|allwin|{}".format(
order.ordercode,
order.jd_payordercode,
session,
UtilTime().today.replace(minutes=120).timestamp))
def getvercode(self,username):
"""
获取手机验证码(目前手机登录用)
:param username:
:return:
"""
wbLoginClass = WeiBoLoginForPhone()
wbLoginClass.getvercode(username)
def phonelogin(self,username,vercode):
"""
:param username: 登录手机号
:param vercode: 验证码
:return:
"""
try:
wbUserObj = WeiboUser.objects.get(username=username)
except WeiboUser.DoesNotExist:
raise PubErrorCustom("账号不存在!")
wbLoginClass = WeiBoLoginForPhone()
wbUserObj.session = wbLoginClass.login_by_vercode(username,vercode)
wbUserObj.uid = wbUserObj.session['uid']
wbUserObj.session = json.dumps(wbUserObj.session)
wbUserObj.logintime = UtilTime().timestamp
wbUserObj.session_status = '0'
wbUserObj.save()
def pclogin(self,datas):
rdatas=[]
for item in datas:
try:
wbUserObj = WeiboUser.objects.get(username=item['username'])
except WeiboUser.DoesNotExist:
rdatas.append({
"username":wbUserObj.username,
"code":"10001",
"msg":"账号不存在系统登录失败!"
})
continue
wbLFPClass = WeiboLoginForPc(username=wbUserObj.username,password=wbUserObj.password)
if 'params' in item and item['params']['showpin'] == '1':
wbLFPClass.login_params = item['params']
wbLFPClass.login_params['vercode'] = item['vercode']
try:
if wbUserObj.session:
session = json.loads(wbUserObj.session)
else:
session = {}
session['cookie'] = {}
res = wbLFPClass.login()
print(res)
session['uid'] = res['uid']
session['cookie']['pccookie'] = res['cookie']['pccookie']
wbUserObj.session = json.dumps(session)
wbUserObj.uid = session['uid']
wbUserObj.logintime = UtilTime().timestamp
wbUserObj.save()
except Exception as e:
logger.error(str(e))
rdatas.append({
"username": wbUserObj.username,
"code": "10002",
"msg": "密码或验证码错误,请重新输入!",
"url": wbLFPClass.getvercodeUrl(),
"params" : wbLFPClass.login_params
})
continue
else:
wbLFPClass.preLogin()
if wbLFPClass.login_params['showpin'] == '1':
rdatas.append({
"username": wbUserObj.username,
"code": "10002",
"msg": "需要获取验证码登录!",
"url": wbLFPClass.getvercodeUrl(),
"params" : wbLFPClass.login_params
})
continue
else:
try:
if wbUserObj.session:
session = json.loads(wbUserObj.session)
else:
session = {}
session['cookie'] = {}
res = wbLFPClass.login()
print(res)
session['uid'] = res['uid']
session['cookie']['pccookie'] = res['cookie']['pccookie']
wbUserObj.session = json.dumps(session)
wbUserObj.uid = session['uid']
wbUserObj.logintime = UtilTime().timestamp
wbUserObj.save()
except Exception as e:
logger.error(str(e))
rdatas.append({
"username":wbUserObj.username,
"code": "10001",
"msg":"账号或密码错误!"
})
continue
print(rdatas)
return rdatas
def groupjoin(self,uid,uids,name,userid):
"""
创建群并添加成员
:param uid: 群组长uid
:param uids: 群成员uid
:param name: 群名称
:return:
"""
try:
userBossObj = WeiboUser.objects.get(uid=uid)
except WeiboUser.DoesNotExist:
raise PubErrorCustom("群组长ID不正确{}".format(uid))
userMemberObjs = []
for item in uids.split(","):
try:
userMemberObjs.append(WeiboUser.objects.get(uid=item))
except WeiboUser.DoesNotExist:
raise PubErrorCustom("群成员ID不正确{}".format(item))
#群组长关联各个群成员
print(userBossObj.session)
followClass = WeiboFollow(sessionRes=json.loads(userBossObj.session))
for item in userMemberObjs:
followClass.follow(item.uid)
#群成员关注群组长
for item in userMemberObjs:
WeiboFollow(sessionRes=json.loads(item.session)).follow(userBossObj.uid)
#添加群
wbGroupClass = WeiboGroup(sessionRes=json.loads(userBossObj.session))
res = wbGroupClass.create(name=name)
WeiboGroupModel.objects.create(**{
"group_id" : res['id'],
"name": name,
"userid":userid,
"uid":uid
})
#添加成员
wbGroupClass.join(groupid=res['id'],uids=uids)
for item in uids.split(","):
WeiboGroupMember.objects.create(**{
"group_id": res['id'],
"name" : name,
"userid":userid,
"uid" : uid,
'son_uid':item
})
def gethb(self):
time.sleep(2)
if self.wbOUser and self.wbOTask:
pass
else:
print("无可用用户或可用任务")
return
wbHbClass = WeiboHb(sessionRes=json.loads(self.wbOUser.session))
wbSLObj = WeiboSendList.objects.filter().order_by('-setid')
if not wbSLObj.exists():
max_set_id = 0
else:
max_set_id = wbSLObj[0].setid
try:
sendlist = wbHbClass.getlistAll(year="2019", type="2", max_set_id=max_set_id)
with transaction.atomic():
for item in sendlist:
WeiboSendList.objects.create(**{
"groupid":self.wbOTask.groupid,
"setid":item['set_id'],
"uid":self.wbOUser.uid,
"uids":json.dumps({"uids":[]}),
"swithurl":item['url'],
"taskid":self.wbOTask.taskid,
"userid":self.wbOTask.userid,
"amount":item['amount'],
"getcount":item['getcount'],
"sendcount":item['sendcount'],
"status": '0' if item['getcount'] == item['sendcount'] else '1'
})
except Exception as e:
logger.error(str(e))
self.gethb()
def send(self):
"""
发红包
:return:
"""
time.sleep(3)
if self.wbOUser and self.wbOTask:
pass
else:
return
wbHbClass = WeiboHb(sessionRes=json.loads(self.wbOUser.session))
wbSLObj = WeiboSendList.objects.filter(status='1',umark='1').order_by('setid')
if not wbSLObj.exists():
return
for item in wbSLObj:
try:
with transaction.atomic():
wbHbClass.send(item)
item.umark='0'
item.save()
except Exception as e:
logger.error(str(e))
def rob(self):
time.sleep(5)
if self.wbOUser and self.wbOTask:
pass
else:
return
WbSLObj = WeiboSendList.objects.filter(status=1,taskid=self.wbOTask.taskid)
if WbSLObj.exists():
for item in WbSLObj:
uidsObj=json.loads(item.uids)
print(uidsObj)
print(item.groupid)
for item_member in WeiboGroupMember.objects.filter(group_id=item.groupid):
if len(item.uids) and item_member.son_uid in uidsObj['uids']:
continue
time.sleep(20)
wbUserObj = WeiboUser.objects.get(uid=item_member.son_uid)
try:
print(item_member.son_uid)
rFlag = WeiboHbGet(sessionRes=json.loads(wbUserObj.session)).rob(url=item.url)
if rFlag:
uidsObj['uids'].append(item_member.son_uid)
item.getcount +=1
except Exception as e:
logger.error("抢红包失败",str(e),item_member.son_uid,item.url)
if item.getcount>=item.sendcount:
item.status = '0'
print(uidsObj)
item.uids = json.dumps(uidsObj)
item.save()