def do_offline_order_by_device_code(device_code):
device_code_key = RedisClient.get_device_code_key(device_code)
record_key = redis_cache_client.get(device_code_key)
if record_key is None:
log.error("当前通过device_code = {} 下机失败, 没有在redis中找到对应的上机信息".format(
device_code))
return False
# 发送下机指令
return WindowsService.do_offline_order(record_key)
def check_connect():
if not request.is_json:
log.warn("参数错误...")
return fail(HTTP_OK, u"need application/json!!")
device_code = request.json.get('device_code')
if device_code is None:
return fail(HTTP_OK, u"not have device_code!!!")
# 获得设备使用状态
device_status = DeviceService.get_device_status(device_code)
if device_status is None:
return success({
'status': -1,
'device_status': device_status,
'msg': "not deploy"
})
# 保持心跳
DeviceService.keep_device_heart(device_code)
# 从维护状态跳转到空闲状态
if device_status == DeviceStatus.STATUS_MAINTAIN:
log.info("当前状态为维护状态，设备已经有心跳需要重新设置空闲状态!")
DeviceService.status_transfer(device_code, device_status,
DeviceStatus.STATUE_FREE)
# 重新获得设备状态
device_status = DeviceService.get_device_status(device_code)
device_code_key = RedisClient.get_device_code_key(device_code)
record_key = redis_cache_client.get(device_code_key)
if record_key is None:
return success({
'status': 0,
'device_status': device_status,
'msg': "not login"
})
return success({
"status": 1,
"token": record_key,
'device_status': device_status,
"msg": "login successed!"
})
def user_offline():
if not request.is_json:
log.warn("参数错误...")
return fail(HTTP_OK, u"need application/json!!")
user_id = request.json.get('user_id')
device_code = request.json.get('device_code')
device_id = request.json.get('device_id')
log.info("当前强制下机user_id = {}".format(user_id))
log.info("当前强制下机device_code = {}".format(device_code))
log.info("当前强制下机device_id = {}".format(device_id))
if user_id is not None:
user_key = RedisClient.get_user_key(user_id)
record_key = redis_cache_client.get(user_key)
if record_key is None:
return success({
'status':
0,
'msg':
"logout failed! reason: user device is already offline"
})
charging = redis_cache_client.get(record_key)
if charging is None:
return success({
'status':
0,
'msg':
"logout failed! reason: user device is already offline"
})
log.info("通过user_id下机: user_id = {}".format(user_id))
return WindowsService.do_offline(charging)
if device_code is not None:
device_code_key = RedisClient.get_device_code_key(device_code)
record_key = redis_cache_client.get(device_code_key)
if record_key is not None:
charging = redis_cache_client.get(record_key)
if charging is None:
return success({
'status':
0,
'msg':
"logout failed! reason: user device is already offline"
})
log.info("通过device_code下机: device_code = {}".format(device_code))
return WindowsService.do_offline(charging)
if device_id is not None:
device_key = RedisClient.get_device_key(device_id)
record_key = redis_cache_client.get(device_key)
if record_key is None:
return success({
'status':
0,
'msg':
"logout failed! reason: user device is already offline"
})
charging = redis_cache_client.get(record_key)
if charging is None:
return success({
'status':
0,
'msg':
"logout failed! reason: user device is already offline"
})
log.info("通过device_id下机: device_id = {}".format(device_id))
return WindowsService.do_offline(charging)
return success(u'当前参数没有使任何机器或用户下机')
def do_offline(charging):
# offline_lock_key = None
lock = None
if charging is None:
log.error("charging is None 下机异常!!")
return fail(HTTP_OK, u"下机异常!")
try:
charge_dict = json.loads(charging)
record_id = charge_dict.get('id')
user_id = charge_dict.get('user_id')
device_id = charge_dict.get('device_id')
charge_mode = charge_dict.get('charge_mode')
device_code = charge_dict.get('device_code')
openid = charge_dict.get('openid')
log.info(
"当前下线信息: user_id = {} device_id = {} charge_mode = {} device_code = {}"
.format(user_id, device_id, charge_mode, device_code))
# 获得用户上线key
user_key = RedisClient.get_user_key(user_id)
# 下机需要加锁
lock = DistributeLock(user_key, redis_cache_client)
log.info("开始加锁下机: user_key = {}".format(user_key))
# 加锁下机
lock.acquire()
# 判断是否已经在redis中进行记录
record_key = RedisClient.get_record_key(user_id, device_id)
if redis_cache_client.get(record_key) is None:
log.warn("当前用户或者设备已经下机: user_id = {} device_id = {}".format(
user_id, device_id))
return success({'status': 1, 'msg': 'logout successed!'})
# 结账下机
result, record, user = WindowsService.cal_offline(
user_id=user_id,
device_id=device_id,
record_id=record_id,
charge_mode=charge_mode)
if not result:
log.error(
"下机扣费失败: user_id = {} device_id = {} charge_mode = {}".
format(user_id, device_id, charge_mode))
return fail(HTTP_OK, u"下机失败！")
# 获得设备上线key
device_key = RedisClient.get_device_key(device_id)
# 获得当前设备token
device_code_key = RedisClient.get_device_code_key(device_code)
# 获得keep_alive_key 更新最新存活时间
user_online_key = RedisClient.get_user_online_key(record_key)
# 从redis中删除上机记录
redis_cache_client.delete(record_key)
redis_cache_client.delete(user_key)
redis_cache_client.delete(device_key)
redis_cache_client.delete(device_code_key)
redis_cache_client.delete(user_online_key)
is_success = True
except Exception as e:
log.error("数据解析失败: {}".format(charging))
log.exception(e)
return fail(HTTP_OK, u"数据解析失败!!")
finally:
# 解锁
if lock is not None:
lock.release()
log.info("下机完成: lock_key = {}".format(lock.lock_key))
# 如果成功则进行下机提醒
if is_success and openid is not None:
TemplateService.offline(openid, record, user.balance_account)
log.info("下机成功: user_id = {} device_id = {}".format(
user_id, device_id))
return success({'status': 1, 'msg': 'logout successed!'})
def do_online(user, device, charge_mode):
log.info("用户还未上机可以进行上机: user_id = {} device_id = {}".format(
user.id, device.id))
record, is_success = UseRecord.create(user.id, device.id,
device.address.province,
device.address.city,
device.address.area,
device.address.location)
if not is_success:
return False
# 判断是否已经在redis中进行记录
record_key = RedisClient.get_record_key(user.id, device.id)
# 获得用户上线key
user_key = RedisClient.get_user_key(user.id)
# 获得设备上线key
device_key = RedisClient.get_device_key(device.id)
# 获得当前设备token
device_code_key = RedisClient.get_device_code_key(device.device_code)
# 获得keep_alive_key 更新最新存活时间
user_online_key = RedisClient.get_user_online_key(record_key)
log.info(
"当前上机时间: user_id:{} device_id:{} record_id:{} ctime:{}".format(
user.id, device.id, record.id,
record.ctime.strftime('%Y-%m-%d %H:%M:%S')))
# 获得计费结构体
charging = record.to_charging()
# 得到计费方式
charging['charge_mode'] = charge_mode
# 得到当前用户总额
charging['balance_account'] = user.balance_account
# 填充设备机器码
charging['device_code'] = device.device_code
# 填充用户的openid
charging['openid'] = user.openid
# charging = {
# 'id': self.id,
# 'user_id': self.user_id,
# 'device_id': self.device_id,
# # 花费金额数目
# 'cost_money': self.cost_money,
# # 上机时间
# 'ctime': self.ctime.strftime('%Y-%m-%d %H:%M:%S'),
# # 更新时间，主要用户同步计费
# 'utime': self.utime.strftime('%Y-%m-%d %H:%M:%S'),
# # 已经上机时间
# 'cost_time': self.cost_time,
# # 计费方式 目前默认 5分钱/分钟
# 'charge_mode': 5,
# # 当前用户余额
# 'balance_account': 10000,
# # 设备机器码
# 'device_code': 'xx-xx-xx-xx-xx-xx',
# }
charge_str = json.dumps(charging)
# 操作redis 需要加锁
lock = DistributeLock(user_key, redis_cache_client)
try:
lock.acquire()
# 设置设备当前使用状态
if not DeviceService.set_device_status(device,
DeviceStatus.STATUE_BUSY):
log.error("设置设备状态失败, 上机异常！！！")
return False
# 开始上线 把上线信息存储redis
redis_cache_client.set(record_key, charge_str)
redis_cache_client.set(user_key, record_key)
redis_cache_client.set(device_key, record_key)
# 根据设备机器码获得记录token
redis_cache_client.set(device_code_key, record_key)
# 设置最新存活时间 最多存活五分钟
import time
redis_cache_client.setex(user_online_key,
settings.MAX_LOST_HEART_TIME,
int(time.time()))
is_success = True
except Exception as e:
is_success = False
log.exception(e)
finally:
lock.release()
# 判断上线是否成功
if is_success:
# 发送上线通知
TemplateService.online(user.openid, record.ctime, device.address,
user.balance_account, charge_mode)
return True