def test_gift_05(self):
'''业务-角色-房管'''
self.user = self.create_user()
MoneyClass.set_money(self.user, 1)
User.set_fg(cid, self.user)
self.exp_res = dict(code=200,
status=True,
data=dict(extend=dict(is_fg='1')))
def test_gift_15(self):
'''业务-粉丝值'''
self.exp_res = {'status': True, 'code': 200, 'data': {}}
self.user = self.create_user()
MoneyClass.set_money(self.user, 1)
get_loveliness = User.loveliness('get', self.user, cid)
self.ver = lambda: User.loveliness(
'get', self.user, cid) == get_loveliness + gift['fan_exp']
def test_gift_09(self):
'''业务-赠送爱心-用户赠送爱心增加经验主播增加仙能'''
self.user = self.create_user()
self.data['gift'] = 0
self.exp_res = {'status': True, 'code': 200}
MoneyClass.set_xd(self.user, 1000)
# 获取用户平台经验,主播仙能
user_experience = User.get_experience(self.user)[0]
anchor_experience = User.get_experience(anchor)[1]
self.ver = lambda: User.get_experience(self.user)[0] == user_experience + 1000 and \
User.get_experience(anchor)[1] == anchor_experience + 1000
def test_16(self):
'''业务-图标-徽章'''
self.exp_res = {
'code': 200,
'data': {
'badge': [{
'bid': '1',
}]
}
}
self.user = self.create_user()
User.set_badge(self.user)
def test_gift_07(self):
'''业务-显示图标-徽章'''
self.exp_res = {
'code': 200,
'data': {
'badge': [{
'bid': '1',
}]
}
}
self.user = self.create_user()
User.set_badge(self.user)
MoneyClass.set_money(self.user, 1)
def test_15(self):
'''业务-图标-粉丝'''
self.exp_res = {
'code': 200,
'data': {
'fans': {
'cid': cid,
'level': '25',
'name': '粉丝'
}
}
}
self.user = self.create_user()
# 设置用户粉丝等级
User.set_fs_level(self.user, cid)
def test_gift_06(self):
'''业务-角色-粉丝'''
self.user = self.create_user()
MoneyClass.set_money(self.user, 1)
User.set_fs_level(self.user, cid)
self.exp_res = {
'code': 200,
'data': {
'fans': {
'cid': cid,
'level': '25',
'name': '粉丝'
}
}
}
def create_user(self):
uid = User.reg('noble')
logger_test_api.info(f'注册用户UID：{uid}')
User.bd_sj(uid)
return uid
from django.shortcuts import render
from django.http import StreamingHttpResponse, HttpResponse, JsonResponse, HttpResponseRedirect
from huomao.common import Common
from huomao.user import User
from huomao.channel import Channel
from huomao.money import MoneyClass
from huomao.test import test
import logging
import json
user = User()
channel = Channel()
money = MoneyClass()
def api_test(request):
return render(request, 'api_test.html')
def chatroom(request):
return render(request, 'chatroom.html')
def new_web(request, method=''):
if request.META.get('HTTP_X_FORWARDED_FOR'):
ip = request.META['HTTP_X_FORWARDED_FOR']
else:
ip = request.META['REMOTE_ADDR']
print(ip)
if method == '':
return render(request, 'index.html')
def validate(self, _type='create'):
# discount = self.discount and Decimal(str(self.discount)) or 1
discount = isinstance(self.discount, dict) and self.discount['discount'] * 10 / 100 or self.discount * 10 / 100
# 贵族等级：开通价格0，续费价格1，返还猫币2，主播提成3，增加经验4,喇叭5
noble_data = {
1: [66, 30, 30, 13.2, 0, 0],
2: [500, 300, 300, 100, 50000, 0],
3: [1500, 1000, 1000, 300, 125000, 0],
4: [5000, 3000, 3000, 1000, 500000, 5],
5: [15000, 10000, 10000, 3000, 1250000, 8],
6: [40000, 30000, 30000, 6000, 2500000, 15],
7: [120000, 100000, 100000, 12000, 5000000, 30]
}
level = isinstance(self.discount, dict) and self.discount['level'] or self.data['level']
month = isinstance(self.discount, dict) and self.discount['month'] or self.data['month']
old_level = hasattr(self, 'old_level') and self.old_level
old_month = hasattr(self, 'old_month') and self.old_month
# 获取赠送者用户的猫币，贵族猫币，平台经验
buyer_uid = self.user
buyer_coin = MoneyClass.get_money(buyer_uid)['coin']
buyer_noble_coin = MoneyClass.get_noble_coin(buyer_uid)
buyer_exp = User.get_experience(buyer_uid)[0]
buyer_lb = Bag.get_dmk(buyer_uid, 90011)
# 获取被赠送者的猫币，贵族猫币，平台经验
to_uid = self.data.get('to_uid')
if to_uid:
to_uid_coin = MoneyClass.get_money(to_uid)['coin']
to_uid_noble_coin = MoneyClass.get_noble_coin(to_uid)
to_uid_exp = User.get_experience(to_uid)[0]
to_uid_lb = Bag.get_dmk(to_uid, 90011)
def _ver():
noble_profit = get_noble_exp = get_noble_money = pay_money = False
if to_uid:
# A 赠送模式
# 1 判断增送者猫币
buyer_coin_new = MoneyClass.get_money(buyer_uid)['coin']
if _type == 'create' or _type == 'upgrade' or (_type == 'protect_create' and level != old_level):
# 开通/升级 首月原价,其他优惠价
pay_money = (noble_data[level][0] * 1 + noble_data[level][1] * (month - 1)) * discount
elif _type == 'renew' or (_type == 'protect_create' and level == old_level):
# 续费/续费保护期购买 只花费折扣价格
pay_money = noble_data[level][1] * month * discount
if buyer_coin != buyer_coin_new + pay_money:
logger_test_api.error(f'赠送者-猫币错误{buyer_coin}:{buyer_coin_new}')
return False
# 2 判断赠送者贵族猫币
buyer_noble_coin_new = MoneyClass.get_noble_coin(buyer_uid)
if buyer_noble_coin != buyer_noble_coin_new:
logger_test_api.error(f'赠送者贵族猫币错误{buyer_noble_coin}:{buyer_noble_coin_new}')
return False
# 3 判断赠送者平台经验
buyer_exp_new = User.get_experience(buyer_uid)[0]
if buyer_exp != buyer_exp_new:
logger_test_api.error(f'赠送者平台经验错误{buyer_exp}:{buyer_exp_new}')
return False
# 判断赠送者喇叭
buyer_lb_new = Bag.get_dmk(buyer_uid, 90011)
if buyer_lb != buyer_lb_new:
logger_test_api.error(f'赠送者喇叭错误{buyer_lb}:{buyer_lb_new}')
return False
# 4 判断被增送者猫币
to_uid_coin_new = MoneyClass.get_money(to_uid)['coin']
if to_uid_coin != to_uid_coin_new:
logger_test_api.error(f'被赠送者猫币错误{to_uid_coin}:{to_uid_coin_new}')
return False
# 5 判断被增送贵族猫币,平台经验,喇叭
to_uid_noble_coin_new = MoneyClass.get_noble_coin(to_uid)
to_uid_exp_new = User.get_experience(to_uid)[0]
to_uid_lb_new = Bag.get_dmk(to_uid, 90011)
get_noble_money = noble_data[level][2] * discount * month
get_noble_exp = noble_data[level][4] * discount * month
get_noble_lb = noble_data[level][5] * month
# if _type == 'create' or _type == 'protect_create':
# # 开通/续费保护期 获得一个月
# get_noble_money = noble_data[level][2] * discount
# get_noble_exp = noble_data[level][4] * discount
# elif _type == 'renew':
# # 续费 不获得
# get_noble_money = 0
# get_noble_exp = 0
# elif _type == 'upgrade':
# # 返还第一个月和之前月份未给的
# get_noble_money = noble_data[level][2] * discount + noble_data[old_level][2] * (old_month - 1)
# get_noble_exp = noble_data[level][4] * discount + noble_data[old_level][4] * (old_month - 1)
if to_uid_noble_coin != to_uid_noble_coin_new - get_noble_money:
logger_test_api.error(f'被赠送者贵族猫币错误{to_uid_noble_coin}:{to_uid_noble_coin_new}')
return False
if to_uid_exp != to_uid_exp_new - get_noble_exp:
logger_test_api.error(f'普通-平台经验错误{to_uid_exp}:{to_uid_exp_new}:{get_noble_exp}')
return False
if to_uid_lb != to_uid_lb_new - get_noble_lb:
logger_test_api.error(f'普通-喇叭错误{to_uid_lb}!={to_uid_lb_new}-{get_noble_lb}')
return False
# 判断主播提成
profit = User.find_noble_anchor_profit(to_uid, pay_money)
if _type == 'create' or _type == 'upgrade' or (_type == 'protect_create' and level != old_level):
# 开通/升级 获得一个月
noble_profit = noble_data[level][3] * 10 / 10 * discount
elif _type == 'renew' or (_type == 'protect_create' and level == old_level):
# 续费/续费保护期 不获得主播提成
noble_profit = 0
if profit != noble_profit:
logger_test_api.error(f'普通-主播提成错误{profit}')
return False
else:
# B 普通模式
# 1 判断花费猫币
buyer_coin_new = MoneyClass.get_money(buyer_uid)['coin']
if _type == 'create' or _type == 'upgrade' or (_type == 'protect_create' and level != old_level):
# 开通/升级/续费保护不同等级 首月原价,其他优惠价
pay_money = (noble_data[level][0] * 1 + noble_data[level][1] * (month - 1)) * discount
elif _type == 'renew' or (_type == 'protect_create' and level == old_level):
# 续费/续费保护相同等级购买 只花费折扣价格
pay_money = noble_data[level][1] * month * discount
if buyer_coin != buyer_coin_new + pay_money:
logger_test_api.error(f'普通-猫币错误{buyer_coin}:{buyer_coin_new}:{pay_money}')
return False
# 2 判断贵族猫币,平台经验,喇叭数量
buyer_lb_new = Bag.get_dmk(buyer_uid, 90011)
buyer_noble_coin_new = MoneyClass.get_noble_coin(buyer_uid)
buyer_exp_new = User.get_experience(buyer_uid)[0]
# 新逻辑 开通/续费/升级/续费保护期购买 获得所有
get_noble_money = noble_data[level][2] * discount * month
get_noble_exp = noble_data[level][4] * discount * month
get_noble_lb = noble_data[level][5] * month # 喇叭不打折
# if _type == 'create' or _type == 'protect_create' :
# # 开通/续费保护期购买 获得一个月
# get_noble_money = noble_data[level][2] * discount
# get_noble_exp = noble_data[level][4] * discount
# elif _type == 'renew':
# # 续费 不获得
# get_noble_money = 0
# get_noble_exp = 0
# elif _type == 'upgrade':
# # 返还第一个月和之前月份未给的
# get_noble_money = noble_data[level][2] * discount + noble_data[old_level][2] * (old_month - 1)
# get_noble_exp = noble_data[level][4] * discount + noble_data[old_level][4] * (old_month - 1)
#
if buyer_noble_coin != buyer_noble_coin_new - get_noble_money:
logger_test_api.error(f'普通-贵族猫币错误{buyer_noble_coin}:{buyer_noble_coin_new}')
return False
if buyer_exp != buyer_exp_new - get_noble_exp:
logger_test_api.error(f'普通-平台经验错误{buyer_exp}:{buyer_exp_new}:{get_noble_exp}')
return False
if buyer_lb != buyer_lb_new - get_noble_lb:
logger_test_api.error(f'普通-喇叭错误{buyer_lb}!={buyer_lb_new}-{get_noble_lb}')
return False
# 3 判断主播提成
profit = User.find_noble_anchor_profit(buyer_uid, pay_money)
if _type == 'create' or _type == 'upgrade' or (_type == 'protect_create' and level != old_level):
# 开通/升级 获得一个月
noble_profit = round(noble_data[level][3] * 10 / 10 * discount, 2)
elif _type == 'renew' or (_type == 'protect_create' and level == old_level):
# 续费/续费保护期 不获得主播提成
noble_profit = 0
if profit != noble_profit:
logger_test_api.error(f'普通-主播提成错误{noble_profit}:{profit}')
return False
return True
return _ver
'zhuxiao',
'lisiyuan',
'machao',
'xiawenhao',
'gaolingyun',
'huangrui',
'zhaoxu',
'yubinbin',
'yangjichao',
'liyu',
'liuyilin',
'yuhan',
]
#
# for i in users:
# try:
# name = 'hm_' + str(i) +'1'
# uid = User.find_uid(name)['msg']
# print(uid)
# REDIS_INST.delete(f'hm_{uid}')
# except Exception as e:
# print(e)
# [26342,26449]
for i in range(100):
u = User()
uid = u.reg('testling')
u.bd_sj(uid)
MoneyClass.set_money(uid, 1000000)
print(uid)
def test_11(self):
'''业务-角色功能判断-房管'''
self.exp_res = {'code': 200, 'data': {'extend': {'is_fg': '1'}}}
self.user = self.create_user()
User.set_fg(cid, self.user)
def test_07(self):
'''业务-发言间隔'''
self.exp_res = {'status': False, 'code': '204', 'message': '你发言太快！'}
self.user = self.create_user()
User.set_chat_time(self.user)
23: [60000000, 100, 120000],
24: [100000000, 100, 160000],
25: [150000000, 100, 200000],
26: [220000000, 100, 280000],
27: [310000000, 100, 360000],
28: [420000000, 100, 440000],
29: [550000000, 100, 520000],
30: [700000000, 100, 600000],
}
uids = list(range(5524, 5554))
# 测试各等级每日礼包
for i in fans_config.keys():
# 创建用户
uid = User.reg('fans')
# uid = uids[i-1]
# 设置粉丝值
User.loveliness('set', uid, 2, fans_config[i][0])
# 判断等级,每日礼包数量
ret = requests.post('http://lxy.new.huomaotv.com.cn/chatnew/joinMsg',
data=dict(cid=2, anchor_id=1522, is_yule=0),
cookies=Common.generate_cookies(uid)).json()
if int(ret['data']['fans']['level']) == i and Bag.get_bag(
uid, 20) == fans_config[i][1]:
print(uid, int(ret['data']['fans']['level']), i, Bag.get_bag(uid, 20),
fans_config[i][1], '测试ok')
else:
print(uid, int(ret['data']['fans']['level']), i, Bag.get_bag(uid, 20),
fans_config[i][1], '测试fail')
# 测试衰减脚本
def test(self, *args):
logger_test_api.info(args)
# 开通参数
self.data['month'] = args[-1]
self.data['level'] = args[-2]
self.old_level = args[1]
self.old_month = args[2]
# 创建购买用户
self.user = self.create_user()
# 是否赠送，创建用户贵族
if args[3]:
self.data['to_uid'] = self.create_user()
self.data['type'] = 2
if args[0] != 'first':
# 是首次开通,不用预先开通用户贵族
User.create_noble(self.data['to_uid'], level=self.old_level, month=self.old_month)
if args[0] == 'expired_protect':
User.set_noble_expire(self.data['to_uid'])
elif args[0] == 'expired':
User.set_noble_expire(self.data['to_uid'], 50)
else:
if args[0] != 'first':
User.create_noble(self.user, level=self.old_level, month=self.old_month)
if args[0] == 'expired_protect':
User.set_noble_expire(self.user)
elif args[0] == 'expired':
User.set_noble_expire(self.user, 50)
# 通用8折皇帝，国王不打折,指定打折卡,添加打折卡
self.discount = args[-3]
if isinstance(self.discount, dict):
# 添加打折卡
use_level = self.discount['level']
discount = self.discount['discount']
open_month = self.discount['month']
if discount < 10:
self.data['card'] = User.add_noble_card(self.user, use_level, discount, open_month)
else:
Bag.add_bag(self.user, self.discount['card'])
self.data['card'] = self.discount['card']
elif self.discount > 0 and self.data['level'] <= 5:
Bag.add_bag(self.user, bag=90001)
else:
self.discount = 10
# 验证
if isinstance(args[4], dict) and args[4].get('card'):
if self.old_level == self.data['level'] and args[0] == 'unexpired':
self.exp_res = {'code': 201, 'data': ''}
else:
self.ver = self.validate('renew')
elif args[0] == 'expired_protect':
self.ver = self.validate('protect_create')
elif args[0] == 'expired':
self.ver = self.validate('create')
elif args[0] == 'unexpired':
# 验证
if self.old_level == self.data['level']:
self.ver = self.validate('renew')
elif self.old_level < self.data['level']:
self.ver = self.validate('upgrade')
else:
self.exp_res = {'code': 201, 'data': ''}
else:
self.ver = self.validate()
def _ver():
noble_profit = get_noble_exp = get_noble_money = pay_money = False
if to_uid:
# A 赠送模式
# 1 判断增送者猫币
buyer_coin_new = MoneyClass.get_money(buyer_uid)['coin']
if _type == 'create' or _type == 'upgrade' or (_type == 'protect_create' and level != old_level):
# 开通/升级 首月原价,其他优惠价
pay_money = (noble_data[level][0] * 1 + noble_data[level][1] * (month - 1)) * discount
elif _type == 'renew' or (_type == 'protect_create' and level == old_level):
# 续费/续费保护期购买 只花费折扣价格
pay_money = noble_data[level][1] * month * discount
if buyer_coin != buyer_coin_new + pay_money:
logger_test_api.error(f'赠送者-猫币错误{buyer_coin}:{buyer_coin_new}')
return False
# 2 判断赠送者贵族猫币
buyer_noble_coin_new = MoneyClass.get_noble_coin(buyer_uid)
if buyer_noble_coin != buyer_noble_coin_new:
logger_test_api.error(f'赠送者贵族猫币错误{buyer_noble_coin}:{buyer_noble_coin_new}')
return False
# 3 判断赠送者平台经验
buyer_exp_new = User.get_experience(buyer_uid)[0]
if buyer_exp != buyer_exp_new:
logger_test_api.error(f'赠送者平台经验错误{buyer_exp}:{buyer_exp_new}')
return False
# 判断赠送者喇叭
buyer_lb_new = Bag.get_dmk(buyer_uid, 90011)
if buyer_lb != buyer_lb_new:
logger_test_api.error(f'赠送者喇叭错误{buyer_lb}:{buyer_lb_new}')
return False
# 4 判断被增送者猫币
to_uid_coin_new = MoneyClass.get_money(to_uid)['coin']
if to_uid_coin != to_uid_coin_new:
logger_test_api.error(f'被赠送者猫币错误{to_uid_coin}:{to_uid_coin_new}')
return False
# 5 判断被增送贵族猫币,平台经验,喇叭
to_uid_noble_coin_new = MoneyClass.get_noble_coin(to_uid)
to_uid_exp_new = User.get_experience(to_uid)[0]
to_uid_lb_new = Bag.get_dmk(to_uid, 90011)
get_noble_money = noble_data[level][2] * discount * month
get_noble_exp = noble_data[level][4] * discount * month
get_noble_lb = noble_data[level][5] * month
# if _type == 'create' or _type == 'protect_create':
# # 开通/续费保护期 获得一个月
# get_noble_money = noble_data[level][2] * discount
# get_noble_exp = noble_data[level][4] * discount
# elif _type == 'renew':
# # 续费 不获得
# get_noble_money = 0
# get_noble_exp = 0
# elif _type == 'upgrade':
# # 返还第一个月和之前月份未给的
# get_noble_money = noble_data[level][2] * discount + noble_data[old_level][2] * (old_month - 1)
# get_noble_exp = noble_data[level][4] * discount + noble_data[old_level][4] * (old_month - 1)
if to_uid_noble_coin != to_uid_noble_coin_new - get_noble_money:
logger_test_api.error(f'被赠送者贵族猫币错误{to_uid_noble_coin}:{to_uid_noble_coin_new}')
return False
if to_uid_exp != to_uid_exp_new - get_noble_exp:
logger_test_api.error(f'普通-平台经验错误{to_uid_exp}:{to_uid_exp_new}:{get_noble_exp}')
return False
if to_uid_lb != to_uid_lb_new - get_noble_lb:
logger_test_api.error(f'普通-喇叭错误{to_uid_lb}!={to_uid_lb_new}-{get_noble_lb}')
return False
# 判断主播提成
profit = User.find_noble_anchor_profit(to_uid, pay_money)
if _type == 'create' or _type == 'upgrade' or (_type == 'protect_create' and level != old_level):
# 开通/升级 获得一个月
noble_profit = noble_data[level][3] * 10 / 10 * discount
elif _type == 'renew' or (_type == 'protect_create' and level == old_level):
# 续费/续费保护期 不获得主播提成
noble_profit = 0
if profit != noble_profit:
logger_test_api.error(f'普通-主播提成错误{profit}')
return False
else:
# B 普通模式
# 1 判断花费猫币
buyer_coin_new = MoneyClass.get_money(buyer_uid)['coin']
if _type == 'create' or _type == 'upgrade' or (_type == 'protect_create' and level != old_level):
# 开通/升级/续费保护不同等级 首月原价,其他优惠价
pay_money = (noble_data[level][0] * 1 + noble_data[level][1] * (month - 1)) * discount
elif _type == 'renew' or (_type == 'protect_create' and level == old_level):
# 续费/续费保护相同等级购买 只花费折扣价格
pay_money = noble_data[level][1] * month * discount
if buyer_coin != buyer_coin_new + pay_money:
logger_test_api.error(f'普通-猫币错误{buyer_coin}:{buyer_coin_new}:{pay_money}')
return False
# 2 判断贵族猫币,平台经验,喇叭数量
buyer_lb_new = Bag.get_dmk(buyer_uid, 90011)
buyer_noble_coin_new = MoneyClass.get_noble_coin(buyer_uid)
buyer_exp_new = User.get_experience(buyer_uid)[0]
# 新逻辑 开通/续费/升级/续费保护期购买 获得所有
get_noble_money = noble_data[level][2] * discount * month
get_noble_exp = noble_data[level][4] * discount * month
get_noble_lb = noble_data[level][5] * month # 喇叭不打折
# if _type == 'create' or _type == 'protect_create' :
# # 开通/续费保护期购买 获得一个月
# get_noble_money = noble_data[level][2] * discount
# get_noble_exp = noble_data[level][4] * discount
# elif _type == 'renew':
# # 续费 不获得
# get_noble_money = 0
# get_noble_exp = 0
# elif _type == 'upgrade':
# # 返还第一个月和之前月份未给的
# get_noble_money = noble_data[level][2] * discount + noble_data[old_level][2] * (old_month - 1)
# get_noble_exp = noble_data[level][4] * discount + noble_data[old_level][4] * (old_month - 1)
#
if buyer_noble_coin != buyer_noble_coin_new - get_noble_money:
logger_test_api.error(f'普通-贵族猫币错误{buyer_noble_coin}:{buyer_noble_coin_new}')
return False
if buyer_exp != buyer_exp_new - get_noble_exp:
logger_test_api.error(f'普通-平台经验错误{buyer_exp}:{buyer_exp_new}:{get_noble_exp}')
return False
if buyer_lb != buyer_lb_new - get_noble_lb:
logger_test_api.error(f'普通-喇叭错误{buyer_lb}!={buyer_lb_new}-{get_noble_lb}')
return False
# 3 判断主播提成
profit = User.find_noble_anchor_profit(buyer_uid, pay_money)
if _type == 'create' or _type == 'upgrade' or (_type == 'protect_create' and level != old_level):
# 开通/升级 获得一个月
noble_profit = round(noble_data[level][3] * 10 / 10 * discount, 2)
elif _type == 'renew' or (_type == 'protect_create' and level == old_level):
# 续费/续费保护期 不获得主播提成
noble_profit = 0
if profit != noble_profit:
logger_test_api.error(f'普通-主播提成错误{noble_profit}:{profit}')
return False
return True
def create_user(self, phone=True):
uid = User.reg('noble')
logger_test_api.info(f'注册用户UID：{uid}')
if phone:
User.bd_sj(uid)
return uid
# Userbase.update(get_experience=0).where(Userbase.uid == '1522').execute()
# User.update_nick_name('22693'
#
# ,'运维的锅')ㅤㅤㅤㅤㅤㅤㅤ
# User.set_badge(5257,48)
# u = User()
# uid = u.reg('noble')
# # print(uid)
# # u.bd_sj(uid)
# MoneyClass.set_money(uid, 150000)
# # Bag.add_bag(uid,bag=90001)
# User.create_noble(35418, level=4, month=1,cid=2)
User.set_noble_expire(35418, 33)
#
# driver = webdriver.Chrome()
# driver.implicitly_wait(10)
# driver.get('http://lxy.new.huomaotv.com.cn/1')
# driver.maximize_window()
# CookieLogin(uid,driver)
# driver.get('http://lxy.new.huomaotv.com.cn/memberpay/noblePay')
# 非贵族
# 房主 t_n3247(26311) 1225388 粉丝0-1 徽章 0-3
#
# 贵族
# 房主 1
#!/usr/bin/env python # -*- coding: utf-8 -*- # Date : 2018/5/31 19:25 # Author : lixingyun # Description : from huomao.common import Common from time import time import requests from huomao.user import User User.add_noble_card(1522, 2, 2, 2) # STREAM_REFRESH_API_EXPIRE = 10 # a = Common.hash_table(30183) # print(a) # exit(1) # url = 'http://test1.api.huomao.com/channels/channelDetail' # # url = 'http://lxyapi.new.huomaotv.com.cn/channels/channelDetail' # data = dict( # refer='android', # cid=9418, # expires_time=1527757747, # post_data=1, # time=1528181184, # uid=27064, # now_time=int(time()), # an=67, # ver='dev2.4', # )
def create_user(self):
uid = User.reg('noble')
logger_test_api.info(f'注册用户UID：{uid}')
User.bd_sj(uid)
MoneyClass.set_money(uid, 9000000)
return uid
