manyi/apps/web/eventer/__init__.py

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

import datetime
import logging
import time
from functools import wraps

from typing import TYPE_CHECKING

from apps.web.device.timescale import FluentedEngine


if TYPE_CHECKING:
    from apps.web.core.adapter.base import SmartBox
    from apps.web.eventer.base import WorkEvent


logger = logging.getLogger(__name__)


class EventBuilder(object):
    def __init__(self, smartBox):
        # type:(SmartBox)->None

        self.deviceAdapter = smartBox

    @property
    def device(self):
        return self.deviceAdapter.device

    @property
    def support_507_power(self):
        return False

    def getEvent(self, device_event):
        event = self.__getEvent__(device_event)
        if not event:
            return event
        else:
            event.isPlayback = device_event.pop('playback', False)
            event.recvTime = device_event.pop('recvTime', int(time.time()))
            return event

    def __getEvent__(self, device_event):
        # type:(dict)->Event

        raise NotImplementedError('must implement __getEvent__.')


class Event(object):
    def __init__(self, smartBox):
        # type:(SmartBox)->None

        self.deviceAdapter = smartBox  # type: SmartBox
        self.isPlayback = False
        self.recvTime = int(time.time())

    @property
    def device(self):
        return self.deviceAdapter.device

    @property
    def dealer(self):
        """
        使用的时候再动态查询 减少数据库访问次数
        """
        return self.deviceAdapter.device.owner

    def do(self, **args):
        pass

    def is_notify_dealer(self):
        return False

    def is_notify_user(self):
        return False

    def notify_user(self, managerialOpenId, templateName, url = None, **kwargs):
        try:
            if not self.dealer:
                logger.error('dealer is null')
                return

            if not managerialOpenId:
                logger.error('managerialOpenId is null')
                return

            from taskmanager.mediator import task_caller
            task_caller('report_to_user_via_wechat', openId = managerialOpenId, dealerId = str(self.dealer.id),
                        templateName = templateName, url = url, **kwargs)
        except Exception as e:
            logger.exception(e)

    def notify_dealer(self, templateName, **kwargs):
        try:
            if not self.dealer or not self.dealer.managerialOpenId:
                return

            from taskmanager.mediator import task_caller
            task_caller('report_to_dealer_via_wechat', openId = self.dealer.managerialOpenId,
                        dealerId = str(self.dealer.id),
                        templateName = templateName,
                        **kwargs)

            # 合伙人一起推送
            groups = self.device.group
            partnerDict = groups.get('partnerDict')
            if partnerDict:
                from apps.web.dealer.models import Dealer
                for id in partnerDict:
                    partner = Dealer.objects.filter(id=id).first()
                    if partner and partner.devFaultPushDealerSwitch: # 有合伙人 并且打开了故障通知开关
                        task_caller('report_to_dealer_via_wechat', openId=partner.managerialOpenId,
                                    dealerId=id,
                                    templateName=templateName,
                                    **kwargs)
                    else:
                        pass


        except Exception as e:
            logger.exception(e)

    def notify_service_complete(self, managerialOpenId, title, service, finishTime = None):

        finishTime = finishTime or datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')

        self.notify_user(managerialOpenId, 'service_complete',
                         **{
                             'title': title,
                             'service': service,
                             'finishTime': finishTime,
                             'remark': u'谢谢您的支持'
                         }
                         )

    def notify_refund_coins(self, managerialOpenId, title, backCount, finishTime = None):
        finishTime = finishTime or datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')

        self.notify_user(managerialOpenId, 'refund_coins',
                         **{
                             'title': title,
                             'backCount': backCount,
                             'finishTime': finishTime
                         }
                         )

    @property
    def support_playback(self):
        return False


# 粤万通功率记录装饰器 临时使用 不干扰本来业务处理功率上报的逻辑 额外将power进入新的处理程序进行处理 后续驱动全网修改之后 直接将装饰器注释即可
def powerRecorder(stop=False):
    def wrapper(f):
        @wraps(f)
        def inner(eventer, *args, **kwargs):

            res = f(eventer, *args, **kwargs)
            try:
                from apps.web.device.models import Device

                if not eventer.device.support_power_graph:
                    otherConf = eventer.device.get("otherConf", dict())
                    otherConf["supportPG"] = True
                    Device.objects.get(devNo=eventer.device.devNo).update(otherConf=otherConf)
                    Device.invalid_device_cache(eventer.device.devNo)

                    # 相当于重载一次
                    # eventer.device = Device.get_dev(eventer.device.devNo)

                # 停止事件上来的时候 事件内部处理时再去请求一次功率 这个就不需要了 直接置为0吧
                power = eventer.event_data["power"] if not stop else 0
                port = eventer.event_data["portStr"]

                FluentedEngine().in_power_udp(
                    devNo=eventer.device.devNo,
                    port=str(port),
                    ts=int(time.time()),
                    power=power,
                    voltage=None,
                    current=None
                )
            except KeyError:
                logging.error("record yuewantong power error, eventer is {}, params = {}, {}".format(eventer, args, kwargs))

            return res

        return inner
    return wrapper