manyi/apps/web/core/adapter/time3.py

# -*- coding: utf-8 -*-
# !/usr/bin/env python

import datetime
import time

from apilib.utils_datetime import to_datetime
from apilib.utils_json import JsonResponse
from apps.web.constant import DeviceCmdCode, MQTT_TIMEOUT, ErrorCode, Const
from apps.web.core.adapter.base import SmartBox
from apps.web.core.exceptions import ServiceException
from apps.web.core.networking import MessageSender
from apps.web.device.models import Device
from apps.web.core.device_define import PackageDict


class TimeSwitchBox3(SmartBox):
    def __init__(self, device):
        super(TimeSwitchBox3, self).__init__(device)

    def test(self, coins):
        now_time = datetime.datetime.now()

        return MessageSender.send(device = self.device, cmd = DeviceCmdCode.PAY_MONEY, payload = {
            't': int(time.mktime(now_time.timetuple())),
            'duration': 300
        })

    def stop(self, port = None):
        Device.invalid_device_control_cache(self.device.devNo)

        devInfo = MessageSender.send(device = self.device, cmd = DeviceCmdCode.STOP_DEVICE, payload = {
            't': int(time.time())
        })
        if devInfo['rst'] == 0:
            if 'left_time' in devInfo:
                devInfo['remainder_time'] = int(devInfo['left_time'] / 60.0)
            else:
                devInfo['remainder_time'] = int(devInfo['remainder_time'] / 60.0)

        return devInfo

    def start_device(self, package, openId, attachParas):
        #: 首先检查设备是否在线
        now_time = datetime.datetime.now()

        duration = PackageDict(package).estimated_duraion

        devInfo = MessageSender.send(device = self.device,
                                     cmd = DeviceCmdCode.PAY_MONEY,
                                     payload = {
                                         't': int(time.mktime(now_time.timetuple())),
                                         'duration': duration
                                     }, timeout = MQTT_TIMEOUT.START_DEVICE)
        if devInfo.has_key('rst') and devInfo['rst'] != 0:
            current_dev_type_name = self.device['devType']['name']
            if current_dev_type_name == u'其他':
                current_dev_type_name = u'自助设备'

            if devInfo['rst'] == -1:
                description = u'当前' + current_dev_type_name + u'正在玩命找网络，您的金币还在，重试不会扣款，建议您试试旁边其他设备，或者试试投硬币，或者稍后再试哦'
                raise ServiceException({'result': ErrorCode.DEVICE_CONN_FAIL, 'description': description})
            elif devInfo['rst'] == 1:
                description = u'当前' + current_dev_type_name + u'正在忙，无响应，您的金币还在，重试不会扣款，请试试其他线路，或者请稍后再试哦'
                raise ServiceException({'result': ErrorCode.BOARD_UART_TIMEOUT, 'description': description})

        if 'left_time' in devInfo:
            # 新版本设置到设备后, 时间是上次还剩下的时间加上本次下发的时间
            needTime = devInfo['left_time']

            devInfo['finishedTime'] = (int(time.mktime(now_time.timetuple())) + int(needTime))

            Device.update_dev_control_cache(
                self.device['devNo'],
                {
                    'status': Const.DEV_WORK_STATUS_WORKING,
                    'finishedTime': devInfo['finishedTime'],
                    'openId': openId,
                    'startTime': now_time.strftime('%Y-%m-%d %H:%M:%S'),
                    'needTime': needTime,
                    'vCardId': self._vcard_id
                })

            return devInfo
        else:
            # 老版本去模块取时间
            devInfo = MessageSender.send(device = self.device, cmd = DeviceCmdCode.GET_DEVINFO, payload = {
                'fields': ['remainder_time']
            })

            if devInfo.has_key('rst') and devInfo['rst'] == 0 and devInfo.has_key('remainder_time'):
                needTime = devInfo['remainder_time'] / 1000.0
            else:
                needTime = duration

            devInfo['finishedTime'] = (int(time.time()) + int(needTime))

            Device.update_dev_control_cache(self.device.devNo,
                                            {
                                                'status': Const.DEV_WORK_STATUS_WORKING,
                                                'finishedTime': devInfo['finishedTime'],
                                                'openId': openId,
                                                'startTime': now_time.strftime('%Y-%m-%d %H:%M:%S'),
                                                'needTime': needTime,
                                                'vCardId': self._vcard_id
                                            })

            return devInfo

    def get_left_time(self):
        ctrInfo = Device.get_dev_control_cache(self.device['devNo'])
        if (ctrInfo is None) or (not ctrInfo.has_key('status')) or (
                ctrInfo['status'] == Const.DEV_WORK_STATUS_IDLE):
            return 0.0, 0.0

        devInfo = MessageSender.send(device = self.device,
                                     cmd = DeviceCmdCode.GET_DEVINFO,
                                     payload = {'fields': ['remainder_time', 'left_time']})
        if devInfo.has_key('rst') and devInfo['rst'] != 0:
            if ctrInfo.has_key('startTime') and ctrInfo.has_key('needTime'):
                startTime = to_datetime(ctrInfo['startTime'])
                needTime = ctrInfo['needTime'] / 60.0
                leftTime = needTime - (datetime.datetime.now() - startTime).total_seconds() / 60.0
                return leftTime, needTime

            current_dev_type_name = self.device['devType']['name']
            if current_dev_type_name == u'其他':
                current_dev_type_name = u'自助设备'

            if devInfo['rst'] == -1:
                description = u'当前' + current_dev_type_name + u'正在玩命找网络，建议您试试旁边其他设备，或者试试投硬币，或者稍后再试哦'
                raise ServiceException({'result': 2, 'description': description})
            elif devInfo['rst'] == 1:
                description = u'当前' + current_dev_type_name + u'正在忙，无响应，请稍后再试哦'
                raise ServiceException({'result': 2, 'description': description})

        if 'left_time' in devInfo:
            # 新版本换一个字段,以秒为单位
            leftTime = devInfo['left_time']
            needTime = ctrInfo.get('needTime', leftTime)
        elif 'remainder_time' in devInfo:
            # 老版本是以毫秒为单位
            leftTime = devInfo['remainder_time'] / 1000.0
            needTime = ctrInfo.get('needTime', leftTime)
        elif ctrInfo.has_key('startTime') and ctrInfo.has_key('needTime'):
            startTime = to_datetime(ctrInfo['startTime'])
            needTime = ctrInfo['needTime'] / 60.0
            leftTime = needTime - (datetime.datetime.now() - startTime).total_seconds() / 60.0
            return leftTime, needTime
        else:
            return 0.0, 0.0

        if leftTime == 0.0:  # 顺便清理下状态
            Device.invalid_device_control_cache(self.device['devNo'])

        if needTime < leftTime:
            needTime = leftTime

        return leftTime / 60.0, needTime / 60.0

    def support_count_down(self, openId = None, port = None):
        return True

    def count_down(self, request, dev, agent, group, devType, lastOpenId, port = None):
        surplus, sumtime = self.get_left_time()
        orderProcessing = False
        if surplus == 0.0 and sumtime == 0.0:
            orderProcessing = True

        return JsonResponse(
            {
                'result': 1,
                'description': '',
                'payload': {
                    'surplus': surplus,
                    'sum': sumtime,
                    'name': group['groupName'],
                    'address': group['address'],
                    'code': devType.get('code'),
                    'orderProcessing': orderProcessing,
                    'logicalCode': dev['logicalCode'],
                    'user': 'me' if lastOpenId == request.user.openId else 'notme',
                    'agentFeatures': agent.features,
                }
            })