Trixy/Stats/HouseStats.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from datetime import datetime
from abc import ABC, abstractmethod


class _airStats(object):
    oxigenLevel = 0
    nitrogenLevel = 0
    methaneLevel = 0
    sulfurDioxidLevel = 0
    carbonMonoxidLevel = 0
    carbonDioxidLevel = 0
    particles_pm1 = 0
    particles_pm5 = 0
    particles_pm10 = 0

    def getJSON(self):
        return {
            "Oxigen": self.oxigenLevel,
            "Nitrogen": self.nitrogenLevel,
            "Methane": self.methaneLevel,
            "Sulfurdioxid": self.sulfurDioxidLevel,
            "Carbonmonoxid": self.carbonMonoxidLevel,
            "Carbondioxid": self.carbonDioxidLevel,
            "Particles_PM1": self.particles_pm1,
            "Particles_PM5": self.particles_pm5,
            "Particles_PM10":self.particles_pm10
        }

class _temperatureProperty:
    _temperature = dict()
    __temperature_count = 0
    __temperature_coldest = 22
    __temperature_hottest = 22
    __temperature_avg = 22

    @property
    def count(self) -> int:
        return self.__temperature_count

    @property
    def coldest(self) -> float:
        return self.__temperature_coldest

    @property
    def hottest(self) -> float:
        return self.__temperature_hottest

    @property
    def avg(self) -> float:
        if self.__temperature_count==0:
            return 20.0
        else:
            return self.__temperature_avg

    def set(self, id:str, value:float):
        if id in self._temperature:
            if self._temperature[id] == value:
                # Value exists and didn't change
                return
        # Key doesn't exists or value has changed
        self._temperature[id] = value
        count = 0
        tempMin = 99.9
        tempMax = 0.0
        tempTotal = 0.0
        for k,v in self._temperature.items():
            count+=1
            tempTotal+=v
            if tempMin > v:
                tempMin = v
            if tempMax < v:
                tempMax = v
        self.__temperature_count = int(count)
        self.__temperature_coldest = float(tempMin)
        self.__temperature_hottest = float(tempMax)
        if count==0:
            return 20.0
        else:
            self.__temperature_avg = float(tempTotal / count)

    def getJSON(self):
        return {
            "count": self.count,
            "avg": self.avg,
            "coldest": self.coldest,
            "hottest": self.hottest
        }

class _toggleProperty(ABC):
    _objects = dict()
    _count = 0
    _active = 0
    _inactive = 0
    _time_active = datetime.now()
    _time_inactive = datetime.now()
    _time_all_active = datetime.now()
    _time_all_inactive = datetime.now()

    @property
    def count(self) -> int:
        return self._count

    def set(self, id:str, state:bool):
        if id in self._objects:
            if self._objects[id] == state:
                # Value exists and didn't change
                return
        # Key doesn't exists or value has changed
        if self._count == self._off:
            self._time_all_inactive = datetime.now()
        if self._off>0:
            self._time_inactive = datetime.now()
        if self._count == self._open:
            self._time_all_active = datetime.now()
        if self._on>0:
            self._time_active = datetime.now()

        self._objects[id] = state
        count = 0
        countOn = 0
        countOff = 0
        for k,v in self._objects.items():
            count+=1
            if v==True:
                countOn+=1
            else:
                countOff+=1
        self._count = count
        self._active = countOn
        self._inactive = countOff

    @abstractmethod
    def getJSON(self):
        pass

    def _readableTime(self, time:datetime):
        return time

class _onOffProperty(_toggleProperty):
    @property
    def bAllOn(self) -> bool:
        return self._count <= self._active

    @property
    def bAllOff(self) -> bool:
        return self._count <= self._inactive

    @property
    def on(self) -> int:
        return self._active

    @property
    def off(self) -> int:
        return self._inactive

    @property
    def lastTimeOn(self) -> datetime:
        if self._active>0:
            return datetime.now()
        else:
            self._time_active

    @property 
    def lastTimeAllOn(self) -> datetime:
        if self._count == self._active:
            return datetime.now()
        else:
            self._time_all_active

    @property 
    def laseTimeOff(self) -> datetime:
        if self._inactive>0:
            return datetime.now()
        else:
            return self._time_inactive

    @property 
    def lastTimeAllOff(self) -> datetime:
        if self._count == self._inactive:
            return datetime.now()
        else:
            return self._time_all_inactive

    def getJSON(self):
        return {
            "All_Off": self.bAllOn,
            "All_On": self.bAllOff,
            "LastTimeOpen": self._readableTime(self.lastTimeOn),
            "LaseTimeClose": self._readableTime(self.laseTimeOff),
            "LastTimeAllOpen": self._readableTime(self.lastTimeAllOn),
            "LastTimeAllClosed": self._readableTime(self.lastTimeAllOff),
            "Count": self.count,
            "OnCount": self.on,
            "OffCount": self.off
        }

class _openCloseProperty(_toggleProperty):
    @property
    def bAllOpen(self) -> bool:
        return self._count <= self._active

    @property
    def bAllClose(self) -> bool:
        return self._count <= self._inactive

    @property
    def open(self) -> int:
        return self._active

    @property
    def close(self) -> int:
        return self._inactive

    @property
    def lastTimeOpen(self) -> datetime:
        if self._active>0:
            return datetime.now()
        else:
            self._time_active

    @property 
    def lastTimeAllOpen(self) -> datetime:
        if self._count == self._active:
            return datetime.now()
        else:
            self._time_all_active

    @property 
    def laseTimeClose(self) -> datetime:
        if self._inactive>0:
            return datetime.now()
        else:
            return self._time_inactive

    @property 
    def lastTimeAllClose(self) -> datetime:
        if self._count == self._inactive:
            return datetime.now()
        else:
            return self._time_all_inactive

    def getJSON(self):
        return {
            "All_Closed": self.bAllOpen,
            "All_Opened": self.bAllClose,
            "LastTimeOpen": self._readableTime(self.lastTimeOpen),
            "LaseTimeClose": self._readableTime(self.laseTimeClose),
            "LastTimeAllOpen": self._readableTime(self.lastTimeAllOpen),
            "LastTimeAllClosed": self._readableTime(self.lastTimeAllClose),
            "Count": self.count,
            "OpenCount": self.open,
            "CloseCount": self.close
        }

class HouseStats(object):
    
    def __init__(self):
        self._movements = dict()
        self._rooms = dict()
        self._air = _airStats()
        self.__lightsProp = _onOffProperty()
        self.__switchesProp = _onOffProperty()
        self.__windowsProp = _openCloseProperty()
        self.__doorsProp = _openCloseProperty()
        self.__temperature = _temperatureProperty()

    @property
    def Lights(self) -> _onOffProperty:
        return self.__lightsProp

    @property
    def Switches(self) -> _onOffProperty:
        return self.__switchesProp

    @property
    def Windows(self) -> _onOffProperty:
        return self.__windowsProp

    @property
    def Doors(self) -> _onOffProperty:
        return self.__doorsProp
    
    @property
    def Temperature(self) -> _temperatureProperty:
        return self.__temperature
    
    @property
    def Air(self) -> _airStats:
        return self._air
    
    #TODO Rooms

    #TODO Movement Stats

    def getJson(self):
        return {
            "Temperature": self.Temperature.getJSON(),
            "Windows": self.Windows.getJSON(),
            "Doors": self.Doors.getJSON(),
            "Lights": self.Lights.getJSON(),
            "Switches": self.Lights.getJSON(),
            "Air": self.Air.getJSON(),
            "Rooms": {
                # TODO
            },
            "Movements": {
                # TODO
            }
        }