Merge pull request #859 from sisamiwe/dev-db_addon

DBADDON Plugin: Several updates

db_addon/locale.yaml

@@ -1,6 +1,7 @@
 # translations for the web interface
 plugin_translations:
     # Translations for the plugin specially for the web interface
+    'hourly':     {'de': 'stündlich', 'en': 'hourly'}
     'daily':     {'de': 'täglich', 'en': 'daily'}
     'weekly':    {'de': 'wöchentlich', 'en': '='}
     'monthly':   {'de': 'monatlich', 'en': '='}

db_addon/user_doc.rst

@@ -218,8 +218,8 @@ Erläuterungen zu Temperatursummen
 Grünlandtemperatursumme
 -----------------------
 
-Beim Grünland wird die Wärmesumme nach Ernst und Loeper benutzt, um den Vegetationsbeginn und somit den Termin von Düngungsmaßnahmen zu bestimmen. 
-Dabei erfolgt die Aufsummierung der Tagesmitteltemperaturen über 0 °C, wobei der Januar mit 0.5 und der Februar mit 0.75 gewichtet wird. 
+Beim Grünland wird die Wärmesumme nach Ernst und Loeper benutzt, um den Vegetationsbeginn und somit den Termin von Düngungsmaßnahmen zu bestimmen.
+Dabei erfolgt die Aufsummierung der Tagesmitteltemperaturen über 0 °C, wobei der Januar mit 0.5 und der Februar mit 0.75 gewichtet wird.
 Bei einer Wärmesumme von 200 Grad ist eine Düngung angesagt.
 
 siehe: https://de.wikipedia.org/wiki/Gr%C3%BCnlandtemperatursumme
@@ -236,10 +236,10 @@ Folgende Parameter sind möglich / notwendig:
 
 Wachstumsgradtag
 ----------------
-Der Begriff Wachstumsgradtage (WGT) ist ein Überbegriff für verschiedene Größen. 
-Gemeinsam ist ihnen, daß zur Berechnung eine Lufttemperatur von einem Schwellenwert subtrahiert wird. 
-Je nach Fragestellung und Pflanzenart werden der Schwellenwert unterschiedlich gewählt und die Temperatur unterschiedlich bestimmt. 
-Verfügbar sind die Berechnung über 0) "einfachen Durchschnitt der Tagestemperaturen", 1) "modifizierten Durchschnitt der Tagestemperaturen" 
+Der Begriff Wachstumsgradtage (WGT) ist ein Überbegriff für verschiedene Größen.
+Gemeinsam ist ihnen, daß zur Berechnung eine Lufttemperatur von einem Schwellenwert subtrahiert wird.
+Je nach Fragestellung und Pflanzenart werden der Schwellenwert unterschiedlich gewählt und die Temperatur unterschiedlich bestimmt.
+Verfügbar sind die Berechnung über 0) "einfachen Durchschnitt der Tagestemperaturen", 1) "modifizierten Durchschnitt der Tagestemperaturen"
 und 2) Anzahl der Tage, deren Mitteltempertatur oberhalb der Schwellentemperatur lag.
 
 siehe https://de.wikipedia.org/wiki/Wachstumsgradtag
@@ -260,7 +260,7 @@ Wärmesumme
 ----------
 
 Die Wärmesumme soll eine Aussage über den Sommer und die Pflanzenreife liefern. Es gibt keine eindeutige Definition der Größe "Wärmesumme".
-Berechnet wird die Wärmesumme als Summe aller Tagesmitteltemperaturen über einem Schwellenwert ab dem 1.1. des Jahres. 
+Berechnet wird die Wärmesumme als Summe aller Tagesmitteltemperaturen über einem Schwellenwert ab dem 1.1. des Jahres.
 
 siehe https://de.wikipedia.org/wiki/W%C3%A4rmesumme
 
@@ -278,7 +278,7 @@ Folgende Parameter sind möglich / notwendig:
 Kältesumme
 ----------
 
-Die Kältesumme soll eine Aussage über die Härte des Winters liefern. 
+Die Kältesumme soll eine Aussage über die Härte des Winters liefern.
 Berechnet wird die Kältesumme als Summe aller negativen Tagesmitteltemperaturen ab dem 21.9. des Jahres bis 31.3. des Folgejahres.
 
 siehe https://de.wikipedia.org/wiki/K%C3%A4ltesumme

db_addon/webif/__init__.py

