E-Manager/client/energyuser.py

import random
import sys
import json
import requests
class EnergyUser:
    def __init__(self, config):
        self.ID = config.get("ID")
        self.user_prio = config.get("user_prio", 0)
        self.lock_prio = config.get("lock_prio", 0)
        self.idle = True
        self.used_energy = 0
        self.current_power = 0
        self.current_delta_power = 0

        self.modular = False
        self.powersteps = []
        
    def calc_used_power(self):
        raise NotImplementedError("Subclasses must implement use_energy method")

        
        
    def use_energy(self, amount):
        raise NotImplementedError("Subclasses must implement use_energy method")
        

    
    
    def get_current_values(self):
        raise NotImplementedError("Subclasses must implement use_energy method")


    def get_requested_power(self):

                    max_power = max(self.powersteps)
                    return max_power if random.choice([True, False]) else max_power
                    return 0
                
    
    
    
    @staticmethod
    def create_userlist_from_json(json_data):
        subclasses = [cls for cls in sys.modules[__name__].__dict__.values() if isinstance(cls, type) and issubclass(cls, EnergyUser) and cls != EnergyUser]
    
        energy_users = []
        data = json.loads(json_data)
    
        for user_data in data["users"]:
            user_type = user_data["type"]
            user_config = user_data["config"]
            for subclass in subclasses:
                if user_type in subclass.__name__:
                    energy_users.append(subclass(user_config))
    
        return energy_users



    @staticmethod
    def get_all_current_values(users):
        data = {"User_data": { "Current_Power": 0, "Used_Energy": 0, "Current_Prio": 0, "Current_deltaPower": 0, "measured_Temp": 0}}
        for user in users:
                current_value = user.get_current_value()
                userdata = {
                    "Current_Power": current_value.get("Current_Power", 0),
                    "Used_Energy": current_value.get("Used_Energy", 0),
                    "Current_Prio": current_value.get("Current_Prio", 0),
                    "Current_deltaPower": current_value.get("Current_deltaPower", 0),
                    "measured_Temp": current_value.get("measured_Temp", 0)
                }
                
                data[user.ID] = userdata
        return data



class User1(EnergyUser):

    def __init__(self, config):
        self.ID = config.get("ID")
        self.user_prio = config.get("user_prio", 0)
        self.lock_prio = config.get("lock_prio", 0)
        self.idle = True
        self.used_energy = 6
        self.current_power = 0
        self.current_delta_power = 0   
        
        self.modular = False
        self.powersteps =  [100, 600]
        
        
    def calc_used_power(self):
        pass
                
    
    def use_energy(self, amount):
        print(f"Using energy as {self.ID} with amount {amount}")
        # Hier kannst du die spezifische Logik für User 1 implementieren
      
    def get_current_value(self):
                        return {"Current_Power": self.current_power,
                                "Used_Energy": self.used_energy,
                                "Current_Prio": self.user_prio,
                                "Idle": self.idle,
                                "Current_deltaPower": self.current_delta_power}





class User2(EnergyUser):
    modular = False
    powersteps = [200, 400]
    
    def __init__(self, config):
        self.ID = config.get("ID")
        self.user_prio = config.get("user_prio", 0)
        self.lock_prio = config.get("lock_prio", 0)
        self.idle = True
        self.used_energy = 4
        self.current_power = 0
        self.current_delta_power = 0
        
        self.modular = False
        self.powersteps = [0]
        
    
    def calc_used_power(self):
        pass
        

    def use_energy(self, amount):
        print(f"Using energy as {self.ID} with amount {amount}")
        # Hier kannst du die spezifische Logik für User 2 implementieren
    
    def get_current_value(self):
                        return {"Current_Power": self.current_power,
                                "Used_Energy": self.used_energy,
                                "Current_Prio": self.user_prio,
                                "Current_deltaPower": self.current_delta_power}




class Boiler_1Stufig_Shelly(EnergyUser):

    def __init__(self, config):
        self.ID = config.get("ID")
        self.user_prio = config.get("user_prio", 0)
        self.lock_prio = config.get("lock_prio", 0)
        self.idle = True
        self.used_energy = 0
        self.current_power = 0
        self.current_delta_power = 0   
        
        self.modular = False
        self.powersteps = [0]
        
        self.measured_Temp =0
        # userdefinierte Variablen
        self.boilerleistung = config.get("boilerpower", 0)
        self.temperatur = config.get("temperatur", 0)
        self.shelly_ip = config.get("shelly_ip")

    
    def get_shelly_temperature(self):
        try:
            url = f"http://{self.shelly_ip}/status"
            response = requests.get(url)
            if response.status_code == 200:
                data = response.json()
                temperature = data.get("ext_temperature", {}).get("0", {}).get("tC")
                self.measured_Temp =temperature

                return temperature
            else:
                print("Failed to get temperature from Shelly.")
                self.measured_Temp = 0

                return None
        except Exception as e:
            print(f"Error occurred while getting temperature from Shelly: {e}")
            return None
    
    def set_shelly_output(self, state):
        try:
            url = f"http://{self.shelly_ip}/relay/0?turn={'on' if state else 'off'}"
            response = requests.get(url)
            if response.status_code != 200:
                print("Failed to set Shelly output state.")
        except Exception as e:
            print(f"Error occurred while setting Shelly output state: {e}")
        
    def calc_used_power(self):
        
        temperature = self.get_shelly_temperature()
        if temperature is not None and temperature < self.temperatur:
            self.powersteps[0] = self.boilerleistung
        else:
            self.current_power = 0

    def use_energy(self, amount):
        if amount == self.boilerleistung:
            self.set_shelly_output(True)
        else:
            self.set_shelly_output(False)
        print(f"Using energy as {self.ID} with amount {amount}")
        
    def get_current_value(self):
        return {"Current_Power": self.current_power,
                "Used_Energy": self.used_energy,
                "Current_Prio": self.user_prio,
                "measured_Temp": self.measured_Temp,

                "Idle": self.idle,
                "Current_deltaPower": self.current_delta_power}