manyi/apps/common/utils.py

# -*- coding: utf-8 -*-
#!/usr/bin/env python
import calendar
import datetime
import math
import numbers
from typing import TYPE_CHECKING, Optional

from django.conf import settings
from pandas import date_range

from apps.web.constant import Const

if TYPE_CHECKING:
    from apps.web.device.models import DeviceDict
    from apps.web.dealer.models import Dealer


class CoordinateTrans(object):
    """
    坐标系转换
    """
    def __init__(self, lng=0.0, lat=0.0):
        """
        :param lng: 经度
        :param lat: 维度
        """
        self._x_pi = 3.14159265358979324 * 3000.0 / 180.0
        self._lng = lng
        self._lat = lat

    def bd09_to_gcj02(self):
        """
        百度坐标系到google坐标系的经纬度转换
        :return:
        """
        if self._lng == 0.0 or self._lat == 0.0:
            return self._lng, self._lat

        x = self._lng - 0.0065
        y = self._lat - 0.006
        z = math.sqrt(x * x + y * y) - 0.00002 * math.sin(y * self._x_pi)
        theta = math.atan2(y, x) - 0.000003 * math.cos(x * self._x_pi)
        gg_lng = z * math.cos(theta)
        gg_lat = z * math.sin(theta)
        return [gg_lng, gg_lat]

    def gcj02_to_bd09(self):
        """
        高德/谷歌 坐标系 转百度
        :return:
        """
        if self._lng == 0.0 or self._lat == 0.0:
            return self._lng, self._lat

        z = math.sqrt(self._lng * self._lng + self._lat * self._lat) + 0.00002 * math.sin(self._lat * self._x_pi)
        theta = math.atan2(self._lat, self._lng) + 0.000003 * math.cos(self._lng * self._x_pi)
        bd_lng = z * math.cos(theta) + 0.0065
        bd_lat = z * math.sin(theta) + 0.006
        return [bd_lng, bd_lat]

    def __call__(self, lng, lat, _type="b_to_g"):
        """
        :param lng:
        :param lat:
        :param _type: b_to_g 百度转高德   g_to_b 高德转百度
        :return:
        """
        self._lng = lng
        self._lat = lat

        if _type == "b_to_g":
            return self.bd09_to_gcj02()
        elif _type == "g_to_b":
            return self.gcj02_to_bd09()
        else:
            pass


class IntToHex(object):
    """
    数字转换16进制字符串
    """
    def __init__(self):
        self._number = None

    def _add_trans_number(self, number):
        if isinstance(number, numbers.Integral):
            self._number = number
        elif isinstance(number, str) and number.isdigit():
            self._number = int(number)
        else:
            raise TypeError("type of number must in <Integral，str>")

    @staticmethod
    def _reverse_hex(h):
        if not len(h):
            return ""
        return h[-2:] + IntToHex._reverse_hex(h[:-2])

    def __call__(self, number, lens=4, reverse=False):  # type:(Optional[numbers.Integral, str], int, bool) -> str
        if not isinstance(lens, numbers.Integral):
            raise TypeError("type of lens must be Integral")
        self._add_trans_number(number)

        formatStr = "{:0>%sX}" % lens
        numberHex = formatStr.format(self._number)
        if reverse:
            return IntToHex._reverse_hex(numberHex)

        return numberHex


class DealerGetPackages(object):

    def __init__(self, device, visitor, isTemp=False):   # type: (DeviceDict, Dealer, bool) -> None
        self._device = device
        self._visitor = visitor
        self._isTemp = isTemp

    @property
    def unitPrice(self):
        return self._device.otherConf.get("unit_price", "")

    @property
    def devData(self):  # type: ()-> dict
        """
        设备数据
        """
        if not self._device.is_registered:
            return {
                "id": self._device.devNo,
                "maxCoins": self._device.otherConf.get("maxCoins", 4),
                "devNo": self._device.devNo,
                "type": u"脉冲",
                "typeCode": u"201",
                "groupName": u"测试",
                "groupNumber": 666,
            }

        devData = {
            "id": self._device.devNo,
            "maxCoins": self._device.otherConf.get("maxCoins", 4),
            "devNo": self._device.devNo,
            "type": self._device.devTypeName,
            "typeCode": self._device.devTypeCode,
            "groupName": self._device.group.groupName,
            "groupNumber": self._device.groupNumber
        }

        if self._device.devTypeCode in [Const.DEVICE_TYPE_CODE_HP_GATE]:
            chargeIndex = {}
            if self._device.otherConf.get("controlEnter") in ("1", "2"):
                chargeIndex["enter"] = "idle"
            if self._device.otherConf.get("controlExit") in ("1", "2"):
                chargeIndex["exit"] = "idle"

            devData.update({"chargeIndex": chargeIndex})

        return devData

    @property
    def ruleList(self):  # type: () -> list
        """
        套餐列表
        """
        # 此处可以将套餐抽象化表达
        if not self._device.is_registered:
            rules = [
                {"id": "".format(i), "name": u"测试", "coins": i, "price": i}
                for i in range(1, 6)
            ]
        else:
            rules = []

        return rules


coordinateHandler = CoordinateTrans()

int_to_hex = IntToHex()


def get_start_and_end_by_month(monthStr):
    # type:(str) -> (str, str)
    """根据月份获取 当月月初和月末"""
    year, month = map(lambda x: int(x), monthStr.split("-"))
    firstWeekDay, lastDay = calendar.monthrange(year, month)

    startTime = datetime.date(year, month, 1).strftime("%Y-%m-%d")
    endTime = datetime.date(year, month, lastDay).strftime("%Y-%m-%d")

    return startTime, endTime


def get_start_and_end_by_year(yearStr):
    """
    获取年初 和年尾
    :param yearStr:
    :return:
    """
    return "{}-01-01".format(yearStr), "{}-12-31".format(yearStr)


def get_date_range(st, et, freq='D', reverse = True):
    if reverse:
        return list(reversed(date_range(st, et, freq=freq).tolist()))
    else:
        return list(date_range(st, et, freq=freq).tolist())


def get_test_point(domain, key):
    import os
    return os.environ.get('test_{}_{}'.format(domain, key), None)


def support_test_point(point):
    if not settings.DEBUG:
        return False

    import os
    test_point = os.environ.get(point, None)

    if test_point == 'yes':
        return True
    else:
        return False