@@ -59,7 +59,7 @@ def __init__(self, webif_dir, plugin):
         self.tplenv = self.init_template_environment()
 
     @cherrypy.expose
-    def index(self, reload=None):
+    def index(self, reload=None, action=None, item_path=None, active=None, option=None):
         """
         Build index.html for cherrypy
 
@@ -68,17 +68,31 @@ def index(self, reload=None):
         :return: contents of the template after being rendered
         """
 
+        pagelength = self.plugin.get_parameter_value('webif_pagelength')
         tmpl = self.tplenv.get_template('index.html')
 
+        if action is not None:
+            if action == "recalc_item" and item_path is not None:
+                self.logger.info(f"Recalc of item={item_path} called via WebIF. Item put to Queue for new calculation.")
+                self.plugin.execute_items(option='item', item=item_path)
+
+            elif action == "clean_item_cache" and item_path is not None:
+                self.logger.info(f"Clean item cache of item={item_path} called via WebIF. Plugin item value cache will be cleaned.")
+                self.plugin._clean_item_cache(item=item_path)
+
+            elif action == "_activate_item_calculation" and item_path is not None and active is not None:
+                self.logger.info(f"Item calculation of item={item_path} will be set to {bool(int(active))} via WebIF.")
+                self.plugin._activate_item_calculation(item=item_path, active=bool(int(active)))
+
         return tmpl.render(p=self.plugin,
-                           webif_pagelength=self.plugin.get_parameter_value('webif_pagelength'),
+                           webif_pagelength=pagelength,
                            suspended='true' if self.plugin.suspended else 'false',
                            items=self.plugin.get_item_list('db_addon', 'function'),
                            item_count=len(self.plugin.get_item_list('db_addon', 'function')),
                            plugin_shortname=self.plugin.get_shortname(),
                            plugin_version=self.plugin.get_version(),
                            plugin_info=self.plugin.get_info(),
-                           maintenance=True if self.plugin.log_level == 10 else False,
+                           maintenance=True if self.plugin.log_level < 20 else False,
                            )
 
     @cherrypy.expose
@@ -94,24 +108,70 @@ def get_data_html(self, dataSet=None):
         if dataSet is None:
             # get the new data
             data = dict()
-            data['items'] = {}
 
+            data['items'] = {}
             for item in self.plugin.get_item_list('db_addon', 'function'):
-                data['items'][item.id()] = {}
-                data['items'][item.id()]['value'] = item.property.value
-                data['items'][item.id()]['last_update'] = item.property.last_update.strftime('%d.%m.%Y %H:%M:%S')
-                data['items'][item.id()]['last_change'] = item.property.last_change.strftime('%d.%m.%Y %H:%M:%S')
+                data['items'][item.path()] = {}
+                data['items'][item.path()]['value'] = item.property.value
+                data['items'][item.path()]['last_update'] = item.property.last_update.strftime('%d.%m.%Y %H:%M:%S')
+                data['items'][item.path()]['last_change'] = item.property.last_change.strftime('%d.%m.%Y %H:%M:%S')
 
             data['plugin_suspended'] = self.plugin.suspended
             data['maintenance'] = True if self.plugin.log_level == 10 else False
             data['queue_length'] = self.plugin.queue_backlog()
             data['active_queue_item'] = self.plugin.active_queue_item
 
+            data['debug_log'] = {}
+            for debug in ['parse', 'execute', 'ondemand', 'onchange', 'prepare', 'sql']:
+                data['debug_log'][debug] = getattr(self.plugin.debug_log, debug)
+
             try:
                 return json.dumps(data, default=str)
             except Exception as e:
                 self.logger.error(f"get_data_html exception: {e}")
 
+    @cherrypy.expose
+    def submit(self, item=None):
+        result = None
+        item_path, cmd = item.split(':')
+        if item_path is not None and cmd is not None:
+            self.logger.debug(f"Received db_addon {cmd=} for {item_path=} via web interface")
+
+            if cmd == "recalc_item":
+                self.logger.info(f"Recalc of item={item_path} called via WebIF. Item put to Queue for new calculation.")
+                result = self.plugin.execute_items(option='item', item=item_path)
+                self.logger.debug(f"Result for web interface: {result}")
+                return json.dumps(result).encode('utf-8')
+
+            elif cmd == "clean_item_cache":
+                self.logger.info(f"Clean item cache of item={item_path} called via WebIF. Plugin item value cache will be cleaned.")
+                result = self.plugin._clean_item_cache(item=item_path)
+                self.logger.debug(f"Result for web interface: {result}")
+                return json.dumps(result).encode('utf-8')
+
+            elif cmd.startswith("suspend_plugin_calculation"):
+                self.logger.debug(f"set_plugin_calculation {cmd=}")
+                cmd, value = cmd.split(',')
+                value = True if value == "True" else False
+                self.logger.info(f"Plugin will be set to suspended: {value} via WebIF.")
+                result = self.plugin.suspend(value)
+                self.logger.debug(f"Result for web interface: {result}")
+                return json.dumps(result).encode('utf-8')
+
+            elif cmd.startswith("suspend_item_calculation"):
+                cmd, value = cmd.split(',')
+                self.logger.info(f"Item calculation of item={item_path} will be set to suspended: {value} via WebIF.")
+                value = True if value == "True" else False
+                result = self.plugin._suspend_item_calculation(item=item_path, suspended=value)
+                self.logger.debug(f"Result for web interface: {result}")
+                return json.dumps(result).encode('utf-8')
+
+        if result is not None:
+            # JSON zurücksenden
+            cherrypy.response.headers['Content-Type'] = 'application/json'
+            self.logger.debug(f"Result for web interface: {result}")
+            return json.dumps(result).encode('utf-8')
+
     @cherrypy.expose
     def recalc_all(self):
         self.logger.debug(f"recalc_all called")
@@ -136,3 +196,69 @@ def activate(self):
     def suspend(self):
         self.logger.debug(f"suspend called")
         self.plugin.suspend(True)
+
+    @cherrypy.expose
+    def debug_log_option(self, log: str = None, state: bool = None):
+        self.logger.warning(f"debug_log_option called with {log=}, {state=}")
+        _state = True if state == 'true' else False
+        setattr(self.plugin.debug_log, log, _state)
+
+    @cherrypy.expose
+    def debug_log_option_parse_true(self):
+        self.logger.debug("debug_log_option_parse_true")
+        setattr(self.plugin.debug_log, 'parse', True)
+
+    @cherrypy.expose
+    def debug_log_option_parse_false (self):
+        self.logger.debug("debug_log_option_parse_false")
+        setattr(self.plugin.debug_log, 'parse', False)
+
+    @cherrypy.expose
+    def debug_log_option_execute_true(self):
+        self.logger.debug("debug_log_option_execute_true")
+        setattr(self.plugin.debug_log, 'execute', True)
+
+    @cherrypy.expose
+    def debug_log_option_execute_false (self):
+        self.logger.debug("debug_log_option_execute_false")
+        setattr(self.plugin.debug_log, 'execute', False)
+
+    @cherrypy.expose
+    def debug_log_option_ondemand_true(self):
+        self.logger.debug("debug_log_option_ondemand_true")
+        setattr(self.plugin.debug_log, 'ondemand', True)
+
+    @cherrypy.expose
+    def debug_log_option_ondemand_false (self):
+        self.logger.debug("debug_log_option_ondemand_false")
+        setattr(self.plugin.debug_log, 'ondemand', False)
+
+    @cherrypy.expose
+    def debug_log_option_onchange_true(self):
+        self.logger.debug("debug_log_option_onchange_true")
+        setattr(self.plugin.debug_log, 'onchange', True)
+
+    @cherrypy.expose
+    def debug_log_option_onchange_false (self):
+        self.logger.debug("debug_log_option_onchange_false")
+        setattr(self.plugin.debug_log, 'onchange', False)
+
+    @cherrypy.expose
+    def debug_log_option_prepare_true(self):
+        self.logger.debug("debug_log_option_prepare_true")
+        setattr(self.plugin.debug_log, 'prepare', True)
+
+    @cherrypy.expose
+    def debug_log_option_prepare_false (self):
+        self.logger.debug("debug_log_option_prepare_false")
+        setattr(self.plugin.debug_log, 'prepare', False)
+
+    @cherrypy.expose
+    def debug_log_option_sql_true(self):
+        self.logger.debug("debug_log_option_sql_true")
+        setattr(self.plugin.debug_log, 'sql', True)
+
+    @cherrypy.expose
+    def debug_log_option_sql_false (self):
+        self.logger.debug("debug_log_option_sql_false")
+        setattr(self.plugin.debug_log, 'sql', False)