\"");
+
+ $hash->{HELPER}{ACTIVE} = "off";
+ if (AttrVal($name,"debugactivetoken",0)) {
+ Log3($name, 3, "$name - Active-Token deleted by OPMODE: $hash->{OPMODE}");
+ }
+ return;
+ }
+
+ if($hash->{HELPER}{LOGINRETRIES} >= $lrt) {
+ # login wird abgebrochen, Freigabe Funktionstoken
+ $hash->{HELPER}{ACTIVE} = "off";
+ if (AttrVal($name,"debugactivetoken",0)) {
+ Log3($name, 3, "$name - Active-Token deleted by OPMODE: $hash->{OPMODE}");
+ }
+ Log3($name, 2, "$name - ERROR - Login or privilege of user $username unsuccessful");
+ return;
+ }
+
+ my $httptimeout = AttrVal($name,"httptimeout",4);
+ Log3($name, 5, "$name - HTTP-Call login will be done with httptimeout-Value: $httptimeout s");
+
+ my $urlwopw; # nur zur Anzeige bei verbose >= 4 und "showPassInLog" == 0
+
+ # sid in Quotes einschliessen oder nicht -> bei Problemen mit 402 - Permission denied
+ my $sid = AttrVal($name, "noQuotesForSID", "0") == 1 ? "sid" : "\"sid\"";
+
+ if (AttrVal($name,"session","DSM") eq "SurveillanceStation") {
+ $url = "$proto://$serveraddr:$serverport/webapi/$apiauthpath?api=$apiauth&version=$apiauthmaxver&method=Login&account=$username&passwd=$password&session=SurveillanceStation&format=$sid";
+ $urlwopw = "$proto://$serveraddr:$serverport/webapi/$apiauthpath?api=$apiauth&version=$apiauthmaxver&method=Login&account=$username&passwd=*****&session=SurveillanceStation&format=$sid";
+ } else {
+ $url = "$proto://$serveraddr:$serverport/webapi/$apiauthpath?api=$apiauth&version=$apiauthmaxver&method=Login&account=$username&passwd=$password&format=$sid";
+ $urlwopw = "$proto://$serveraddr:$serverport/webapi/$apiauthpath?api=$apiauth&version=$apiauthmaxver&method=Login&account=$username&passwd=*****&format=$sid";
+ }
+
+ AttrVal($name, "showPassInLog", "0") == 1 ? Log3($name, 4, "$name - Call-Out now: $url") : Log3($name, 4, "$name - Call-Out now: $urlwopw");
+ $hash->{HELPER}{LOGINRETRIES}++;
+
+ $param = {
+ url => $url,
+ timeout => $httptimeout,
+ hash => $hash,
+ user => $username,
+ funcret => $fret,
+ method => "GET",
+ header => "Accept: application/json",
+ callback => \&SSCam_login_return
+ };
+ HttpUtils_NonblockingGet ($param);
+}
+
+sub SSCam_login_return ($) {
+ my ($param, $err, $myjson) = @_;
+ my $hash = $param->{hash};
+ my $name = $hash->{NAME};
+ my $username = $param->{user};
+ my $fret = $param->{funcret};
+ my $subref = \&$fret;
+ my $success;
+
+ # Verarbeitung der asynchronen Rückkehrdaten aus sub "login_nonbl"
+ if ($err ne "") {
+ # ein Fehler bei der HTTP Abfrage ist aufgetreten
+ Log3($name, 2, "$name - error while requesting ".$param->{url}." - $err");
+
+ readingsSingleUpdate($hash, "Error", $err, 1);
+
+ return SSCam_login($hash,$fret);
+
+ } elsif ($myjson ne "") {
+ # wenn die Abfrage erfolgreich war ($data enthält die Ergebnisdaten des HTTP Aufrufes)
+
+ # Evaluiere ob Daten im JSON-Format empfangen wurden
+ ($hash, $success) = SSCam_evaljson($hash,$myjson);
+ unless ($success) {
+ Log3($name, 4, "$name - no JSON-Data returned: ".$myjson);
+ $hash->{HELPER}{ACTIVE} = "off";
+
+ if (AttrVal($name,"debugactivetoken",0)) {
+ Log3($name, 3, "$name - Active-Token deleted by OPMODE: $hash->{OPMODE}");
+ }
+ return;
+ }
+
+ my $data = decode_json($myjson);
+
+ # Logausgabe decodierte JSON Daten
+ Log3($name, 5, "$name - JSON decoded: ". Dumper $data);
+
+ $success = $data->{'success'};
+
+ if ($success) {
+ # login war erfolgreich
+ my $sid = $data->{'data'}->{'sid'};
+
+ # Session ID in hash eintragen
+ $hash->{HELPER}{SID} = $sid;
+
+ # Setreading
+ readingsBeginUpdate($hash);
+ readingsBulkUpdate($hash,"Errorcode","none");
+ readingsBulkUpdate($hash,"Error","none");
+ readingsEndUpdate($hash, 1);
+
+ # Logausgabe
+ Log3($name, 4, "$name - Login of User $username successful - SID: $sid");
+
+ return &$subref($hash);
+
+ } else {
+ # Errorcode aus JSON ermitteln
+ my $errorcode = $data->{'error'}->{'code'};
+
+ # Fehlertext zum Errorcode ermitteln
+ my $error = SSCam_experrorauth($hash,$errorcode);
+
+ # Setreading
+ readingsBeginUpdate($hash);
+ readingsBulkUpdate($hash,"Errorcode",$errorcode);
+ readingsBulkUpdate($hash,"Error",$error);
+ readingsEndUpdate($hash, 1);
+
+ # Logausgabe
+ Log3($name, 3, "$name - Login of User $username unsuccessful. Code: $errorcode - $error - try again");
+
+ return SSCam_login($hash,$fret);
+ }
+ }
+return SSCam_login($hash,$fret);
+}
+
+###################################################################################
+# Funktion logout
+###################################################################################
+sub SSCam_logout ($) {
+ my ($hash) = @_;
+ my $name = $hash->{NAME};
+ my $serveraddr = $hash->{SERVERADDR};
+ my $serverport = $hash->{SERVERPORT};
+ my $apiauth = $hash->{HELPER}{APIAUTH};
+ my $apiauthpath = $hash->{HELPER}{APIAUTHPATH};
+ my $apiauthmaxver = $hash->{HELPER}{APIAUTHMAXVER};
+ my $sid = $hash->{HELPER}{SID};
+ my $proto = $hash->{PROTOCOL};
+ my $url;
+ my $param;
+ my $httptimeout;
+
+ Log3($name, 4, "$name - ####################################################");
+ Log3($name, 4, "$name - ### start cam operation $hash->{OPMODE} ");
+ Log3($name, 4, "$name - ####################################################");
+ Log3($name, 4, "$name - --- Begin Function SSCam_logout nonblocking ---");
+
+ $httptimeout = AttrVal($name,"httptimeout",4);
+ Log3($name, 5, "$name - HTTP-Call will be done with httptimeout-Value: $httptimeout s");
+
+ if (AttrVal($name,"session","DSM") eq "SurveillanceStation") {
+ $url = "$proto://$serveraddr:$serverport/webapi/$apiauthpath?api=$apiauth&version=$apiauthmaxver&method=Logout&session=SurveillanceStation&_sid=$sid";
+ } else {
+ $url = "$proto://$serveraddr:$serverport/webapi/$apiauthpath?api=$apiauth&version=$apiauthmaxver&method=Logout&_sid=$sid";
+ }
+
+ $param = {
+ url => $url,
+ timeout => $httptimeout,
+ hash => $hash,
+ method => "GET",
+ header => "Accept: application/json",
+ callback => \&SSCam_logout_return
+ };
+
+ HttpUtils_NonblockingGet ($param);
+}
+
+sub SSCam_logout_return ($) {
+ my ($param, $err, $myjson) = @_;
+ my $hash = $param->{hash};
+ my $name = $hash->{NAME};
+ my $sid = $hash->{HELPER}{SID};
+ my ($success, $username) = SSCam_getcredentials($hash,0);
+ my $OpMode = $hash->{OPMODE};
+ my $data;
+ my $error;
+ my $errorcode;
+
+ if($err ne "") {
+ # wenn ein Fehler bei der HTTP Abfrage aufgetreten ist
+ Log3($name, 2, "$name - error while requesting ".$param->{url}." - $err");
+
+ readingsSingleUpdate($hash, "Error", $err, 1);
+ } elsif($myjson ne "") {
+ # wenn die Abfrage erfolgreich war ($data enthält die Ergebnisdaten des HTTP Aufrufes)
+ Log3($name, 4, "$name - URL-Call: ".$param->{url});
+
+ # Evaluiere ob Daten im JSON-Format empfangen wurden
+ ($hash, $success) = SSCam_evaljson($hash,$myjson);
+
+ unless ($success) {
+ Log3($name, 4, "$name - Data returned: ".$myjson);
+
+ $hash->{HELPER}{ACTIVE} = "off";
+
+ if (AttrVal($name,"debugactivetoken",0)) {
+ Log3($name, 3, "$name - Active-Token deleted by OPMODE: $hash->{OPMODE}");
+ }
+ return;
+ }
+
+ $data = decode_json($myjson);
+
+ # Logausgabe decodierte JSON Daten
+ Log3($name, 4, "$name - JSON returned: ". Dumper $data);
+
+ $success = $data->{'success'};
+
+ if ($success) {
+ # die Logout-URL konnte erfolgreich aufgerufen werden
+ Log3($name, 4, "$name - Session of User $username has ended - SID: \"$sid\" has been deleted");
+
+ } else {
+ # Errorcode aus JSON ermitteln
+ $errorcode = $data->{'error'}->{'code'};
+
+ # Fehlertext zum Errorcode ermitteln
+ $error = &SSCam_experrorauth($hash,$errorcode);
+
+ Log3($name, 2, "$name - ERROR - Logout of User $username was not successful, however SID: \"$sid\" has been deleted. Errorcode: $errorcode - $error");
+ }
+ }
+ # Session-ID aus Helper-hash löschen
+ delete $hash->{HELPER}{SID};
+
+ # ausgeführte Funktion ist erledigt (auch wenn logout nicht erfolgreich), Freigabe Funktionstoken
+ $hash->{HELPER}{ACTIVE} = "off";
+
+ if (AttrVal($name,"debugactivetoken",0)) {
+ Log3($name, 3, "$name - Active-Token deleted by OPMODE: $hash->{OPMODE}");
+ }
+return;
+}
+
+###############################################################################
+# Test ob JSON-String empfangen wurde
+###############################################################################
+sub SSCam_evaljson($$) {
+ my ($hash,$myjson) = @_;
+ my $OpMode = $hash->{OPMODE};
+ my $name = $hash->{NAME};
+ my $success = 1;
+
+ eval {decode_json($myjson)} or do
+ {
+ if($hash->{HELPER}{RUNVIEW} =~ m/^live_.*hls$/ || $OpMode =~ m/^.*_hls$/) {
+ # HLS aktivate/deaktivate bringt kein JSON wenn bereits aktiviert/deaktiviert
+ Log3($name, 5, "$name - HLS-activation data return: $myjson");
+ if ($myjson =~ m/{"success":true}/) {
+ $success = 1;
+ $myjson = '{"success":true}';
+ }
+ } else {
+ $success = 0;
+ # Setreading
+ readingsBeginUpdate($hash);
+ readingsBulkUpdate($hash,"Errorcode","none");
+ readingsBulkUpdate($hash,"Error","malformed JSON string received");
+ readingsEndUpdate($hash, 1);
+ }
+ };
+
+return($hash,$success,$myjson);
+}
+
+######################################################################################################
+# Refresh eines Raumes aus $hash->{HELPER}{STRMROOM}
+# bzw. Longpoll von SSCam bzw. eines SSCamSTRM Devices wenn
+# $hash->{HELPER}{STRMDEV} gefüllt
+# $hash, $pload (1=Page reload), SSCam-state-Event(1=Event), SSCamSTRM-Event (1=Event)
+######################################################################################################
+sub SSCam_refresh($$$$) {
+ my ($hash,$pload,$lpoll_scm,$lpoll_strm) = @_;
+ my $name;
+ if (ref $hash ne "HASH")
+ {
+ ($name,$pload,$lpoll_scm,$lpoll_strm) = split ",",$hash;
+ $hash = $defs{$name};
+ } else {
+ $name = $hash->{NAME};
+ }
+ my $fpr = 0;
+
+ # Kontext des SSCamSTRM-Devices speichern für Refresh
+ my $sd = $hash->{HELPER}{STRMDEV}?$hash->{HELPER}{STRMDEV}:"\"n.a.\""; # Name des aufrufenden SSCamSTRM-Devices
+ my $sr = $hash->{HELPER}{STRMROOM}?$hash->{HELPER}{STRMROOM}:"\"n.a.\""; # Raum aus dem das SSCamSTRM-Device die Funktion aufrief
+ my $sl = $hash->{HELPER}{STRMDETAIL}?$hash->{HELPER}{STRMDETAIL}:"\"n.a.\""; # Name des SSCamSTRM-Devices (wenn Detailansicht)
+ $fpr = AttrVal($hash->{HELPER}{STRMDEV},"forcePageRefresh",0) if($hash->{HELPER}{STRMDEV});
+ Log3($name, 4, "$name - SSCam_refresh - caller: $sd, callerroom: $sr, detail: $sl, pload: $pload, forcePageRefresh: $fpr");
+
+ # Page-Reload
+ if($pload && $hash->{HELPER}{STRMROOM} && $hash->{HELPER}{STRMDETAIL}) {
+ if($hash->{HELPER}{STRMROOM} && !$hash->{HELPER}{STRMDETAIL} && !$fpr) {
+ Log3($name, 4, "$name - SSCam_refresh jetzt");
+ # trifft zu wenn in einer Raumansicht
+ my @rooms = split(",",$hash->{HELPER}{STRMROOM});
+ foreach (@rooms) {
+ my $room = $_;
+ { map { FW_directNotify("FILTER=room=$room", "#FHEMWEB:$_", "location.reload('true')", "") } devspec2array("TYPE=FHEMWEB") }
+ }
+ } elsif ( !$hash->{HELPER}{STRMROOM} || $hash->{HELPER}{STRMDETAIL} || $fpr ) {
+ # trifft zu bei Detailansicht oder im FLOORPLAN bzw. Dashboard oder wenn Seitenrefresh mit dem
+ # SSCamSTRM-Attribut "forcePageRefresh" erzwungen wird
+ { map { FW_directNotify("#FHEMWEB:$_", "location.reload('true')", "") } devspec2array("TYPE=FHEMWEB") }
+ }
+ } elsif ($fpr) {
+ # Seitenrefresh durch SSCamSTRM-Attribut "forcePageRefresh" erzwungen
+ { map { FW_directNotify("#FHEMWEB:$_", "location.reload('true')", "") } devspec2array("TYPE=FHEMWEB") }
+ }
+
+ # Aufnahmestatus/Disabledstatus in state abbilden & SSCam-Device state setzen (mit/ohne Event)
+ my $st = (ReadingsVal($name, "Availability", "enabled") eq "disabled")?"disabled":(ReadingsVal($name, "Record", "") eq "Start")?"on":"off";
+ if($lpoll_scm) {
+ readingsSingleUpdate($hash,"state", $st, 1);
+ } else {
+ readingsSingleUpdate($hash,"state", $st, 0);
+ }
+
+ # parentState des SSCamSTRM-Device mit Opmode updaten (mit/ohne Event)
+ my @strmdvs = devspec2array("TYPE=SSCamSTRM:FILTER=PARENT=".$name);
+ if(@strmdvs) {
+ foreach (@strmdvs) {
+ my $strmhash = $defs{$_};
+ if($lpoll_strm) {
+ readingsSingleUpdate($strmhash,"parentState", $hash->{OPMODE}, 1);
+ } else {
+ readingsSingleUpdate($strmhash,"parentState", $hash->{OPMODE}, 0);
+ }
+ }
+ }
+
+return;
+}
+
+###############################################################################
+# Test ob MODEL=SVS (sonst ist es eine Cam)
+###############################################################################
+sub SSCam_IsModelCam($){
+ my ($hash)= @_;
+ my $m = ($hash->{MODEL} ne "SVS")?1:0;
+return($m);
+}
+
+###############################################################################
+# JSON Boolean Test und Mapping
+###############################################################################
+sub SSCam_jboolmap($){
+ my ($bool)= @_;
+
+ if(JSON::is_bool($bool)) {
+ $bool = $bool?"true":"false";
+ }
+
+return $bool;
+}
+
+###############################################################################
+# Schnappschußgalerie abrufen (snapGalleryBoost) o. nur Info des letzten Snaps
+###############################################################################
+sub SSCam_snaplimsize ($) {
+ my ($hash)= @_;
+ my $name = $hash->{NAME};
+ my ($slim,$ssize);
+
+ if(!AttrVal($name,"snapGalleryBoost",0)) {
+ $slim = 1;
+ $ssize = 0;
+ } else {
+ $hash->{HELPER}{GETSNAPGALLERY} = 1;
+ $slim = AttrVal($name,"snapGalleryNumber",$SSCam_slim); # Anzahl der abzurufenden Snaps
+ my $sg = AttrVal($name,"snapGallerySize","Icon"); # Auflösung Image
+ $ssize = ($sg eq "Icon")?1:2;
+ }
+return ($slim,$ssize);
+}
+
+###############################################################################
+# Helper für listLog-Argumente extrahieren
+###############################################################################
+sub SSCam_extlogargs ($$) {
+ my ($hash,$a) = @_;
+
+ $hash->{HELPER}{LISTLOGSEVERITY} = (split("severity:",$a))[1] if(lc($a) =~ m/^severity:.*/);
+ $hash->{HELPER}{LISTLOGLIMIT} = (split("limit:",$a))[1] if(lc($a) =~ m/^limit:.*/);
+ $hash->{HELPER}{LISTLOGMATCH} = (split("match:",$a))[1] if(lc($a) =~ m/^match:.*/);
+
+return;
+}
+
+###############################################################################
+# Helper für optimizeParams-Argumente extrahieren
+###############################################################################
+sub SSCam_extoptpar($$$) {
+ my ($hash,$a,$cpcl) = @_;
+
+ $hash->{HELPER}{MIRROR} = (split("mirror:",$a))[1] if(lc($a) =~ m/^mirror:.*/);
+ $hash->{HELPER}{FLIP} = (split("flip:",$a))[1] if(lc($a) =~ m/^flip:.*/);
+ $hash->{HELPER}{ROTATE} = (split("rotate:",$a))[1] if(lc($a) =~ m/^rotate:.*/);
+ $hash->{HELPER}{NTPSERV} = (split("ntp:",$a))[1] if(lc($a) =~ m/^ntp:.*/);
+
+ $hash->{HELPER}{CHKLIST} = ($hash->{HELPER}{NTPSERV}?$cpcl->{ntp}:0)+
+ ($hash->{HELPER}{MIRROR}?$cpcl->{mirror}:0)+
+ ($hash->{HELPER}{FLIP}?$cpcl->{flip}:0)+
+ ($hash->{HELPER}{ROTATE}?$cpcl->{rotate}:0);
+
+return;
+}
+
+###############################################################################
+# Helper für HLS Lieferfähigkeit
+# HLS kann geliefert werden wenn "SYNO.SurveillanceStation.VideoStream"
+# existiert und Reading CamStreamFormat "HLS" ist
+###############################################################################
+sub SSCam_IsHLSCap($) {
+ my ($hash) = @_;
+ my $name = $hash->{NAME};
+ my $ret = 0;
+ my $api = $hash->{HELPER}{APIVIDEOSTMSMAXVER};
+ my $csf = (ReadingsVal($name,"CamStreamFormat","MJPEG") eq "HLS")?1:0;
+
+ $ret = 1 if($api && $csf);
+
+return $ret;
+}
+
+###############################################################################
+# Clienthash übernehmen oder zusammenstellen
+# Identifikation ob über FHEMWEB ausgelöst oder nicht -> erstellen $hash->CL
+sub SSCam_getclhash($;$$) {
+ my ($hash,$nobgd)= @_;
+ my $name = $hash->{NAME};
+ my $ret;
+
+ if($nobgd) {
+ # nur übergebenen CL-Hash speichern,
+ # keine Hintergrundverarbeitung bzw. synthetische Erstellung CL-Hash
+ $hash->{HELPER}{CL}{1} = $hash->{CL};
+ return undef;
+ }
+
+ if (!defined($hash->{CL})) {
+ # Clienthash wurde nicht übergeben und wird erstellt (FHEMWEB Instanzen mit canAsyncOutput=1 analysiert)
+ my $outdev;
+ my @webdvs = devspec2array("TYPE=FHEMWEB:FILTER=canAsyncOutput=1:FILTER=STATE=Connected");
+ my $i = 1;
+ foreach (@webdvs) {
+ $outdev = $_;
+ next if(!$defs{$outdev});
+ $hash->{HELPER}{CL}{$i}->{NAME} = $defs{$outdev}{NAME};
+ $hash->{HELPER}{CL}{$i}->{NR} = $defs{$outdev}{NR};
+ $hash->{HELPER}{CL}{$i}->{COMP} = 1;
+ $i++;
+ }
+ } else {
+ # übergebenen CL-Hash in Helper eintragen
+ $hash->{HELPER}{CL}{1} = $hash->{CL};
+ }
+
+ # Clienthash auflösen zur Fehlersuche (aufrufende FHEMWEB Instanz
+ if (defined($hash->{HELPER}{CL}{1})) {
+ for (my $k=1; (defined($hash->{HELPER}{CL}{$k})); $k++ ) {
+ Log3($name, 4, "$name - Clienthash number: $k");
+ while (my ($key,$val) = each(%{$hash->{HELPER}{CL}{$k}})) {
+ $val = $val?$val:" ";
+ Log3($name, 4, "$name - Clienthash: $key -> $val");
+ }
+ }
+ } else {
+ Log3($name, 2, "$name - Clienthash was neither delivered nor created !");
+ $ret = "Clienthash was neither delivered nor created. Can't use asynchronous output for function.";
+ }
+
+return ($ret);
+}
+
+###############################################################################
+# konvertiere alle ptzPanel_rowXX-attribute zu html-Code für
+# das generierte Widget und das weblink-Device ptzpanel_$name
+###############################################################################
+sub SSCam_ptzpanel($;$$) {
+ my ($name,$ptzcdev,$ptzcontrol) = @_;
+ my $hash = $defs{$name};
+ my $iconpath = AttrVal("$name","ptzPanel_iconPath","www/images/sscam");
+ my $iconprefix = AttrVal("$name","ptzPanel_iconPrefix","black_btn_");
+ my $rowisset = 0;
+ my $ptz_ret;
+ my $row;
+
+ my @vl = split (/\.|-/,ReadingsVal($name, "SVSversion", ""));
+ if(@vl) {
+ my $actvs = $vl[0];
+ $actvs .= $vl[1];
+ return "" if($actvs <= 71);
+ }
+
+ $ptz_ret = "";
+ $ptz_ret.= '
';
+
+ foreach my $rownr (0..9) {
+ $rownr = sprintf("%2.2d",$rownr);
+ $row = AttrVal("$name","ptzPanel_row$rownr",undef);
+ next if (!$row);
+ $rowisset = 1;
+ $ptz_ret .= "";
+ my @btn = split (",",$row); # die Anzahl Buttons in einer Reihe
+
+ foreach my $btnnr (0..$#btn) {
+ $ptz_ret .= '';
+ if ($btn[$btnnr] ne "") {
+ my $cmd;
+ my $img;
+ if ($btn[$btnnr] =~ /(.*?):(.*)/) { # enthält Komando -> :
+ $cmd = $1;
+ $img = $2;
+ } else { # button has format or is empty
+ $cmd = $btn[$btnnr];
+ $img = $btn[$btnnr];
+ }
+ if ($img =~ m/\.svg/) { # Verwendung für SVG's
+ $img = FW_makeImage($img, $cmd, "rc-button");
+ } else {
+ $img = "$img "; # $FW_subdir = Sub-path in URL, used by FLOORPLAN/weblink
+ } else {
+ $ptz_ret .= $img;
+ }
+ }
+ $ptz_ret .= " ";
+ $ptz_ret .= "\n";
+ }
+ $ptz_ret .= " \n";
+ }
+
+ $ptz_ret .= "
";
+ $ptz_ret .= "
';
+ $ret .= '';
+ $ret .= '';
+
+ if(!$StmKey || ReadingsVal($camname, "Availability", "") ne "enabled" || IsDisabled($camname)) {
+ # Ausgabe bei Fehler
+ my $cam = AttrVal($camname, "alias", $camname);
+ $cause = !$StmKey?"Cam $cam has no Reading \"StmKey\" set !":"Cam \"$cam\" is disabled";
+ $cause = "Cam \"$cam\" is disabled" if(IsDisabled($camname));
+ $ret .= " $cause ";
+ $ret .= ' ';
+ $ret .= ' ';
+ $ret .= '
';
+ $ret .= '';
+ return $ret;
+ }
+
+ if($fmt =~ /mjpeg/) {
+ if($apivideostmsmaxver) { # keine API "SYNO.SurveillanceStation.VideoStream" mehr ab API v2.8
+ $link = "$proto://$serveraddr:$serverport/webapi/$apivideostmspath?api=$apivideostms&version=$apivideostmsmaxver&method=Stream&cameraId=$camid&format=mjpeg&_sid=$sid";
+ } elsif ($hash->{HELPER}{STMKEYMJPEGHTTP}) {
+ $link = $hash->{HELPER}{STMKEYMJPEGHTTP};
+ }
+ if($apiaudiostmmaxver) { # keine API "SYNO.SurveillanceStation.AudioStream" mehr ab API v2.8
+ $audiolink = "$proto://$serveraddr:$serverport/webapi/$apiaudiostmpath?api=$apiaudiostm&version=$apiaudiostmmaxver&method=Stream&cameraId=$camid&_sid=$sid";
+ }
+ $ret .= "$imgrecendless ";
+ } else {
+ # Aufnahmebutton Stop
+ $ret .= "$imgrecstop ";
+ }
+ $ret .= "$imgdosnap ";
+ $ret .= "$ptz_ret ";
+ }
+ }
+ if($audiolink && ReadingsVal($camname, "CamAudioType", "Unknown") !~ /Unknown/) {
+ $ret .= '';
+ $ret .= '';
+ $ret .= "
+ Your browser does not support the audio element.
+ ";
+ $ret .= " Set attribute \"genericStrmHtmlTag\" in device $camname ";
+ $ret .= ' ';
+ $ret .= '';
+ $ret .= '';
+ $ret .= '';
+ return $ret;
+ }
+
+ $ret .= "";
+ $ret .= "$htag";
+ $ret .= "$imgrefresh ";
+ $ret .= $imgblank;
+ if(ReadingsVal($camname, "Record", "Stop") eq "Stop") {
+ # Aufnahmebutton endlos Start
+ $ret .= "$imgrecendless ";
+ } else {
+ # Aufnahmebutton Stop
+ $ret .= "$imgrecstop ";
+ }
+ $ret .= "$imgdosnap ";
+ $ret .= " ";
+ if(AttrVal($camname,"ptzPanel_use",1)) {
+ my $ptz_ret = SSCam_ptzpanel($camname);
+ if($ptz_ret) {
+ $ret .= "$ptz_ret ";
+ }
+ }
+
+ } elsif($fmt =~ /switched/) {
+ my $wltype = $hash->{HELPER}{WLTYPE};
+ $link = $hash->{HELPER}{LINK};
+
+ if($link && $wltype =~ /image|iframe|video|base64img|embed|hls/) {
+ if($wltype =~ /image/) {
+ $ret .= "$imgstop ";
+ $ret .= $imgblank;
+ if($hash->{HELPER}{RUNVIEW} =~ /live_fw/) {
+ if(ReadingsVal($camname, "Record", "Stop") eq "Stop") {
+ # Aufnahmebutton endlos Start
+ $ret .= "$imgrecendless ";
+ } else {
+ # Aufnahmebutton Stop
+ $ret .= "$imgrecstop ";
+ }
+ $ret .= "$imgdosnap ";
+ }
+ $ret .= "$ptz_ret ";
+ }
+ }
+ if($hash->{HELPER}{AUDIOLINK} && ReadingsVal($camname, "CamAudioType", "Unknown") !~ /Unknown/) {
+ $ret .= "";
+ $ret .= '';
+ $ret .= "{HELPER}{AUDIOLINK} preload='none' volume='0.5' controls>
+ Your browser does not support the audio element.
+ ";
+ }
+
+ } elsif ($wltype =~ /iframe/) {
+ $ret .= "$imgstop ";
+ $ret .= "$imgrefresh ";
+ $ret .= " ';
+ $ret .= '';
+ $ret .= "{HELPER}{AUDIOLINK} preload='none' volume='0.5' controls>
+ Your browser does not support the audio element.
+ ";
+ $ret .= "
+
+
+
+ Your browser does not support the video tag
+ $imgstop ";
+ $ret .= " ';
+ $ret .= '';
+ $ret .= "{HELPER}{AUDIOLINK} preload='none' volume='0.5' controls>
+ Your browser does not support the audio element.
+ ";
+ $ret .= "$imgstop ";
+ $ret .= "
+
+
+ Your browser does not support the video tag
+ $imgstop ";
+ $ret .= "$imgrefresh ";
+ $ret .= "$imghlsreact ";
+ $ret .= $imgblank;
+ if(ReadingsVal($camname, "Record", "Stop") eq "Stop") {
+ # Aufnahmebutton endlos Start
+ $ret .= "$imgrecendless ";
+ } else {
+ # Aufnahmebutton Stop
+ $ret .= "$imgrecstop ";
+ }
+ $ret .= "$imgdosnap ";
+ $ret .= "$ptz_ret ";
+ }
+ }
+ }
+ } else {
+ my $cam = AttrVal($camname, "alias", $camname);
+ $cause = "Playback cam \"$cam\" switched off";
+ $ret .= " $cause $imgmjpegrun ";
+ $ret .= "$imghlsrun " if(SSCam_IsHLSCap($hash));
+ $ret .= "$imglrirun ";
+ $ret .= "$imglh264run ";
+ $ret .= "$imglmjpegrun ";
+ $ret .= "$imglsnaprun ";
+ $ret .= " ";
+ }
+ } else {
+ $cause = "Videoformat not supported";
+ $ret .= " $cause ";
+ }
+
+ $ret .= ' ';
+ $ret .= '';
+ $ret .= '';
+ Log3($strmdev, 4, "$strmdev - Link called: $link") if($link);
+
+return $ret;
+}
+
+###############################################################################
+# Schnappschußgalerie zusammenstellen
+###############################################################################
+sub composegallery ($;$$) {
+ my ($name,$strmdev,$model) = @_;
+
+ Log3($name, 1, "$name - SSCam will change the internal Code soon. Please delete your old Snapgallery-Device and create a new one by \"set $name createSnapGallery\" ");
+ my $htmlCode = SSCam_composegallery($name,$strmdev,$model);
+
+return $htmlCode;
+}
+
+###############################################################################
+# Schnappschußgalerie zusammenstellen
+###############################################################################
+sub SSCam_composegallery ($;$$) {
+ my ($name,$strmdev,$model) = @_;
+ my $hash = $defs{$name};
+ my $camname = $hash->{CAMNAME};
+ my $allsnaps = $hash->{HELPER}{".SNAPHASH"}; # = \%allsnaps
+ my $sgc = AttrVal($name,"snapGalleryColumns",3); # Anzahl der Images in einer Tabellenzeile
+ my $lss = ReadingsVal($name, "LastSnapTime", " "); # Zeitpunkt neueste Aufnahme
+ my $lang = AttrVal("global","language","EN"); # Systemsprache
+ my $limit = $hash->{HELPER}{SNAPLIMIT}; # abgerufene Anzahl Snaps
+ my $totalcnt = $hash->{HELPER}{TOTALCNT}; # totale Anzahl Snaps
+ $limit = $totalcnt if ($limit > $totalcnt); # wenn weniger Snaps vorhanden sind als $limit -> Text in Anzeige korrigieren
+ my $lupt = ((ReadingsTimestamp($name,"LastSnapTime"," ") gt ReadingsTimestamp($name,"LastUpdateTime"," "))
+ ? ReadingsTimestamp($name,"LastSnapTime"," ")
+ : ReadingsTimestamp($name,"LastUpdateTime"," ")); # letzte Aktualisierung
+ $lupt =~ s/ / \/ /;
+
+ my $cmddosnap = "cmd=set $name snap STRM"; # Snapshot auslösen mit Kennzeichnung "by STRM-Device"
+ my $imgdosnap = "CAUTION - No snapshots can be retrieved. Please set the attribute \"snapGalleryBoost=1\" in device $name " if ($lang eq "EN");
+ $sgbnote = "ACHTUNG - Es können keine Schnappschüsse abgerufen werden. Bitte setzen sie das Attribut \"snapGalleryBoost=1\" im Device $name " if ($lang eq "DE");
+ }
+
+ my $header;
+ if ($lang eq "EN") {
+ $header = "Snapshots ($limit/$totalcnt) of camera $camname - newest Snapshot: $lss$camname - neueste Aufnahme: $lss $header
");
+ $htmlCode .= "
";
+ $htmlCode .= "";
+ $htmlCode .= "";
+ my $cell = 1;
+
+ foreach my $key (@as) {
+ $ct = $allsnaps->{$key}{createdTm};
+ my $html = sprintf("$ct " );
+
+ $cell++;
+
+ if ( $cell == $sgc+1 ) {
+ $htmlCode .= $html;
+ $htmlCode .= " ";
+ $htmlCode .= "";
+ $cell = 1;
+ } else {
+ $htmlCode .= $html;
+ }
+ }
+
+ if ( $cell == 2 ) {
+ $htmlCode .= " ";
+ }
+
+ $htmlCode .= " ";
+ $htmlCode .= " ";
+ $htmlCode .= "
";
+ $htmlCode .= "
$imgdosnap " if($strmdev);
+ $htmlCode .= "";
+
+return $htmlCode;
+}
+
+##############################################################################
+# Auflösung Errorcodes bei Login / Logout
+##############################################################################
+sub SSCam_experrorauth {
+ # Übernahmewerte sind $hash, $errorcode
+ my ($hash,@errorcode) = @_;
+ my $device = $hash->{NAME};
+ my $errorcode = shift @errorcode;
+ my $error;
+
+ unless (exists($SSCam_errauthlist{"$errorcode"})) {$error = "Message of errorcode \"$errorcode\" not found. Please turn to Synology Web API-Guide."; return ($error);}
+
+ # Fehlertext aus Hash-Tabelle %errorauthlist ermitteln
+ $error = $SSCam_errauthlist{"$errorcode"};
+return ($error);
+}
+
+##############################################################################
+# Auflösung Errorcodes SVS API
+
+sub SSCam_experror {
+ # Übernahmewerte sind $hash, $errorcode
+ my ($hash,@errorcode) = @_;
+ my $device = $hash->{NAME};
+ my $errorcode = shift @errorcode;
+ my $error;
+
+ unless (exists($SSCam_errlist{"$errorcode"})) {$error = "Message of errorcode $errorcode not found. Please turn to Synology Web API-Guide."; return ($error);}
+
+ # Fehlertext aus Hash-Tabelle %errorlist ermitteln
+ $error = $SSCam_errlist{"$errorcode"};
+ return ($error);
+}
+
+
+1;
+
+=pod
+=item summary Camera module to control the Synology Surveillance Station
+=item summary_DE Kamera-Modul für die Steuerung der Synology Surveillance Station
+=begin html
+
+SSCam
+
+ Using this Module you are able to operate cameras which are defined in Synology Surveillance Station (SVS) and execute
+ functions of the SVS. It is based on the SVS API and supports the SVS version 7 and above.
+
+ Start a Recording
+ Stop a Recording (using command or automatically after the <RecordTime> period
+ Trigger a Snapshot
+ Deaktivate a Camera in Synology Surveillance Station
+ Activate a Camera in Synology Surveillance Station
+ Control of the exposure modes day, night and automatic
+ switchover the motion detection by camera, by SVS or deactivate it
+ control of motion detection parameters sensitivity, threshold, object size and percentage for release
+ Retrieval of Camera Properties (also by Polling) as well as informations about the installed SVS-package
+ Move to a predefined Preset-position (at PTZ-cameras)
+ Start a predefined Patrol (at PTZ-cameras)
+ Positioning of PTZ-cameras to absolute X/Y-coordinates
+ continuous moving of PTZ-camera lense
+ trigger of external events 1-10 (action rules in SVS)
+ start and stop of camera livestreams incl. audio replay, show the last recording and snapshot
+ fetch of livestream-Url's with key (login not needed in that case)
+ playback of last recording and playback the last snapshot
+ switch the Surveillance Station HomeMode on/off and retrieve the HomeModeState
+ show the stored credentials of a device
+ fetch the Surveillance Station Logs, exploit the newest entry as reading
+ create a gallery of the last 1-10 snapshots (as Popup or in a discrete device)
+ Start/Stop Object Tracking (only supported PTZ-Cams with this capability)
+ set/delete a Preset (at PTZ-cameras)
+ set a Preset or current position as Home Preset (at PTZ-cameras)
+ provides a panel for camera control (at PTZ-cameras)
+ create different types of discrete Streaming-Devices (createStreamDev)
+ Activation / Deactivation of a camera integrated PIR sensor
+
+
+ 49_SSCam: Fragen, Hinweise, Neuigkeiten und mehr rund um dieses Modul . Prerequisites sudo apt-get install libjson-perl Credentials . Define
+
+ camera is defined by:
+ define <Name> SSCAM <camera name in SVS> <ServerAddr> [Port] [Protocol]
+
+ At first the devices have to be set up and has to be operable in Synology Surveillance Station 7.0 and above. SVS-device to control functions of the Surveillance Station (SVS) is defined by:
+ define <Name> SSCAM SVS <ServerAddr> [Port] [Protocol]
+
+ In that case the term <camera name in SVS> become replaced by SVS only.
+
+ Name the name of the new device to use in FHEM Cameraname camera name as defined in Synology Surveillance Station if camera-device, "SVS" if SVS-Device. Spaces are not allowed in camera name. ServerAddr IP-address of Synology Surveillance Station Host. Note: avoid using hostnames because of DNS-Calls are not unblocking in FHEM Port optional - the port of synology disc station. If not set, the default "5000" is used Protocol optional - the protocol (http or https) to access the synology disc station. If not set, the default "http" is used
+
+ Examples:
+
+ define CamCP SSCAM Carport 192.168.2.20 [5000] [http]
+ define CamCP SSCAM Carport 192.168.2.20 [5001] [https]
+ # creates a new camera device CamCP
+
+ define DS1 SSCAM SVS 192.168.2.20 [5000] [http]
+ define DS1 SSCAM SVS 192.168.2.20 [5001] [https]
+ # creares a new SVS device DS1
+
+
+ When a new Camera is defined, as a start the recordingtime of 15 seconds will be assigned to the device.attribute "rectime" you can adapt the recordingtime for every camera individually.attribute "rectime" would be deleted again, the default-value for recording-time (15s) become active.command "set <name> on [rectime]" a temporary recordingtime is determinded which would overwrite the dafault-value of recordingtime "set <name> on 0" leads also to an endless recording as well.attributes "ptzPanel_.*". command "set <name> createPTZcontrol" in this context.
+ Credentials
+ After a camera-device is defined, firstly it is needed to save the credentials. This will be done with command:
+
+
+ set <name> credentials <username> <password>
+
+
+ The password length has a maximum of 20 characters.
+ DSM-User as member of admin group: unrestricted test of all module functions -> session: DSM
+ SVS-User as Manager or observer: adjusted privilege profile -> session: SurveillanceStation
+
+ Attribute "session" can be selected, if the session should be established to DSM or the
+ SVS instead. Further informations about user management in SVS are available by execute
+ "get <name> versionNotes 5".minimum rights that the particular module function needs.
+
+
+ set ... on session: ServeillanceStation - observer with enhanced privilege "manual recording" set ... off session: ServeillanceStation - observer with enhanced privilege "manual recording" set ... snap session: ServeillanceStation - observer set ... delPreset session: ServeillanceStation - observer set ... disable session: ServeillanceStation - manager set ... enable session: ServeillanceStation - manager set ... expmode session: ServeillanceStation - manager set ... extevent session: DSM - user as member of admin-group set ... goPreset session: ServeillanceStation - observer with privilege objective control of camera set ... homeMode ssession: ServeillanceStation - observer with privilege Home Mode switch (valid for SVS-device ! ) set ... motdetsc session: ServeillanceStation - manager set ... runPatrol session: ServeillanceStation - observer with privilege objective control of camera set ... goAbsPTZ session: ServeillanceStation - observer with privilege objective control of camera set ... move session: ServeillanceStation - observer with privilege objective control of camera set ... runView session: ServeillanceStation - observer with privilege liveview of camera set ... setHome session: ServeillanceStation - observer set ... setPreset session: ServeillanceStation - observer set ... snap session: ServeillanceStation - observer set ... snapGallery session: ServeillanceStation - observer set ... stopView - set ... credentials - get ... caminfo[all] session: ServeillanceStation - observer get ... eventlist session: ServeillanceStation - observer get ... listLog session: ServeillanceStation - observer get ... listPresets session: ServeillanceStation - observer get ... scanVirgin session: ServeillanceStation - observer get ... svsinfo session: ServeillanceStation - observer get ... snapfileinfo session: ServeillanceStation - observer get ... snapinfo session: ServeillanceStation - observer get ... stmUrlPath session: ServeillanceStation - observer
+
+ HTTP-Timeout Settings
+ All functions of SSCam use HTTP-calls to SVS Web API. attribute "httptimeout" > 0 to adjust the value as needed in your technical environment.
+ Set
+
+
+ set <name> createStreamDev [generic | mjpeg | switched] (valid for CAM)
+
+
+ generic - the streaming device playback a content determined by attribute "genericStrmHtmlTag" mjpeg - the streaming device playback a permanent MJPEG video stream (Streamkey method) switched - playback of different streaming types. Buttons for mode control are provided.
+
+ attribute "htmlattr" of the camera device or by the
+ specific attributes of the SSCamSTRM-device itself.
+attr <name> genericStrmHtmlTag <video $HTMLATTR controls autoplay>
+ <source src='http://192.168.2.10:32000/$NAME.m3u8' type='application/x-mpegURL'>
+ </video>
+
+ The variables $HTMLATTR, $NAME are placeholder and absorb the attribute "htmlattr" (if set) respectively the SSCam-Devicename.
+
+
+
+ set <name> createPTZcontrol (valid for PTZ-CAM)attributes or respectively the specific attributes of the SSCamSTRM-device
+ the properties of the control panel can be affected.
+
+
+ set <name> createSnapGallery (valid for CAM)attributes respectively the specific attributes of the SSCamSTRM-device
+ you are able to manipulate the properties of the new snapshot gallery device.
+
+
+ set <name> credentials <username> <password> (valid for CAM/SVS)Credentials
+
+
+ set <name> delPreset <PresetName> (valid for PTZ-CAM)
+
+ set <name> [enable|disable] (valid for CAM)deactivating / activating a list of cameras or all cameras by Regex-expression, subsequent two
+ examples using "at":
+
+ define a13 at 21:46 set CamCP1,CamFL,CamHE1,CamTER disable (enable)
+ define a14 at 21:46 set Cam.* disable (enable)
+
+
+ A bit more convenient is it to use a dummy-device for enable/disable all available cameras in Surveillance Station.
+ define allcams dummy
+ attr allcams eventMap on:enable off:disable
+ attr allcams room Cams
+ attr allcams webCmd enable:disable
+
+
+ With combination of two created notifies, respectively one for "enable" and one for "diasble", you are able to switch all cameras into "enable" or "disable" state at the same time if you set the dummy to "enable" or "disable".
+
+ define all_cams_disable notify allcams:.*off set CamCP1,CamFL,CamHE1,CamTER disable
+ attr all_cams_disable room Cams
+
+ define all_cams_enable notify allcams:on set CamCP1,CamFL,CamHE1,CamTER enable
+ attr all_cams_enable room Cams
+
+
+
+ set <name> expmode [day|night|auto] (valid for CAM) Note:
+
+ set <name> extevent [ 1-10 ] (valid for SVS)
+
+ set <name> goAbsPTZ [ X Y | up | down | left | right ] (valid for CAM)
+ set <name> goAbsPTZ 120 450
+
+
+ In this example the camera lense moves to position X=120 und Y=450.
+ X = 0 - 640 (0 - 319 moves lense left, 321 - 640 moves lense right, 320 don't move lense)
+ Y = 0 - 480 (0 - 239 moves lense down, 241 - 480 moves lense up, 240 don't move lense)
+
+
+ The lense can be moved in smallest steps to very large steps into the desired direction.
+ If necessary the procedure has to be repeated to bring the lense into the desired position.
+ set <name> goAbsPTZ up [down|left|right]
+
+
+ In this case the lense will be moved with largest possible increment into the given absolute position.
+ Also in this case the procedure has to be repeated to bring the lense into the desired position if necessary.
+
+
+ set <name> goPreset <Preset> (valid for CAM)
+ define CamFL.Preset.Wandschrank notify MelderTER:on.* set CamFL goPreset Wandschrank, ;; define CamFL.Preset.record at +00:00:10 set CamFL on 5 ;;;; define s3 at +*{3}00:00:05 set CamFL snap ;; define CamFL.Preset.back at +00:00:30 set CamFL goPreset Home
+
+
+ Operating Mode:
+ 2016.02.04 15:02:14 2: CamFL - Camera Flur_Vorderhaus has moved to position "Wandschrank"
+ 2016.02.04 15:02:24 2: CamFL - Camera Flur_Vorderhaus Recording with Recordtime 5s started
+ 2016.02.04 15:02:29 2: CamFL - Snapshot of Camera Flur_Vorderhaus has been done successfully
+ 2016.02.04 15:02:30 2: CamFL - Camera Flur_Vorderhaus Recording stopped
+ 2016.02.04 15:02:34 2: CamFL - Snapshot of Camera Flur_Vorderhaus has been done successfully
+ 2016.02.04 15:02:39 2: CamFL - Snapshot of Camera Flur_Vorderhaus has been done successfully
+ 2016.02.04 15:02:44 2: CamFL - Camera Flur_Vorderhaus has moved to position "Home"
+
+
+
+ set <name> homeMode [on|off] (valid for SVS)Synology Onlinehelp .
+
+
+
+ set <name> motdetsc [camera|SVS|disable] (valid for CAM)
+
+
+ set <name> motdetsc SVS [sensitivity] [threshold] # command pattern set <name> motdetsc SVS 91 30 # set the sensitivity to 91 and threshold to 30 set <name> motdetsc SVS 0 40 # keep the old value of sensitivity, set threshold to 40 set <name> motdetsc SVS 15 # set the sensitivity to 15, threshold keep unchanged
+
+
+
+
+ set <name> motdetsc camera [sensitivity] [threshold] [percentage] # command pattern set <name> motdetsc camera 89 0 20 # set the sensitivity to 89, percentage to 20 set <name> motdetsc camera 0 40 10 # keep old value for sensitivity, set threshold to 40, percentage to 10 set <name> motdetsc camera 30 # set the sensitivity to 30, other values keep unchanged
+
+ Reading "CamMotDetSc" also will be updated which documents the current setup of motion detection.
+ Only the parameters and parameter values supported by SVS at present will be shown. The camera itself may offer further options to adjust.
+ CamMotDetSc SVS, sensitivity: 76, threshold: 55
+
+
+
+ set <name> move [ right | up | down | left | dir_X ] [Sekunden] (valid for CAM up to SVS version 7.1) set <name> move [ right | upright | up | upleft | left | downleft | down | downright ] [Sekunden] (valid for CAM and SVS Version 7.2 and above)
+ set <name> move up 0.5 : moves PTZ 0,5 Sek. (plus processing time) to the top
+ set <name> move dir_1 1.5 : moves PTZ 1,5 Sek. (plus processing time) to top-right
+ set <name> move dir_20 0.7 : moves PTZ 1,5 Sek. (plus processing time) to left-bottom ("CapPTZDirections = 32)"
+
+
+
+ set <name> [on [<rectime>] | off] (valid for CAM)attribute "rectime" individualy.
+ With the attribute (respectively the default value) provided recording time can be overwritten
+ once by "set <name> on <rectime>".
+ The recording will be stopped after processing time "rectime"automatically.attribute "recextend" furthermore as explained as follows.Attribute "recextend = 0" or not set (default):
+ if, for example, a recording with rectimeme=22 is started, no other startcommand (for a recording) will be accepted until this started recording is finished.
+ A hint will be logged in case of verboselevel = 3.
+
+ Attribute "recextend = 1" is set:
+ a before started recording will be extend by the recording time "rectime" if a new start command is received. That means, the timer for the automatic stop-command will be
+ renewed to "rectime" given bei the command, attribute or default value. This procedure will be repeated every time a new start command for recording is received.
+ Therefore a running recording will be extended until no start command will be get.
+
+ a before started endless-recording will be stopped after recordingtime 2rectime" if a new "set on"-command is received (new set of timer). If it is unwanted make sure you
+ don't set the attribute "recextend" in case of endless-recordings.
+
+ Start/Stop a Recording :
+
+ set <name> on [rectime] starts a recording of camera <name>, stops automatically after [rectime] (default 15s or defined by attribute ) set <name> off stops the recording of camera <name>
+
+
+ set <name> optimizeParams [mirror:<value>] [flip:<value>] [rotate:<value>] [ntp:<value>] (gilt für CAM)
+ mirror, flip, rotate: true | false
+ ntp: the name or the IP-address of time server
+
+ Examples: set <name> optimizeParams mirror:true flip:true ntp:time.windows.com set <name> optimizeParams ntp:Surveillance%20Station set <name> optimizeParams mirror:true flip:false rotate:true
+
+
+ set <name> pirSensor [activate | deactivate] (valid for CAM)
+
+ set <name> runPatrol <Patrolname> (valid for CAM)
+
+ set <name> runView [live_fw | live_link | live_open [<room>] | lastrec_fw | lastrec_fw_MJPEG | lastrec_fw_MPEG4/H.264 | lastrec_open [<room>] | lastsnap_fw] (valid for CAM)
+
+
+ live_fw - MJPEG-Livestream. Audio playback is provided if possible. live_fw_hls - HLS-Livestream (currently only Mac Safari Browser and mobile iOS/Android-Devices) live_link - Link of a MJPEG-Livestream live_open [<room>] - opens MJPEG-Livestream in separate Browser window lastrec_fw - playback last recording as iFrame object lastrec_fw_MJPEG - usable if last recording has format MJPEG lastrec_fw_MPEG4/H.264 - usable if last recording has format MPEG4/H.264 lastrec_open [<room>] - playback last recording in a separate Browser window lastsnap_fw - playback last snapshot
+
+ "live_fw, live_link" a MJPEG-Livestream will be started, either as an embedded image
+ or as a generated link. "live_open" starts a new browser window with a MJPEG-Livestream. If the optional "<room>" is set, the
+ window will only be started if the specified room is currently opened in a FHEMWEB-session. "live_fw_hls" is requested, the camera has to be setup to video format H.264 (not MJPEG) in the
+ Synology Surveillance Station and the SVS-Version has to support the HLS format.
+ Therefore this possibility is only present if the Reading "CamStreamFormat" is set to "HLS".
+ "lastrec_fw.*" respectively "lastrec_open" .
+ By "lastrec_fw" the recording will be opened in an iFrame. There are some control elements provided if available. "lastrec_open" command can be extended optionally by a room. In this case the new window opens only, if the
+ room is the same as a FHEMWEB-session has currently opened. "set <name> runView lastsnap_fw" shows the last snapshot of the camera embedded. attribute "htmlattr".
+ Examples:
+ attr <name> htmlattr width="500" height="375"
+ attr <name> htmlattr width="700",height="525",top="200",left="300"
+
+
+ The command "set <name> runView live_open" starts the stream immediately in a new browser window.
+ A browser window will be initiated to open for every FHEMWEB-session which is active. If you want to change this behavior,
+ you can use command "set <name> runView live_open <room>" . In this case the new window opens only, if the
+ room is the same as a FHEMWEB-session has currently opened. attribute "livestreamprefix" overwrite the data for protocol, servername and
+ port in reading "LiveStreamUrl".
+ By "livestreamprefix" the LivestreamURL (is shown if attribute "showStmInfoFull" is set) can
+ be modified and used for distribution and external access to the Livestream. Example:
+ attr <name> livestreamprefix https://<Servername>:<Port>
+
+
+ The livestream can be stopped again by command "set <name> stopView" .
+ The "runView" function also switches Streaming-Devices of type "switched" into the appropriate mode.
+
+
+ Start Recording - starts an endless recording Stop Recording - stopps the recording Take Snapshot - take a snapshot Switch off - stops a running playback
+
+ Note for HLS (HTTP Live Streaming):
+ set <name> setHome <PresetName> (valid for PTZ-CAM)
+
+ set <name> setPreset <PresetNumber> [<PresetName>] [<Speed>] (valid for PTZ-CAM)
+
+ set <name> snap (valid for CAM)
+ set <name> snap
+
+
+ Subsequent some Examples for taking snapshots :
+ define he1_snap_3 notify CamHE1:Record.*on define h3 at +*{3}00:00:02 set CamHE1 snap
+
+
+ Release of 2 Snapshots of camera "CamHE1" at intervals of 6 seconds after the motion sensor "MelderHE1" has sent an event,
+ define he1_snap_2 notify MelderHE1:on.* define h2 at +*{2}00:00:06 set CamHE1 snap
+
+
+ The ID and the filename of the last snapshot will be displayed as value of variable "LastSnapId" respectively "LastSnapFilename" in the device-Readings.
+ set <name> snapGallery [1-10] (valid for CAM)attribute "snapGalleryBoost=1" no popup will be created. The snapshot gallery will be depicted as
+ an browserpage instead. All further functions and attributes are appropriate the "get <name> snapGallery"
+ command. "get <name> snapGallery" command instead of "set".
+
+
+ set <name> startTracking (valid for CAM with tracking capability)
+
+ set <name> stopTracking (valid for CAM with tracking capability)
+ Get
+
+
+ get <name> caminfoall (valid for CAM/SVS) get <name> caminfo (valid for CAM)
+
+ get <name> eventlist (valid for CAM)Reading "CamEventNum" and "CamLastRecord" will be refreshed which containes the total number
+ of in SVS registered camera events and the path/name of the last recording.
+ This command will be implicit executed when "get <name> caminfoall" is running. attribute "videofolderMap" replaces the content of reading "VideoFolder". You can use it for
+ example if you have mounted the videofolder of SVS under another name or path and want to access by your local pc.
+
+
+ get <name> homeModeState (valid for SVS)
+
+ get <name> listLog [severity:<Loglevel>] [limit:<Number of lines>] [match:<Searchstring>] (valid for SVS)
+ <Loglevel> - Information, Warning or Error. Only datasets having this severity are retrieved (default: all)
+ <Number of lines> - the specified number of lines (newest) of the log are retrieved (default: all)
+ <Searchstring> - only log entries containing the searchstring are retrieved (Note: no Regex possible, the searchstring will be given into the call to SVS)
+
+ Examples
+ get <name> listLog severity:Error limit:5 get <name> listLog severity:Information match:Carport get <name> listLog severity:Warning
+
+
+ If the polling of SVS is activated by setting the attribute "pollcaminfoall", the reading
+ "LastLogEntry" will be created. Synology Online-Help .
+
+
+ get <name> listPresets (valid for PTZ-CAM)
+
+ get <name> scanVirgin (valid for CAM/SVS)
+
+ get <name> snapGallery [1-10] (valid for CAM)attribute "snapGalleryBoost" is set,
+ the last snapshots (default 3) are requested by polling and they will be stored in the FHEM-servers main memory.
+ This method is helpful to speed up the output especially in case of full size images, but it can be possible
+ that NOT the newest snapshots are be shown if they have not be initialized by the SSCAm-module itself. attributes :
+ snapGalleryBoost
+ snapGalleryColumns
+ snapGalleryHtmlAttr
+ snapGalleryNumber
+ snapGallerySize
+
+ Note:
+
+ get <name> snapfileinfo (valid for CAM)"get <name> snap"
+ automatically.
+
+
+ get <name> snapinfo (valid for CAM)
+
+ get <name> stmUrlPath (valid for CAM)attribute "showStmInfoFull" is set, additional stream readings like "StmKeyUnicst", "StmKeymjpegHttp" will be shown and can be used to run the
+ appropriate livestream without session id. Is the attribute "livestreamprefix" (usage: "http(s)://<hostname><port>) used, the servername / port will be replaced if necessary.
+ The strUrlPath function will be included automatically if polling is used.
+
+http(s)://<hostname><port>/webapi/entry.cgi?api=SYNO.SurveillanceStation.VideoStreaming&version=1&method=Stream&format=mjpeg&cameraId=5&StmKey="31fd87279976d89bb98409728cced890"
+
+
+ cameraId (Internal CAMID) and StmKey has to be replaced by valid values. Note:
+ get <name> storedCredentials (valid for CAM/SVS)
+
+ get <name> svsinfo (valid for CAM/SVS)
+
+ get <name> versionNotes [hints | rel | <key>] (valid for CAM/SVS)
+ Polling of Camera/SVS-Properties
+ Retrieval of Camera-Properties can be done automatically if the attribute "pollcaminfoall" will be set to a value > 10.
+ PollState = Active - automatic polling will be executed with interval correspondig value of attribute "pollcaminfoall" PollState = Inactive - automatic polling won't be executed
+ here . Notes: Attribut "httptimeout") is set to 4 seconds, the theoretical processing time couldn't be higher than 80 seconds.
+
+
+
+Internals
+ The meaning of used Internals is depicted in following list:
+ CAMID - the ID of camera defined in SVS, the value will be retrieved automatically on the basis of SVS-cameraname CAMNAME - the name of the camera in SVS COMPATIBILITY - information up to which SVS-version the module version is currently released/tested (see also Reading "compstate") CREDENTIALS - the value is "Set" if Credentials are set NAME - the cameraname in FHEM MODEL - distinction between camera device (CAM) and Surveillance Station device (SVS) OPMODE - the last executed operation of the module SERVERADDR - IP-Address of SVS Host SERVERPORT - SVS-Port
+
+
+Attributes
+
+
+ httptimeout htmlattr
+ Example:
+ livestreamprefix loginRetries noQuotesForSID pollcaminfoall pollnologging ptzPanel_Home ptzPanel_iconPath ptzPanel_iconPrefix ptzPanel_row[00-09] <command>:<icon>,<command>:<icon>,... Note:
+ Example:
+ ptzPanel_use rectime recextend session simu_SVSversion snapGalleryBoost snapGalleryColumns snapGalleryHtmlAttr
+ Example:
+ snapGalleryNumber snapGallerySize showStmInfoFull showPassInLog videofolderMap verbose
+ Different Verbose-Level are supported.
+
+ 0 - Start/Stop-Event will be logged 1 - Error messages will be logged 2 - messages according to important events were logged 3 - sended commands will be logged 4 - sended and received informations will be logged 5 - all outputs will be logged for error-analyses. Caution: a lot of data could be written into logfile !
+
+ readingFnAttributes
+
+ Readings
+
+
+
+
+ CamAudioType - Indicating audio type Availability - Availability of Camera (disabled, enabled, disconnected, other) CamEventNum - delivers the total number of in SVS registered events of the camera CamExposureControl - indicating type of exposure control CamExposureMode - current exposure mode (Day, Night, Auto, Schedule, Unknown) CamForceEnableMulticast - Is the camera forced to enable multicast. CamIP - IP-Address of Camera CamLastRec - Path / name of the last recording CamLastRecTime - date / starttime / endtime of the last recording CamLiveFps - Frames per second of Live-Stream CamLiveMode - Source of Live-View (DS, Camera) camLiveQuality - Live-Stream quality set in SVS camLiveResolution - Live-Stream resolution set in SVS camLiveStreamNo - used Stream-number for Live-Stream CamModel - Model of camera CamMotDetSc - state of motion detection source (disabled, by camera, by SVS) and their parameter CamNTPServer - set time server CamPort - IP-Port of Camera CamPreRecTime - Duration of Pre-Recording (in seconds) adjusted in SVS CamPtSpeed - adjusted value of Pan/Tilt-activities (setup in SVS) CamRecShare - shared folder on disk station for recordings CamRecVolume - Volume on disk station for recordings CamStreamFormat - the current format of video streaming CamVideoType - Indicating video type CamVendor - Identifier of camera producer CamVideoFlip - Is the video flip CamVideoMirror - Is the video mirror CamVideoRotate - Is the video rotate CapAudioOut - Capability to Audio Out over Surveillance Station (false/true) CapChangeSpeed - Capability to various motion speed CapPIR - has the camera a PIR sensor feature CapPTZAbs - Capability to perform absolute PTZ action CapPTZAutoFocus - Capability to perform auto focus action CapPTZDirections - the PTZ directions that camera support CapPTZFocus - mode of support for focus action CapPTZHome - Capability to perform home action CapPTZIris - mode of support for iris action CapPTZObjTracking - Capability to perform objekt-tracking CapPTZPan - Capability to perform pan action CapPTZPresetNumber - The maximum number of preset supported by the model. 0 stands for preset incapability CapPTZTilt - mode of support for tilt action CapPTZZoom - Capability to perform zoom action DeviceType - device type (Camera, Video_Server, PTZ, Fisheye) Error - message text of last error Errorcode - error code of last error HomeModeState - HomeMode-state (SVS-version 8.1.0 and above) LastLogEntry - the neweset entry of Surveillance Station Log (only if SVS-device and if attribute pollcaminfoall is set) LastSnapFilename - the filename of the last snapshot LastSnapId - the ID of the last snapshot LastSnapTime - timestamp of the last snapshot LastUpdateTime - date / time the last update of readings by "caminfoall" LiveStreamUrl - the livestream URL if stream is started (is shown if attribute "showStmInfoFull" is set) Patrols - in Synology Surveillance Station predefined patrols (at PTZ-Cameras) PollState - shows the state of automatic polling PresetHome - Name of Home-position (at PTZ-Cameras) Presets - in Synology Surveillance Station predefined Presets (at PTZ-Cameras) Record - if recording is running = Start, if no recording is running = Stop StmKey - current streamkey. it can be used to open livestreams without session id StmKeyUnicst - Uni-cast stream path of the camera. (attribute "showStmInfoFull" has to be set) StmKeymjpegHttp - Mjpeg stream path(over http) of the camera (attribute "showStmInfoFull" has to be set) SVScustomPortHttp - Customized port of Surveillance Station (HTTP) (to get with "svsinfo") SVScustomPortHttps - Customized port of Surveillance Station (HTTPS) (to get with "svsinfo") SVSlicenseNumber - The total number of installed licenses (to get with "svsinfo") SVSuserPriv - The effective rights of the user used for log in (to get with "svsinfo") SVSversion - package version of the installed Surveillance Station (to get with "svsinfo") UsedSpaceMB - used disk space of recordings by Camera VideoFolder - Path to the recorded video compstate - state of compatibility (compares current/simulated SVS-version with Internal COMPATIBILITY)
+
+
+
+
+
+
+=end html
+=begin html_DE
+
+SSCam
+
+ Mit diesem Modul können Operationen von in der Synology Surveillance Station (SVS) definierten Kameras und Funktionen
+ der SVS ausgeführt werden. Es basiert auf der SVS API und unterstützt die SVS ab Version 7.
+
+ Start einer Aufnahme
+ Stop einer Aufnahme (per Befehl bzw. automatisch nach Ablauf der Aufnahmedauer)
+ Aufnehmen eines Schnappschusses und Ablage in der Synology Surveillance Station
+ Deaktivieren einer Kamera in Synology Surveillance Station
+ Aktivieren einer Kamera in Synology Surveillance Station
+ Steuerung der Belichtungsmodi Tag, Nacht bzw. Automatisch
+ Umschaltung der Ereigniserkennung durch Kamera, durch SVS oder deaktiviert
+ steuern der Erkennungsparameterwerte Empfindlichkeit, Schwellwert, Objektgröße und Prozentsatz für Auslösung
+ Abfrage von Kameraeigenschaften (auch mit Polling) sowie den Eigenschaften des installierten SVS-Paketes
+ Bewegen an eine vordefinierte Preset-Position (bei PTZ-Kameras)
+ Start einer vordefinierten Überwachungstour (bei PTZ-Kameras)
+ Positionieren von PTZ-Kameras zu absoluten X/Y-Koordinaten
+ kontinuierliche Bewegung von PTZ-Kameras
+ auslösen externer Ereignisse 1-10 (Aktionsregel SVS)
+ starten und beenden von Kamera-Livestreams incl. Audiowiedergabe, anzeigen der letzten Aufnahme oder des letzten Schnappschusses
+ Abruf und Ausgabe der Kamera Streamkeys sowie Stream-Urls (Nutzung von Kamera-Livestreams ohne Session Id)
+ abspielen der letzten Aufnahme bzw. Anzeige des letzten Schnappschusses
+ anzeigen der gespeicherten Anmeldeinformationen (Credentials)
+ Ein- bzw. Ausschalten des Surveillance Station HomeMode und abfragen des HomeMode-Status
+ abrufen des Surveillance Station Logs, auswerten des neuesten Eintrags als Reading
+ erzeugen einer Gallerie der letzten 1-10 Schnappschüsse (als Popup oder permanentes Device)
+ Start bzw. Stop Objekt Tracking (nur unterstützte PTZ-Kameras mit dieser Fähigkeit)
+ Setzen/Löschen eines Presets (bei PTZ-Kameras)
+ Setzen der Home-Position (bei PTZ-Kameras)
+ erstellen eines Paneels zur Kamera-Steuerung. (bei PTZ-Kameras)
+ erzeugen unterschiedlicher Typen von separaten Streaming-Devices (createStreamDev)
+ Aktivierung / Deaktivierung eines kamerainternen PIR-Sensors
+
+
+ 49_SSCam: Fragen, Hinweise, Neuigkeiten und mehr rund um dieses Modul .SSCAM - Steuerung von Kameras in Synology Surveillance Station .Vorbereitung
+ Dieses Modul nutzt das Perl-Modul JSON. sudo apt-get install libjson-perl Credentials
+
+Definition
+
+ Kamera wird definiert mit:
+ define <Name> SSCAM <Kameraname in SVS> <ServerAddr> [Port] [Protocol]
+
+ Zunächst muß diese Kamera in der Synology Surveillance Station 7.0 oder höher eingebunden sein und entsprechend
+ funktionieren. SVS-Device zur Steuerung von Funktionen der Surveillance Station wird definiert mit:
+ define <Name> SSCAM SVS <ServerAddr> [Port] [Protocol]
+
+ In diesem Fall wird statt <Kameraname in SVS> nur SVS angegeben.
+
+ Name der Name des neuen Gerätes in FHEM Kameraname Kameraname wie er in der Synology Surveillance Station angegeben ist für Kamera-Device, "SVS" für SVS-Device. Leerzeichen im Namen sind nicht erlaubt. ServerAddr die IP-Addresse des Synology Surveillance Station Host. Hinweis: Es sollte kein Servername verwendet werden weil DNS-Aufrufe in FHEM blockierend sind. Port optional - der Port der Synology Disc Station. Wenn nicht angegeben, wird der Default-Port "5000" genutzt Protocol optional - das Protokoll (http oder https) zum Funktionsaufruf. Wenn nicht angegeben, wird der Default "http" genutzt
+
+ Beispiel:
+
+ define CamCP SSCAM Carport 192.168.2.20 [5000] [http]
+ define CamCP SSCAM Carport 192.168.2.20 [5001] [https]
+ # erstellt ein neues Kamera-Device CamCP
+
+ define DS1 SSCAM SVS 192.168.2.20 [5000] [http]
+ define DS1 SSCAM SVS 192.168.2.20 [5001] [https]
+ # erstellt ein neues SVS-Device DS1
+
+
+ Wird eine neue Kamera definiert, wird diesem Device zunächst eine Standardaufnahmedauer von 15 zugewiesen. Attribut "rectime" kann die Aufnahmedauer für jede Kamera individuell angepasst werden. Der Wert "0" für "rectime" führt zu einer Endlosaufnahme, die durch "set <name> off" wieder gestoppt werden muß. Attribut "rectime" gelöscht, greift wieder der Default-Wert (15s) für die Aufnahmedauer. Befehl "set <name> on [rectime]" wird die Aufnahmedauer temporär festgelegt und überschreibt einmalig sowohl den Defaultwert als auch den Wert des gesetzten Attributs "rectime". "set <name> on 0" zu einer Daueraufnahme. Attributen "ptzPanel_.*" beeinflusst werden. Befehl "set <name> createPTZcontrol" .
+
+ Credentials
+ Nach dem Definieren des Gerätes müssen zuerst die Zugangsparameter gespeichert werden. Das geschieht mit dem Befehl:
+
+
+ set <name> credentials <Username> <Passwort>
+
+
+ Die Passwortlänge beträgt maximal 20 Zeichen.
+ DSM-User als Mitglied der Admin-Gruppe: uneingeschränkter Test aller Modulfunktionen -> session: DSM
+ SVS-User als Manager oder Betrachter: angepasstes Privilegienprofil -> session: SurveillanceStation
+
+ Attribut "session" kann ausgewählt werden, ob die Session mit dem DSM oder der SVS
+ aufgebaut werden soll. Weitere Informationen zum Usermanagement in der SVS sind verfügbar mit
+ "get <name> versionNotes 5".Mindestanforderungen der jeweiligen Modulfunktionen an die Nutzerrechte.
+
+
+ set ... credentials - set ... delPreset session: ServeillanceStation - Betrachter set ... disable session: ServeillanceStation - Manager set ... enable session: ServeillanceStation - Manager set ... expmode session: ServeillanceStation - Manager set ... extevent session: DSM - Nutzer Mitglied von Admin-Gruppe set ... goPreset session: ServeillanceStation - Betrachter mit Privileg Objektivsteuerung der Kamera set ... homeMode session: ServeillanceStation - Betrachter mit Privileg Home-Modus schalten ( gilt für SVS-Device ! ) set ... goAbsPTZ session: ServeillanceStation - Betrachter mit Privileg Objektivsteuerung der Kamera set ... move session: ServeillanceStation - Betrachter mit Privileg Objektivsteuerung der Kamera set ... motdetsc session: ServeillanceStation - Manager set ... on session: ServeillanceStation - Betrachter mit erweiterten Privileg "manuelle Aufnahme" set ... off session: ServeillanceStation - Betrachter mit erweiterten Privileg "manuelle Aufnahme" set ... runView session: ServeillanceStation - Betrachter mit Privileg Liveansicht für Kamera set ... runPatrol session: ServeillanceStation - Betrachter mit Privileg Objektivsteuerung der Kamera set ... setHome session: ServeillanceStation - Betrachter set ... setPreset session: ServeillanceStation - Betrachter set ... snap session: ServeillanceStation - Betrachter set ... snapGallery session: ServeillanceStation - Betrachter set ... stopView - get ... caminfo[all] session: ServeillanceStation - Betrachter get ... eventlist session: ServeillanceStation - Betrachter get ... listLog session: ServeillanceStation - Betrachter get ... listPresets session: ServeillanceStation - Betrachter get ... scanVirgin session: ServeillanceStation - Betrachter get ... svsinfo session: ServeillanceStation - Betrachter get ... snapfileinfo session: ServeillanceStation - Betrachter get ... snapGallery session: ServeillanceStation - Betrachter get ... snapinfo session: ServeillanceStation - Betrachter get ... stmUrlPath session: ServeillanceStation - Betrachter
+
+ HTTP-Timeout setzen
+ Alle Funktionen dieses Moduls verwenden HTTP-Aufrufe gegenüber der SVS Web API. Attributes "httptimeout" > 0 kann dieser Wert bei Bedarf entsprechend den technischen
+ Gegebenheiten angepasst werden.
+ Set
+
+
+ set <name> createStreamDev [generic | mjpeg | switched] (gilt für CAM)
+
+
+ generic - das Streaming-Device gibt einen durch das Attribut "genericStrmHtmlTag" bestimmten Content wieder mjpeg - das Streaming-Device gibt einen permanenten MJPEG Kamerastream wieder (Streamkey Methode) switched - Wiedergabe unterschiedlicher Streamtypen. Drucktasten zur Steuerung werden angeboten.
+
+ Attribut "htmlattr" im Kameradevice oder mit den
+ spezifischen Attributen im Streaming-Device beeinflusst werden.
+attr <name> genericStrmHtmlTag <video $HTMLATTR controls autoplay>
+ <source src='http://192.168.2.10:32000/$NAME.m3u8' type='application/x-mpegURL'>
+ </video>
+
+ Die Variablen $HTMLATTR, $NAME sind Platzhalter und übernehmen ein gesetztes Attribut "htmlattr" bzw. den SSCam-Devicenamen.
+
+
+
+ set <name> createPTZcontrol (gilt für PTZ-CAM)Attributen bzw. den spezifischen Attributen des erzeugten
+ SSCamSTRM-Devices können die Eigenschaften des PTZ-Paneels beeinflusst werden.
+
+
+ set <name> createSnapGallery (gilt für CAM)Attributen bzw. den spezifischen Attributen des erzeugten SSCamSTRM-Devices
+ können die Eigenschaften der Schnappschußgallerie beeinflusst werden.
+
+
+ set <name> credentials <username> <password> (gilt für CAM/SVS)Credentials
+
+
+ set <name> delPreset <PresetName> (gilt für PTZ-CAM)
+
+ set <name> [enable|disable] (gilt für CAM)deaktivieren / zu aktivieren zwei Beispiele mit at:
+
+ define a13 at 21:46 set CamCP1,CamFL,CamHE1,CamTER disable (enable)
+ define a14 at 21:46 set Cam.* disable (enable)
+
+
+ Etwas komfortabler gelingt das Schalten aller Kameras über einen Dummy. Zunächst wird der Dummy angelegt:
+
+ define allcams dummy
+ attr allcams eventMap on:enable off:disable
+ attr allcams room Cams
+ attr allcams webCmd enable:disable
+
+
+ Durch Verknüpfung mit zwei angelegten notify, jeweils ein notify für "enable" und "disable", kann man durch Schalten des Dummys auf "enable" bzw. "disable" alle Kameras auf einmal aktivieren bzw. deaktivieren.
+
+ define all_cams_disable notify allcams:.*off set CamCP1,CamFL,CamHE1,CamTER disable
+ attr all_cams_disable room Cams
+
+ define all_cams_enable notify allcams:on set CamCP1,CamFL,CamHE1,CamTER enable
+ attr all_cams_enable room Cams
+
+
+
+ set <name> expmode [day|night|auto] (gilt für CAM) Hinweis:
+
+
+ set <name> extevent [ 1-10 ] (gilt für SVS)
+
+ set <name> goAbsPTZ [ X Y | up | down | left | right ] (gilt für CAM)
+ set <name> goAbsPTZ 120 450
+
+
+ Dieses Beispiel bewegt die Kameralinse in die Position X=120 und Y=450.
+ X = 0 - 640 (0 - 319 bewegt nach links, 321 - 640 bewegt nach rechts, 320 bewegt die Linse nicht)
+ Y = 0 - 480 (0 - 239 bewegt nach unten, 241 - 480 bewegt nach oben, 240 bewegt die Linse nicht)
+
+
+ Die Linse kann damit in kleinsten bis sehr großen Schritten in die gewünschte Richtung bewegt werden.
+ Dieser Vorgang muß ggf. mehrfach wiederholt werden um die Kameralinse in die gewünschte Position zu bringen.
+ set <name> goAbsPTZ [up|down|left|right]
+
+
+ verwendet werden. Die Optik wird in diesem Fall mit der größt möglichen Schrittweite zur Absolutposition in der angegebenen Richtung bewegt.
+ Auch in diesem Fall muß der Vorgang ggf. mehrfach wiederholt werden um die Kameralinse in die gewünschte Position zu bringen.
+
+
+ set <name> goPreset <Preset> (gilt für CAM)
+ define CamFL.Preset.Wandschrank notify MelderTER:on.* set CamFL goPreset Wandschrank, ;; define CamFL.Preset.record at +00:00:10 set CamFL on 5 ;;;; define s3 at +*{3}00:00:05 set CamFL snap ;; define CamFL.Preset.back at +00:00:30 set CamFL goPreset Home
+
+
+ Funktionsweise:
+ 2016.02.04 15:02:14 2: CamFL - Camera Flur_Vorderhaus has moved to position "Wandschrank"
+ 2016.02.04 15:02:24 2: CamFL - Camera Flur_Vorderhaus Recording with Recordtime 5s started
+ 2016.02.04 15:02:29 2: CamFL - Snapshot of Camera Flur_Vorderhaus has been done successfully
+ 2016.02.04 15:02:30 2: CamFL - Camera Flur_Vorderhaus Recording stopped
+ 2016.02.04 15:02:34 2: CamFL - Snapshot of Camera Flur_Vorderhaus has been done successfully
+ 2016.02.04 15:02:39 2: CamFL - Snapshot of Camera Flur_Vorderhaus has been done successfully
+ 2016.02.04 15:02:44 2: CamFL - Camera Flur_Vorderhaus has moved to position "Home"
+
+
+
+ set <name> homeMode [on|off] (gilt für SVS)Synology Onlinehilfe
+ enthalten.
+
+
+
+ set <name> motdetsc [camera|SVS|disable] (gilt für CAM)
+
+
+ set <name> motdetsc SVS [Empfindlichkeit] [Schwellwert] # Befehlsmuster set <name> motdetsc SVS 91 30 # setzt die Empfindlichkeit auf 91 und den Schwellwert auf 30 set <name> motdetsc SVS 0 40 # behält gesetzten Wert für Empfindlichkeit bei, setzt Schwellwert auf 40 set <name> motdetsc SVS 15 # setzt die Empfindlichkeit auf 15, Schwellwert bleibt unverändert
+
+
+
+
+ set <name> motdetsc camera [Empfindlichkeit] [Schwellwert] [Prozentsatz] # Befehlsmuster set <name> motdetsc camera 89 0 20 # setzt die Empfindlichkeit auf 89, Prozentsatz auf 20 set <name> motdetsc camera 0 40 10 # behält gesetzten Wert für Empfindlichkeit bei, setzt Schwellwert auf 40, Prozentsatz auf 10 set <name> motdetsc camera 30 # setzt die Empfindlichkeit auf 30, andere Werte bleiben unverändert
+
+ Reading "CamMotDetSc" aktualisiert welches die gegenwärtige Einstellung der Bewegungserkennung dokumentiert.
+ Es werden nur die Parameter und Parameterwerte angezeigt, welche die SVS aktiv unterstützt. Die Kamera selbst kann weiterführende Einstellmöglichkeiten besitzen.
+ CamMotDetSc SVS, sensitivity: 76, threshold: 55
+
+
+ set <name> move [ right | up | down | left | dir_X ] [Sekunden] (gilt für CAM bis SVS Version 7.1) set <name> move [ right | upright | up | upleft | left | downleft | down | downright ] [Sekunden] (gilt für CAM ab SVS Version 7.2) Beispiele:
+ set <name> move up 0.5 : bewegt PTZ 0,5 Sek. (zzgl. Prozesszeit) nach oben
+ set <name> move dir_1 1.5 : bewegt PTZ 1,5 Sek. (zzgl. Prozesszeit) nach rechts-oben
+ set <name> move dir_20 0.7 : bewegt PTZ 1,5 Sek. (zzgl. Prozesszeit) nach links-unten ("CapPTZDirections = 32)"
+
+
+
+ set <name> [on [<rectime>] | off] (gilt für CAM)Attribut "recextend = 0" bzw. nicht gesetzt (Standard):
+ wird eine Aufnahme mit z.B. rectime=22 gestartet, wird kein weiterer Startbefehl für eine Aufnahme akzeptiert bis diese gestartete Aufnahme nach 22 Sekunden
+ beendet ist. Ein Hinweis wird bei verbose=3 im Logfile protokolliert.
+
+ Attribut "recextend = 1" gesetzt:
+ eine zuvor gestartete Aufnahme wird bei einem erneuten "set on" -Befehl um die Aufnahmezeit "rectime" verlängert. Das bedeutet, dass der Timer für
+ den automatischen Stop auf den Wert "rectime" neu gesetzt wird. Dieser Vorgang wiederholt sich mit jedem Start-Befehl. Dadurch verlängert sich eine laufende
+ Aufnahme bis kein Start-Inpuls mehr registriert wird.
+
+ eine zuvor gestartete Endlos-Aufnahme wird mit einem erneuten "set on"-Befehl nach der Aufnahmezeit "rectime" gestoppt (Timerneustart). Ist dies
+ nicht gewünscht, ist darauf zu achten dass bei der Verwendung einer Endlos-Aufnahme das Attribut "recextend" nicht verwendet wird.
+
+ Start/Stop einer Aufnahme :
+
+ set <name> on [rectime] startet die Aufnahme der Kamera <name>, automatischer Stop der Aufnahme nach Ablauf der Zeit [rectime] (default 15s oder wie im Attribut "rectime" angegeben) set <name> off stoppt die Aufnahme der Kamera <name>
+
+
+ set <name> optimizeParams [mirror:<value>] [flip:<value>] [rotate:<value>] [ntp:<value>] (gilt für CAM)
+ mirror, flip, rotate: true | false
+ ntp: der Name oder die IP-Adresse des Zeitservers
+
+ Beispiele: set <name> optimizeParams mirror:true flip:true ntp:time.windows.com set <name> optimizeParams ntp:Surveillance%20Station set <name> optimizeParams mirror:true flip:false rotate:true
+
+
+ set <name> pirSensor [activate | deactivate] (gilt für CAM)
+
+ set <name> runPatrol <Patrolname> (gilt für CAM)
+
+ set <name> runView [live_fw | live_fw_hls | live_link | live_open [<room>] | lastrec_fw | lastrec_fw_MJPEG | lastrec_fw_MPEG4/H.264 | lastrec_open [<room>] | lastsnap_fw] (gilt für CAM)
+
+
+ live_fw - MJPEG-LiveStream. Audiowiedergabe wird mit angeboten wenn verfügbar. live_fw_hls - HLS-LiveStream (aktuell nur Mac Safari und mobile iOS/Android-Geräte) live_link - Link zu einem MJPEG-Livestream live_open [<room>] - öffnet MJPEG-Stream in separatem Browser-Fenster lastrec_fw - letzte Aufnahme als iFrame Objekt lastrec_fw_MJPEG - nutzbar wenn Aufnahme im Format MJPEG vorliegt lastrec_fw_MPEG4/H.264 - nutzbar wenn Aufnahme im Format MPEG4/H.264 vorliegt lastrec_open [<room>] - letzte Aufnahme wird in separatem Browser-Fenster geöffnet lastsnap_fw - letzter Schnappschuss wird dargestellt
+
+ "live_fw, live_link, live_open" wird ein MJPEG-Livestream, entweder als eingebettetes Image
+ oder als generierter Link, gestartet. "live_open" öffnet ein separates Browserfenster mit dem MJPEG-Livestream. Wird dabei optional der Raum mit
+ angegeben, wird das Browserfenster nur dann gestartet, wenn dieser Raum aktuell im Browser geöffnet ist. "live_fw_hls" ein HLS-Stream verwendet werden, muss die Kamera in der Synology Surveillance Station auf
+ das Videoformat H.264 (nicht MJPEG) eingestellt und HLS durch die eingesetzte SVS-Version unterstützt sein.
+ Diese Möglichkeit wird deshalb nur dann angeboten wenn das Reading "CamStreamFormat" den Wert "HLS" hat.
+ "lastrec_fw.*" bzw. "lastrec_open" erfolgen.
+ Bei Verwendung von "lastrec_fw.*" wird die letzte Aufnahme als eingebettetes iFrame-Objekt abgespielt. Es werden entsprechende
+ Steuerungselemente zur Wiedergabegeschwindigkeit usw. angeboten wenn verfügbar. "set <name> runView lastsnap_fw" zeigt den letzten Schnappschuss der Kamera eingebettet an. "lastrec_open" erfolgt die gleiche Einschränkung wie bei "live_open". Attribut "htmlattr" beeinflusst werden.
+ Beispiel:
+ attr <name> htmlattr width="500" height="375"
+ attr <name> htmlattr width="500" height="375" top="200" left="300"
+
+
+ Wird der Stream als live_fw gestartet, ändert sich die Größe entsprechend der Angaben von Width und Hight. "set <name> runView live_open" startet den Livestreamlink sofort in einem neuen
+ Browserfenster.
+ Dabei wird für jede aktive FHEMWEB-Session eine Fensteröffnung initiiert. Soll dieses Verhalten geändert werden, kann
+ "set <name> runView live_open <room>" verwendet werden um das Öffnen des Browserfensters in einem
+ beliebigen, in einer FHEMWEB-Session aktiven Raum "<room>", zu initiieren.Attribut "livestreamprefix" überschreibt im Reading "LiveStreamUrl"
+ die Angaben für Protokoll, Servername und Port. Damit kann z.B. die LiveStreamUrl für den Versand und externen Zugriff
+ auf die SVS modifiziert werden. Beispiel:
+ attr <name> livestreamprefix https://<Servername>:<Port>
+
+
+ Der Livestream wird über das Kommando "set <name> stopView" wieder beendet.
+
+
+ Start Recording - startet eine Endlosaufnahme Stop Recording - stoppt eine Aufnahme Take Snapshot - löst einen Schnappschuß aus Switch off - stoppt eine laufende Wiedergabe
+
+ Hinweis zu HLS (HTTP Live Streaming):
+ set <name> setHome <PresetName> (gilt für PTZ-CAM)
+
+ set <name> setPreset <PresetNummer> [<PresetName>] [<Speed>] (gilt für PTZ-CAM)
+
+ set <name> snap (gilt für CAM)Schnappschuß kann ausgelöst werden mit:
+
+ set <name> snap
+
+
+ Nachfolgend einige Beispiele für die Auslösung von Schnappschüssen .
+ define he1_snap_3 notify CamHE1:Record.*Start define h3 at +*{3}00:00:02 set CamHE1 snap
+
+
+ Triggern von 2 Schnappschüssen der Kamera "CamHE1" im Abstand von 6 Sekunden nachdem der Bewegungsmelder "MelderHE1" einen Event gesendet hat,
+ define he1_snap_2 notify MelderHE1:on.* define h2 at +*{2}00:00:06 set CamHE1 snap
+
+
+ Es wird die ID und der Filename des letzten Snapshots als Wert der Variable "LastSnapId" bzw. "LastSnapFilename" in den Readings der Kamera ausgegeben.
+ set <name> snapGallery [1-10] (gilt für CAM)"get <name> snapGallery" . Abweichend von "get" wird mit Attribut
+ Attribut "snapGalleryBoost=1" kein Popup erzeugt, sondern die Schnappschußgalerie als Browserseite
+ dargestellt. Alle weiteren Funktionen und Attribute entsprechen dem "get <name> snapGallery" Kommando. "get <name> snapGallery" Kommando anstatt "set" verwendet werden.
+
+
+ set <name> startTracking (gilt für CAM mit Tracking Fähigkeit)
+
+ set <name> stopTracking (gilt für CAM mit Tracking Fähigkeit)
+ Get
+
+
+ get <name> caminfoall (gilt für CAM/SVS) get <name> caminfo (gilt für CAM)
+
+ get <name> eventlist (gilt für CAM)Reading "CamEventNum" und "CamLastRec"
+ aktualisiert, welches die Gesamtanzahl der registrierten Kameraevents und den Pfad / Namen der letzten Aufnahme enthält.
+ Dieser Befehl wird implizit mit "get <name> caminfoall" ausgeführt. Attribut "videofolderMap" kann der Inhalt des Readings "VideoFolder" überschrieben werden.
+ Dies kann von Vortel sein wenn das Surveillance-Verzeichnis der SVS an dem lokalen PC unter anderem Pfadnamen gemountet ist
+ und darüber der Zugriff auf die Aufnahmen erfolgen soll (z.B. Verwendung bei Email-Versand).
+ define CamHE1.snap.email DOIF ([CamHE1:"LastSnapFilename"])
+ ({DebianMailnbl ('Recipient@Domain','Bewegungsalarm CamHE1','Eine Bewegung wurde an der Haustür registriert. Aufnahmelink: \
+ \[CamHE1:VideoFolder]\[CamHE1:CamLastRec]','/media/sf_surveillance/@Snapshot/[CamHE1:LastSnapFilename]')})
+
+
+
+
+ get <name> homeModeState (gilt für SVS)
+
+ get <name> listLog [severity:<Loglevel>] [limit:<Zeilenzahl>] [match:<Suchstring>] (gilt für SVS)
+ <Loglevel> - Information, Warning oder Error. Nur Sätze mit dem Schweregrad werden abgerufen (default: alle)
+ <Zeilenzahl> - die angegebene Anzahl der Logzeilen (neueste) wird abgerufen (default: alle)
+ <Suchstring> - nur Logeinträge mit dem angegeben String werden abgerufen (Achtung: kein Regex, der Suchstring wird im Call an die SVS mitgegeben)
+
+ Beispiele
+ get <name> listLog severity:Error limit:5 get <name> listLog severity:Information match:Carport get <name> listLog severity:Warning
+
+
+ Wurde mit dem Attribut "pollcaminfoall" das Polling der SVS aktiviert, wird das Reading
+ "LastLogEntry" erstellt. Synology Online-Hlfe .
+
+
+ get <name> listPresets (gilt für PTZ-CAM)
+
+ get <name> scanVirgin (gilt für CAM/SVS)
+
+ get <name> snapGallery [1-10] (gilt für CAM)Attribut "snapGalleryBoost" gesetzt,
+ werden die letzten Schnappschüsse (default 3) über Polling abgefragt und im Speicher gehalten. Das Verfahren hilft die Ausgabe zu beschleunigen,
+ kann aber möglicherweise nicht den letzten Schnappschuß anzeigen, falls dieser NICHT über das Modul ausgelöst wurde. Attribute :
+ snapGalleryBoost
+ snapGalleryColumns
+ snapGalleryHtmlAttr
+ snapGalleryNumber
+ snapGallerySize
+
+ Hinweis:
+
+ get <name> snapfileinfo (gilt für CAM)"get <name> snap"
+ ausgeführt.
+
+
+ get <name> snapinfo (gilt für CAM)
+
+ get <name> stmUrlPath (gilt für CAM)Attribut "showStmInfoFull" gesetzt ist, werden zusaätzliche Stream-Informationen wie "StmKeyUnicst", "StmKeymjpegHttp" ausgegeben.
+ Diese Readings enthalten die gültigen Stream-Pfade zu einem Livestream und können z.B. versendet und von einer entsprechenden Anwendung ohne session Id geöffnet werden.
+ Wenn das Attribut "livestreamprefix" (Format: "http(s)://<hostname><port>) gesetzt ist, wird der Servername und Port überschrieben soweit es sinnvoll ist.
+ Wird Polling der Kameraeigenschaften genutzt, wird die stmUrlPath-Funktion automatisch mit ausgeführt.
+
+http(s)://<hostname><port>/webapi/entry.cgi?api=SYNO.SurveillanceStation.VideoStreaming&version=1&method=Stream&format=mjpeg&cameraId=5&StmKey="31fd87279976d89bb98409728cced890"
+
+
+ cameraId (Internal CAMID), StmKey müssen durch gültige Werte ersetzt werden. Hinweis:
+ get <name> storedCredentials (gilt für CAM/SVS)
+
+ get <name> svsinfo (gilt für CAM/SVS)
+
+ get <name> versionNotes [hints | rel | <key>] (gilt für CAM/SVS)
+ Polling der Kamera/SVS-Eigenschaften:
+ PollState = Active - automatisches Polling wird mit Intervall entsprechend "pollcaminfoall" ausgeführt PollState = Inactive - automatisches Polling wird nicht ausgeführt
+ Readings beschrieben. Hinweise: Attribut ) "httptimeout") von 4 Sekunden kann die theoretische Verarbeitungszeit nicht höher als 80 Sekunden betragen. Internals
+ Die Bedeutung der verwendeten Internals stellt die nachfolgende Liste dar:
+ CAMID - die ID der Kamera in der SVS, der Wert wird automatisch anhand des SVS-Kameranamens ermittelt. CAMNAME - der Name der Kamera in der SVS COMPATIBILITY - Information bis zu welcher SVS-Version das Modul kompatibel bzw. zur Zeit getestet ist (siehe Reading "compstate")CREDENTIALS - der Wert ist "Set" wenn die Credentials gesetzt wurden MODEL - Unterscheidung von Kamera-Device (Hersteller - Kameratyp) und Surveillance Station Device (SVS) NAME - der Kameraname in FHEM OPMODE - die zuletzt ausgeführte Operation des Moduls SERVERADDR - IP-Adresse des SVS Hostes SERVERPORT - der SVS-Port
+
+
+
+Attribute
+
+
+ httptimeout htmlattr
+ Beispiel:
+ livestreamprefix loginRetries noQuotesForSID pollcaminfoall pollnologging ptzPanel_Home ptzPanel_iconPath ptzPanel_iconPrefix ptzPanel_row[00-09] <command>:<icon>,<command>:<icon>,... Hinweis
+ Beispiel:
+ ptzPanel_use rectime recextend session simu_SVSversion snapGalleryBoost snapGalleryColumns snapGalleryHtmlAttr
+ Beispiel:
+ snapGalleryNumber snapGallerySize showStmInfoFull showPassInLog videofolderMap verbose
+ Es werden verschiedene Verbose-Level unterstützt.
+ Dies sind im Einzelnen:
+
+
+
+ 0 - Start/Stop-Ereignisse werden geloggt 1 - Fehlermeldungen werden geloggt 2 - Meldungen über wichtige Ereignisse oder Alarme 3 - gesendete Kommandos werden geloggt 4 - gesendete und empfangene Daten werden geloggt 5 - alle Ausgaben zur Fehleranalyse werden geloggt. ACHTUNG: möglicherweise werden sehr viele Daten in das Logfile geschrieben!
+
+ readingFnAttributes
+
+Readings
+
+
+
+
+ CamAudioType - listet den eingestellten Audiocodec auf wenn verwendet Availability - Verfügbarkeit der Kamera (disabled, enabled, disconnected, other) CamEventNum - liefert die Gesamtanzahl der in SVS registrierten Events der Kamera CamExposureControl - zeigt den aktuell eingestellten Typ der Belichtungssteuerung CamExposureMode - aktueller Belichtungsmodus (Day, Night, Auto, Schedule, Unknown) CamForceEnableMulticast - sagt aus ob die Kamera verpflichet ist Multicast einzuschalten. CamIP - IP-Adresse der Kamera CamLastRec - Pfad / Name der letzten Aufnahme CamLastRecTime - Datum / Startzeit - Stopzeit der letzten Aufnahme CamLiveFps - Frames pro Sekunde des Live-Streams CamLiveMode - Quelle für Live-Ansicht (DS, Camera) camLiveQuality - in SVS eingestellte Live-Stream Qualität camLiveResolution - in SVS eingestellte Live-Stream Auflösung camLiveStreamNo - verwendete Stream-Nummer für Live-Stream CamModel - Kameramodell CamMotDetSc - Status der Bewegungserkennung (disabled, durch Kamera, durch SVS) und deren Parameter CamNTPServer - eingestellter Zeitserver CamPort - IP-Port der Kamera CamPreRecTime - Dauer der der Voraufzeichnung in Sekunden (Einstellung in SVS) CamPtSpeed - eingestellter Wert für Schwenken/Neige-Aktionen (Einstellung in SVS) CamRecShare - gemeinsamer Ordner auf der DS für Aufnahmen CamRecVolume - Volume auf der DS für Aufnahmen CamStreamFormat - aktuelles Format des Videostream CamVideoType - listet den eingestellten Videocodec auf CamVendor - Kamerahersteller Bezeichnung CamVideoFlip - Ist das Video gedreht CamVideoMirror - Ist das Video gespiegelt CamVideoRotate - Ist das Video gedreht CapAudioOut - Fähigkeit der Kamera zur Audioausgabe über Surveillance Station (false/true) CapChangeSpeed - Fähigkeit der Kamera verschiedene Bewegungsgeschwindigkeiten auszuführen CapPIR - besitzt die Kamera einen PIR-Sensor CapPTZAbs - Fähigkeit der Kamera für absolute PTZ-Aktionen CapPTZAutoFocus - Fähigkeit der Kamera für Autofokus Aktionen CapPTZDirections - die verfügbaren PTZ-Richtungen der Kamera CapPTZFocus - Art der Kameraunterstützung für Fokussierung CapPTZHome - Unterstützung der Kamera für Home-Position CapPTZIris - Unterstützung der Kamera für Iris-Aktion CapPTZObjTracking - Unterstützung der Kamera für Objekt-Tracking CapPTZPan - Unterstützung der Kamera für Pan-Aktion CapPTZPresetNumber - die maximale Anzahl unterstützter Presets. 0 steht für keine Preset-Unterstützung CapPTZTilt - Unterstützung der Kamera für Tilt-Aktion CapPTZZoom - Unterstützung der Kamera für Zoom-Aktion DeviceType - Kameratyp (Camera, Video_Server, PTZ, Fisheye) Error - Meldungstext des letzten Fehlers Errorcode - Fehlercode des letzten Fehlers HomeModeState - HomeMode-Status (ab SVS-Version 8.1.0) LastLogEntry - der neueste Eintrag des Surveillance Station Logs (nur SVS-Device und wenn Attribut pollcaminfoall gesetzt) LastSnapFilename - der Filename des letzten Schnapschusses LastSnapId - die ID des letzten Schnapschusses LastSnapTime - Zeitstempel des letzten Schnapschusses LastUpdateTime - Datum / Zeit der letzten Aktualisierung durch "caminfoall" LiveStreamUrl - die LiveStream-Url wenn der Stream gestartet ist. (Attribut "showStmInfoFull" muss gesetzt sein) Patrols - in Surveillance Station voreingestellte Überwachungstouren (bei PTZ-Kameras) PollState - zeigt den Status des automatischen Pollings an PresetHome - Name der Home-Position (bei PTZ-Kameras) Presets - in Surveillance Station voreingestellte Positionen (bei PTZ-Kameras) Record - Aufnahme läuft = Start, keine Aufnahme = Stop StmKey - aktueller StreamKey. Kann zum öffnen eines Livestreams ohne Session Id genutzt werden. StmKeyUnicst - Uni-cast Stream Pfad der Kamera. (Attribut "showStmInfoFull" muss gesetzt sein) StmKeymjpegHttp - Mjpeg Stream Pfad (über http) der Kamera. (Attribut "showStmInfoFull" muss gesetzt sein) SVScustomPortHttp - benutzerdefinierter Port der Surveillance Station (HTTP) im DSM-Anwendungsportal (get mit "svsinfo") SVScustomPortHttps - benutzerdefinierter Port der Surveillance Station (HTTPS) im DSM-Anwendungsportal (get mit "svsinfo") SVSlicenseNumber - die Anzahl der installierten Kameralizenzen (get mit "svsinfo") SVSuserPriv - die effektiven Rechte des verwendeten Users nach dem Login (get mit "svsinfo") SVSversion - die Paketversion der installierten Surveillance Station (get mit "svsinfo") UsedSpaceMB - durch Aufnahmen der Kamera belegter Plattenplatz auf dem Volume VideoFolder - Pfad zu den aufgenommenen Videos compstate - Kompatibilitätsstatus (Vergleich von eingesetzter/simulierter SVS-Version zum Internal COMPATIBILITY)
+
+
+
+
+ DbRep
-#
-# This module uses credentials of the DbLog-Device
-#
-###########################################################################################################################
-package main;
-
-use strict;
-use warnings;
-use POSIX qw(strftime);
-use Time::HiRes qw(gettimeofday tv_interval);
-use Scalar::Util qw(looks_like_number);
-eval "use DBI;1" or my $DbRepMMDBI = "DBI";
-use DBI::Const::GetInfoType;
-use Blocking;
-use Color; # colorpicker Widget
-use Time::Local;
-use Encode qw(encode_utf8);
-use IO::Compress::Gzip qw(gzip $GzipError);
-use IO::Uncompress::Gunzip qw(gunzip $GunzipError);
-# no if $] >= 5.018000, warnings => 'experimental';
-no if $] >= 5.017011, warnings => 'experimental::smartmatch';
-
-# Versions History intern
-our %DbRep_vNotesIntern = (
- "8.4.0" => "22.10.2018 countEntries separately for every reading if attribute \"countEntriesDetail\" is set, ".
- "versionNotes changed to support en/de, get dbValue as textfield-long ",
- "8.3.0" => "17.10.2018 reduceLog from DbLog integrated into DbRep, textField-long as default for sqlCmd, both attributes timeOlderThan and timeDiffToNow can be set at same time",
- "8.2.3" => "07.10.2018 check availability of DbLog-device at definition time of DbRep-device ",
- "8.2.2" => "07.10.2018 DbRep_getMinTs changed, fix don't get the real min timestamp in rare cases ",
- "8.2.1" => "07.10.2018 \$hash->{dbloghash}{HELPER}{REOPEN_RUNS_UNTIL} contains time until DB is closed ",
- "8.2.0" => "05.10.2018 direct help for attributes ",
- "8.1.0" => "02.10.2018 new get versionNotes command ",
- "8.0.1" => "20.09.2018 DbRep_getMinTs improved",
- "8.0.0" => "11.09.2018 get filesize in DbRep_WriteToDumpFile corrected, restoreMySQL for clientSide dumps, minor fixes ",
- "7.20.0" => "04.09.2018 deviceRename can operate a Device name with blank, e.g. 'current balance' as old device name ",
- "7.19.0" => "25.08.2018 attribute 'valueFilter' to filter datasets in fetchrows ",
- "7.18.2" => "02.08.2018 fix in fetchrow function (forum:#89886), fix highlighting ",
- "7.18.1" => "03.06.2018 commandref revised ",
- "7.18.0" => "02.06.2018 possible use of y:(\\d) for timeDiffToNow, timeOlderThan , minor fixes of timeOlderThan, delEntries considers executeBeforeDump,executeAfterDump ",
- "7.17.3" => "30.04.2017 writeToDB - readingname can be replaced by the value of attribute 'readingNameMap' ",
- "7.17.2" => "22.04.2017 fix don't writeToDB if device name contain '.' only, minor fix in DbReadingsVal ",
- "7.17.1" => "20.04.2017 fix '§' is deleted by carfilter ",
- "7.17.0" => "17.04.2018 new function DbReadingsVal ",
- "7.16.0" => "13.04.2018 new function dbValue (blocking) ",
- "7.15.2" => "12.04.2018 fix in setting MODEL, prevent fhem from crash if wrong timestamp '0000-00-00' found in db ",
- "7.15.1" => "11.04.2018 sqlCmd accept widget textField-long, Internal MODEL is set ",
- "7.15.0" => "24.03.2018 new command sqlSpecial ",
- "7.14.8" => "21.03.2018 fix no save into database if value=0 (DbRep_OutputWriteToDB) ",
- "7.14.7" => "21.03.2018 exportToFile,importFromFile can use file as an argument and executeBeforeDump, executeAfterDump is considered ",
- "7.14.6" => "18.03.2018 attribute expimpfile can use some kinds of wildcards (exportToFile, importFromFile adapted) ",
- "7.14.5" => "17.03.2018 perl warnings of DbLog \$dn,\$dt,\$evt,\$rd in changeval_Push & complex ",
- "7.14.4" => "11.03.2018 increased timeout of BlockingCall in DbRep_firstconnect ",
- "7.14.3" => "07.03.2018 DbRep_firstconnect changed - get lowest timestamp in database, DbRep_Connect deleted ",
- "7.14.2" => "04.03.2018 fix perl warning ",
- "7.14.1" => "01.03.2018 currentfillup_Push bugfix for PostgreSQL ",
- "7.14.0" => "26.02.2018 syncStandby ",
- "7.13.3" => "25.02.2018 commandref revised (forum:#84953) ",
- "7.13.2" => "24.02.2018 DbRep_firstconnect changed, bug fix in DbRep_collaggstr for aggregation = month ",
- "7.13.1" => "20.02.2018 commandref revised ",
- "7.13.0" => "17.02.2018 changeValue can handle perl code {} as 'new string' ",
- "7.12.0" => "16.02.2018 compression of dumpfile, restore of compressed files possible ",
- "7.11.0" => "12.02.2018 new command 'repairSQLite' to repair a corrupted SQLite database ",
- "7.10.0" => "10.02.2018 bugfix delete attr timeYearPeriod if set other time attributes, new 'changeValue' command ",
- "7.9.0" => "09.02.2018 new attribute 'avgTimeWeightMean' (time weight mean calculation), code review of selection routines, maxValue handle negative values correctly, one security second for correct create TimeArray in DbRep_normRelTime ",
- "7.8.1" => "04.02.2018 bugfix if IsDisabled (again), code review, bugfix last dataset is not selected if timestamp is fully set ('date time'), fix '\$runtime_string_next' = '\$runtime_string_next.999';' if \$runtime_string_next is part of sql-execute place holder AND contains date+time ",
- "7.8.0" => "04.02.2018 new command 'eraseReadings' ",
- "7.7.1" => "03.02.2018 minor fix in DbRep_firstconnect if IsDisabled ",
- "7.7.0" => "29.01.2018 attribute 'averageCalcForm', calculation sceme 'avgDailyMeanGWS', 'avgArithmeticMean' for averageValue ",
- "7.6.1" => "27.01.2018 new attribute 'sqlCmdHistoryLength' and 'fetchMarkDuplicates' for highlighting multiple datasets by fetchrows ",
- "7.6.0" => "26.01.2018 events containing '|' possible in fetchrows & delSeqDoublets, fetchrows displays multiple \$k entries with timestamp suffix \$k (as index), sqlCmdHistory (avaiable if sqlCmd was executed) ",
- "7.5.5" => "25.01.2018 minor change in delSeqDoublets ",
- "7.5.4" => "24.01.2018 delseqdoubl_DoParse reviewed to optimize memory usage, executeBeforeDump executeAfterDump now available for 'delSeqDoublets' ",
- "7.5.3" => "23.01.2018 new attribute 'ftpDumpFilesKeep', version management added to FTP-usage ",
- "7.5.2" => "23.01.2018 fix typo DumpRowsCurrrent, dumpFilesKeep can be set to '0', commandref revised ",
- "7.5.1" => "20.01.2018 DbRep_DumpDone changed to create background_processing_time before execute 'executeAfterProc' Commandref updated ",
- "7.5.0" => "16.01.2018 DbRep_OutputWriteToDB, set options display/writeToDB for (max|min|sum|average|diff)Value ",
- "7.4.1" => "14.01.2018 fix old dumpfiles not deleted by dumpMySQL clientSide ",
- "7.4.0" => "09.01.2018 dumpSQLite/restoreSQLite, backup/restore now available when DbLog-device has reopen xxxx running, executeBeforeDump executeAfterDump also available for optimizeTables, vacuum, restoreMySQL, restoreSQLite, attribute executeBeforeDump / executeAfterDump renamed to executeBeforeProc & executeAfterProc ",
- "7.3.1" => "08.01.2018 fix syntax error for perl < 5.20 ",
- "7.3.0" => "07.01.2018 DbRep-charfilter avoid control characters in datasets to export, impfile_Push errortext improved, expfile_DoParse changed to use aggregation for split selects in timeslices (avoid heavy memory consumption) ",
- "7.2.1" => "04.01.2018 bugfix month out of range that causes fhem crash ",
- "1.0.0" => "19.05.2016 Initial"
-);
-
-# Versions History extern:
-our %DbRep_vNotesExtern = (
- "8.4.0" => "22.10.2018 New attribute \"countEntriesDetail\". Function countEntries creates number of datasets for every ".
- "reading separately if attribute \"countEntriesDetail\" is set. Get versionNotes changed to support en/de. ".
- "Function \"get dbValue\" opens an editor window ",
- "8.3.0" => "17.10.2018 reduceLog from DbLog integrated into DbRep, textField-long as default for sqlCmd, both attributes ".
- "timeOlderThan and timeDiffToNow can be set at same time -> the selection time between timeOlderThan ".
- "and timeDiffToNow can be calculated dynamically ",
- "8.2.2" => "07.10.2018 fix don't get the real min timestamp in rare cases ",
- "8.2.0" => "05.10.2018 direct help for attributes ",
- "8.1.0" => "01.10.2018 new get versionNotes command ",
- "8.0.0" => "11.09.2018 get filesize in DbRep_WriteToDumpFile corrected, restoreMySQL for clientSide dumps, minor fixes ",
- "7.20.0" => "04.09.2018 deviceRename can operate a Device name with blank, e.g. 'current balance' as old device name ",
- "7.19.0" => "25.08.2018 attribute 'valueFilter' to filter datasets in fetchrows ",
- "7.18.2" => "02.08.2018 fix in fetchrow function (forum:#89886), fix highlighting ",
- "7.18.0" => "02.06.2018 possible use of y:(\\d) for timeDiffToNow, timeOlderThan , minor fixes of timeOlderThan, delEntries considers executeBeforeDump,executeAfterDump ",
- "7.17.3" => "30.04.2017 writeToDB - readingname can be replaced by the value of attribute 'readingNameMap' ",
- "7.17.0" => "17.04.2018 new function DbReadingsVal ",
- "7.16.0" => "13.04.2018 new function dbValue (blocking) ",
- "7.15.2" => "12.04.2018 fix in setting MODEL, prevent fhem from crash if wrong timestamp '0000-00-00' found in db ",
- "7.15.1" => "11.04.2018 sqlCmd accept widget textField-long, Internal MODEL is set ",
- "7.15.0" => "24.03.2018 new command sqlSpecial ",
- "7.14.7" => "21.03.2018 exportToFile,importFromFile can use file as an argument and executeBeforeDump, executeAfterDump is considered ",
- "7.14.6" => "18.03.2018 attribute expimpfile can use some kinds of wildcards (exportToFile, importFromFile adapted) ",
- "7.14.3" => "07.03.2018 DbRep_firstconnect changed - get lowest timestamp in database, DbRep_Connect deleted ",
- "7.14.0" => "26.02.2018 new syncStandby command",
- "7.12.0" => "16.02.2018 compression of dumpfile, restore of compressed files possible ",
- "7.11.0" => "12.02.2018 new command 'repairSQLite' to repair a corrupted SQLite database ",
- "7.10.0" => "10.02.2018 bugfix delete attr timeYearPeriod if set other time attributes, new 'changeValue' command ",
- "7.9.0" => "09.02.2018 new attribute 'avgTimeWeightMean' (time weight mean calculation), code review of selection routines, maxValue handle negative values correctly, one security second for correct create TimeArray in DbRep_normRelTime ",
- "7.8.1" => "04.02.2018 bugfix if IsDisabled (again), code review, bugfix last dataset is not selected if timestamp is fully set ('date time'), fix '\$runtime_string_next' = '\$runtime_string_next.999';' if \$runtime_string_next is part of sql-execute place holder AND contains date+time ",
- "7.8.0" => "04.02.2018 new command 'eraseReadings' ",
- "7.7.1" => "03.02.2018 minor fix in DbRep_firstconnect if IsDisabled ",
- "7.7.0" => "29.01.2018 attribute 'averageCalcForm', calculation sceme 'avgDailyMeanGWS', 'avgArithmeticMean' for averageValue ",
- "7.6.1" => "27.01.2018 new attribute 'sqlCmdHistoryLength' and 'fetchMarkDuplicates' for highlighting multiple datasets by fetchrows ",
- "7.5.3" => "23.01.2018 new attribute 'ftpDumpFilesKeep', version management added to FTP-usage ",
- "7.4.1" => "14.01.2018 fix old dumpfiles not deleted by dumpMySQL clientSide ",
- "7.4.0" => "09.01.2018 dumpSQLite/restoreSQLite, backup/restore now available when DbLog-device has reopen xxxx running, executeBeforeDump executeAfterDump also available for optimizeTables, vacuum, restoreMySQL, restoreSQLite, attribute executeBeforeDump / executeAfterDump renamed to executeBeforeProc & executeAfterProc ",
- "7.3.1" => "08.01.2018 fix syntax error for perl < 5.20 ",
- "7.1.0" => "22.12.2017 new attribute timeYearPeriod for reports correspondig to e.g. electricity billing, bugfix connection check is running after restart allthough dev is disabled ",
- "6.4.1" => "13.12.2017 new Attribute 'sqlResultFieldSep' for field separate options of sqlCmd result ",
- "6.4.0" => "10.12.2017 prepare module for usage of datetime picker widget (Forum:#35736) ",
- "6.1.0" => "29.11.2017 new command delSeqDoublets (adviceRemain,adviceDelete), add Option to LASTCMD ",
- "6.0.0" => "18.11.2017 FTP transfer dumpfile after dump, delete old dumpfiles within Blockingcall (avoid freezes) commandref revised, minor fixes ",
- "5.6.4" => "05.10.2017 abortFn's adapted to use abortArg (Forum:77472) ",
- "5.6.3" => "01.10.2017 fix crash of fhem due to wrong rmday-calculation if month is changed, Forum:#77328 ",
- "5.6.0" => "17.07.2017 default timeout changed to 86400, new get-command 'procinfo' (MySQL) ",
- "5.4.0" => "03.07.2017 restoreMySQL - restore of csv-files (from dumpServerSide), RestoreRowsHistory/ DumpRowsHistory, Commandref revised ",
- "5.3.1" => "28.06.2017 vacuum for SQLite added, readings enhanced for optimizeTables / vacuum, commandref revised ",
- "5.3.0" => "26.06.2017 change of DbRep_mysqlOptimizeTables, new command optimizeTables ",
- "5.0.6" => "13.06.2017 add Aria engine to DbRep_mysqlOptimizeTables ",
- "5.0.3" => "07.06.2017 mysql_DoDumpServerSide added ",
- "5.0.1" => "05.06.2017 dependencies between dumpMemlimit and dumpSpeed created, enhanced verbose 5 logging ",
- "5.0.0" => "04.06.2017 MySQL Dump nonblocking added ",
- "4.16.1" => "22.05.2017 encode json without JSON module, requires at least fhem.pl 14348 2017-05-22 20:25:06Z ",
- "4.14.1" => "16.05.2017 limitation of fetchrows result datasets to 1000 by attr limit ",
- "4.14.0" => "15.05.2017 UserExitFn added as separate sub (DbRep_userexit) and attr userExitFn defined, new subs ReadingsBulkUpdateTimeState, ReadingsBulkUpdateValue, ReadingsSingleUpdateValue, commandref revised ",
- "4.13.4" => "09.05.2017 attribute sqlResultSingleFormat: mline sline table, attribute 'allowDeletion' is now also valid for sqlResult, sqlResultSingle and delete command is forced ",
- "4.13.2" => "09.05.2017 sqlResult, sqlResultSingle are able to execute delete, insert, update commands error corrections ",
- "4.12.0" => "31.03.2017 support of primary key for insert functions ",
- "4.11.4" => "29.03.2017 bugfix timestamp in minValue, maxValue if VALUE contains more than one numeric value (like in sysmon) ",
- "4.11.3" => "26.03.2017 usage of daylight saving time changed to avoid wrong selection when wintertime switch to summertime, minor bug fixes ",
- "4.11.2" => "16.03.2017 bugfix in func dbmeta_DoParse (SQLITE_DB_FILENAME) ",
- "4.11.0" => "18.02.2017 added [current|previous]_[month|week|day|hour]_begin and [current|previous]_[month|week|day|hour]_end as options of timestamp ",
- "4.10.2" => "16.01.2017 bugfix uninitialized value \$renmode if RenameAgent ",
- "4.10.1" => "30.11.2016 bugfix importFromFile format problem if UNIT-field wasn't set ",
- "4.9.0" => "23.12.2016 function readingRename added ",
- "4.8.6" => "17.12.2016 new bugfix group by-clause due to incompatible changes made in MyQL 5.7.5 (Forum #msg541103) ",
- "4.8.5" => "16.12.2016 bugfix group by-clause due to Forum #msg540610 ",
- "4.7.6" => "07.12.2016 DbRep version as internal, check if perl module DBI is installed ",
- "4.7.4" => "28.11.2016 sub DbRep_calcount changed due to Forum #msg529312 ",
- "4.7.3" => "20.11.2016 new diffValue function made suitable to SQLite ",
- "4.6.0" => "31.10.2016 bugfix calc issue due to daylight saving time end (winter time) ",
- "4.5.1" => "18.10.2016 get svrinfo contains SQLite database file size (MB), modified timeout routine ",
- "4.2.0" => "10.10.2016 allow SQL-Wildcards in attr reading & attr device ",
- "4.1.3" => "09.10.2016 bugfix delEntries running on SQLite ",
- "3.13.0" => "03.10.2016 added deviceRename to rename devices in database, new Internal DATABASE ",
- "3.12.0" => "02.10.2016 function minValue added ",
- "3.11.1" => "30.09.2016 bugfix include first and next day in calculation if Timestamp is exactly 'YYYY-MM-DD 00:00:00' ",
- "3.9.0" => "26.09.2016 new function importFromFile to import data from file (CSV format) ",
- "3.8.0" => "16.09.2016 new attr readingPreventFromDel to prevent readings from deletion when a new operation starts ",
- "3.7.2" => "04.09.2016 problem in diffValue fixed if if no value was selected ",
- "3.7.1" => "31.08.2016 Reading 'errortext' added, commandref continued, exportToFile changed, diffValue changed to fix wrong timestamp if error occur ",
- "3.7.0" => "30.08.2016 exportToFile added exports data to file (CSV format) ",
- "3.5.0" => "18.08.2016 new attribute timeOlderThan ",
- "3.4.4" => "12.08.2016 current_year_begin, previous_year_begin, current_year_end, previous_year_end added as possible values for timestamp attribute ",
- "3.4.0" => "03.08.2016 function 'insert' added ",
- "3.3.1" => "15.07.2016 function 'diffValue' changed, write '-' if no value ",
- "3.3.0" => "12.07.2016 function 'diffValue' added ",
- "3.1.1" => "10.07.2016 state turns to initialized and connected after attr 'disabled' is switched from '1' to '0' ",
- "3.1.0" => "09.07.2016 new Attr 'timeDiffToNow' and change subs according to that ",
- "3.0.0" => "04.07.2016 no selection if timestamp isn't set and aggregation isn't set with fetchrows, delEntries ",
- "2.9.8" => "01.07.2016 changed fetchrows_ParseDone to handle readingvalues with whitespaces correctly ",
- "2.9.5" => "30.06.2016 format of readingnames changed again (substitute ':' with '-' in time) ",
- "2.9.4" => "30.06.2016 change readingmap to readingNameMap, prove of unsupported characters added ",
- "2.9.3" => "27.06.2016 format of readingnames changed avoiding some problems after restart and splitting ",
- "2.9.0" => "25.06.2016 attributes showproctime, timeout added ",
- "2.8.0" => "24.06.2016 function averageValue changed to nonblocking function ",
- "2.7.0" => "23.06.2016 changed function countEntries to nonblocking ",
- "2.6.2" => "21.06.2016 aggregation week corrected ",
- "2.6.1" => "20.06.2016 routine maxval_ParseDone corrected ",
- "2.6.0" => "31.05.2016 maxValue changed to nonblocking function ",
- "2.4.0" => "29.05.2016 changed to nonblocking function for sumValue ",
- "2.0.0" => "24.05.2016 added nonblocking function for fetchrow ",
- "1.2.0" => "21.05.2016 function and attribute for delEntries added ",
- "1.0.0" => "19.05.2016 Initial"
-);
-
-# Hint Hash en
-our %DbRep_vHintsExt_en = (
- "2" => "Rules of german weather service for calculation of average temperatures. ",
- "1" => "Some helpful FHEM-Wiki Entries."
-);
-
-# Hint Hash de
-our %DbRep_vHintsExt_de = (
- "2" => "Regularien des deutschen Wetterdienstes zur Berechnung von Durchschnittstemperaturen. ",
- "1" => "Hilfreiche Hinweise zu DbRep im FHEM-Wiki ."
-);
-
-sub DbRep_Main($$;$);
-sub DbLog_cutCol($$$$$$$); # DbLog-Funktion nutzen um Daten auf maximale Länge beschneiden
-
-my %dbrep_col = ("DEVICE" => 64,
- "TYPE" => 64,
- "EVENT" => 512,
- "READING" => 64,
- "VALUE" => 128,
- "UNIT" => 32
- );
-
-###################################################################################
-# DbRep_Initialize
-###################################################################################
-sub DbRep_Initialize($) {
- my ($hash) = @_;
- $hash->{DefFn} = "DbRep_Define";
- $hash->{UndefFn} = "DbRep_Undef";
- $hash->{ShutdownFn} = "DbRep_Shutdown";
- $hash->{NotifyFn} = "DbRep_Notify";
- $hash->{SetFn} = "DbRep_Set";
- $hash->{GetFn} = "DbRep_Get";
- $hash->{AttrFn} = "DbRep_Attr";
- $hash->{FW_deviceOverview} = 1;
-
- $hash->{AttrList} = "disable:1,0 ".
- "reading ".
- "allowDeletion:1,0 ".
- "averageCalcForm:avgArithmeticMean,avgDailyMeanGWS,avgTimeWeightMean ".
- "countEntriesDetail:1,0 ".
- "device " .
- "dumpComment ".
- "dumpCompress:1,0 ".
- "dumpDirLocal ".
- "dumpDirRemote ".
- "dumpMemlimit ".
- "dumpSpeed ".
- "dumpFilesKeep:0,1,2,3,4,5,6,7,8,9,10 ".
- "executeBeforeProc ".
- "executeAfterProc ".
- "expimpfile ".
- "fetchRoute:ascent,descent ".
- "fetchMarkDuplicates:red,blue,brown,green,orange ".
- "ftpDebug:1,0 ".
- "ftpDir ".
- "ftpDumpFilesKeep:1,2,3,4,5,6,7,8,9,10 ".
- "ftpPassive:1,0 ".
- "ftpPwd ".
- "ftpPort ".
- "ftpServer ".
- "ftpTimeout ".
- "ftpUse:1,0 ".
- "ftpUser ".
- "ftpUseSSL:1,0 ".
- "aggregation:hour,day,week,month,no ".
- "diffAccept ".
- "limit ".
- "optimizeTablesBeforeDump:1,0 ".
- "readingNameMap ".
- "readingPreventFromDel ".
- "role:Client,Agent ".
- "seqDoubletsVariance ".
- "showproctime:1,0 ".
- "showSvrInfo ".
- "showVariables ".
- "showStatus ".
- "showTableInfo ".
- "sqlCmdHistoryLength:0,5,10,15,20,25,30,35,40,45,50 ".
- "sqlResultFormat:separated,mline,sline,table,json ".
- "sqlResultFieldSep:|,:,\/ ".
- "timeYearPeriod ".
- "timestamp_begin ".
- "timestamp_end ".
- "timeDiffToNow ".
- "timeOlderThan ".
- "timeout ".
- "userExitFn ".
- "valueFilter ".
- $readingFnAttributes;
-
- # Umbenennen von existierenden Attrbuten
- # $hash->{AttrRenameMap} = { "reading" => "readingFilter",
- # "device" => "deviceFilter",
- # };
-
-return undef;
-}
-
-###################################################################################
-# DbRep_Define
-###################################################################################
-sub DbRep_Define($@) {
- # define DbRep
- # ($hash) [1] [2]
- #
- my ($hash, $def) = @_;
- my $name = $hash->{NAME};
-
- return "Error: Perl module ".$DbRepMMDBI." is missing. Install it on Debian with: sudo apt-get install libdbi-perl" if($DbRepMMDBI);
-
- my @a = split("[ \t][ \t]*", $def);
-
- if(!$a[2]) {
- return "You need to specify more parameters.\n". "Format: define DbRep ";
- } elsif (!$defs{$a[2]}) {
- return "The specified DbLog-Device \"$a[2]\" doesn't exist.";
- }
-
- $hash->{LASTCMD} = " ";
- $hash->{ROLE} = AttrVal($name, "role", "Client");
- $hash->{MODEL} = $hash->{ROLE};
- $hash->{HELPER}{DBLOGDEVICE} = $a[2];
- $hash->{VERSION} = (reverse sort(keys %DbRep_vNotesIntern))[0];
- $hash->{NOTIFYDEV} = "global,".$name; # nur Events dieser Devices an DbRep_Notify weiterleiten
- my $dbconn = $defs{$a[2]}{dbconn};
- $hash->{DATABASE} = (split(/;|=/, $dbconn))[1];
- $hash->{UTF8} = defined($defs{$a[2]}{UTF8})?$defs{$a[2]}{UTF8}:0;
-
- my ($err,$hl) = DbRep_getCmdFile($name."_sqlCmdList");
- if(!$err) {
- $hash->{HELPER}{SQLHIST} = $hl;
- Log3 ($name, 4, "DbRep $name - history sql commandlist read from file ".$attr{global}{modpath}."/FHEM/FhemUtils/cacheDbRep");
- }
-
- RemoveInternalTimer($hash);
- InternalTimer(gettimeofday()+int(rand(45)), 'DbRep_firstconnect', $hash, 0);
-
- Log3 ($name, 4, "DbRep $name - initialized");
- ReadingsSingleUpdateValue ($hash, 'state', 'initialized', 1);
-
-return undef;
-}
-
-###################################################################################
-# DbRep_Set
-###################################################################################
-sub DbRep_Set($@) {
- my ($hash, @a) = @_;
- return "\"set X\" needs at least an argument" if ( @a < 2 );
- my $name = $a[0];
- my $opt = $a[1];
- my $prop = $a[2];
- my $dbh = $hash->{DBH};
- my $dblogdevice = $hash->{HELPER}{DBLOGDEVICE};
- $hash->{dbloghash} = $defs{$dblogdevice};
- my $dbmodel = $hash->{dbloghash}{MODEL};
- my $dbname = $hash->{DATABASE};
- my $sd ="";
-
- my (@bkps,$dir);
- $dir = AttrVal($name, "dumpDirLocal", "./"); # 'dumpDirRemote' (Backup-Verz. auf dem MySQL-Server) muß gemountet sein und in 'dumpDirLocal' eingetragen sein
- $dir = $dir."/" unless($dir =~ m/\/$/);
-
- opendir(DIR,$dir);
- if ($dbmodel =~ /MYSQL/) {
- $dbname = $hash->{DATABASE};
- $sd = $dbname.".*(csv|sql)";
- } elsif ($dbmodel =~ /SQLITE/) {
- $dbname = $hash->{DATABASE};
- $dbname = (split /[\/]/, $dbname)[-1];
- $dbname = (split /\./, $dbname)[0];
- $sd = $dbname."_.*.sqlitebkp";
- }
- while (my $file = readdir(DIR)) {
- next unless (-f "$dir/$file");
- next unless ($file =~ /^$sd/);
- push @bkps,$file;
- }
- closedir(DIR);
- my $cj = @bkps?join(",",reverse(sort @bkps)):" ";
-
- # Drop-Down Liste bisherige Befehle in "sqlCmd" erstellen
- my $hl = $hash->{HELPER}{SQLHIST}.",___purge_historylist___" if($hash->{HELPER}{SQLHIST});
-
- my $setlist = "Unknown argument $opt, choose one of ".
- "eraseReadings:noArg ".
- (($hash->{ROLE} ne "Agent")?"sumValue:display,writeToDB ":"").
- (($hash->{ROLE} ne "Agent")?"averageValue:display,writeToDB ":"").
- (($hash->{ROLE} ne "Agent")?"changeValue ":"").
- (($hash->{ROLE} ne "Agent")?"delEntries:noArg ":"").
- (($hash->{ROLE} ne "Agent")?"delSeqDoublets:adviceRemain,adviceDelete,delete ":"").
- "deviceRename ".
- (($hash->{ROLE} ne "Agent")?"readingRename ":"").
- (($hash->{ROLE} ne "Agent")?"exportToFile ":"").
- (($hash->{ROLE} ne "Agent")?"importFromFile ":"").
- (($hash->{ROLE} ne "Agent")?"maxValue:display,writeToDB ":"").
- (($hash->{ROLE} ne "Agent")?"minValue:display,writeToDB ":"").
- (($hash->{ROLE} ne "Agent")?"fetchrows:history,current ":"").
- (($hash->{ROLE} ne "Agent")?"diffValue:display,writeToDB ":"").
- (($hash->{ROLE} ne "Agent")?"insert ":"").
- (($hash->{ROLE} ne "Agent")?"reduceLog ":"").
- (($hash->{ROLE} ne "Agent")?"sqlCmd:textField-long ":"").
- (($hash->{ROLE} ne "Agent" && $hl)?"sqlCmdHistory:".$hl." ":"").
- (($hash->{ROLE} ne "Agent")?"sqlSpecial:50mostFreqLogsLast2days,allDevCount,allDevReadCount ":"").
- (($hash->{ROLE} ne "Agent")?"syncStandby ":"").
- (($hash->{ROLE} ne "Agent")?"tableCurrentFillup:noArg ":"").
- (($hash->{ROLE} ne "Agent")?"tableCurrentPurge:noArg ":"").
- (($hash->{ROLE} ne "Agent" && $dbmodel =~ /MYSQL/ )?"dumpMySQL:clientSide,serverSide ":"").
- (($hash->{ROLE} ne "Agent" && $dbmodel =~ /SQLITE/ )?"dumpSQLite:noArg ":"").
- (($hash->{ROLE} ne "Agent" && $dbmodel =~ /SQLITE/ )?"repairSQLite ":"").
- (($hash->{ROLE} ne "Agent" && $dbmodel =~ /MYSQL/ )?"optimizeTables:noArg ":"").
- (($hash->{ROLE} ne "Agent" && $dbmodel =~ /SQLITE|POSTGRESQL/ )?"vacuum:noArg ":"").
- (($hash->{ROLE} ne "Agent" && $dbmodel =~ /MYSQL/)?"restoreMySQL:".$cj." ":"").
- (($hash->{ROLE} ne "Agent" && $dbmodel =~ /SQLITE/)?"restoreSQLite:".$cj." ":"").
- (($hash->{ROLE} ne "Agent")?"countEntries:history,current ":"");
-
- return if(IsDisabled($name));
-
- if ($opt =~ /eraseReadings/) {
- $hash->{LASTCMD} = $prop?"$opt $prop":"$opt";
- # Readings löschen die nicht in der Ausnahmeliste (Attr readingPreventFromDel) stehen
- DbRep_delread($hash);
- return undef;
- }
-
- if ($opt eq "dumpMySQL" && $hash->{ROLE} ne "Agent") {
- $hash->{LASTCMD} = $prop?"$opt $prop":"$opt";
- if ($prop eq "serverSide") {
- Log3 ($name, 3, "DbRep $name - ################################################################");
- Log3 ($name, 3, "DbRep $name - ### New database serverSide dump ###");
- Log3 ($name, 3, "DbRep $name - ################################################################");
- } else {
- Log3 ($name, 3, "DbRep $name - ################################################################");
- Log3 ($name, 3, "DbRep $name - ### New database clientSide dump ###");
- Log3 ($name, 3, "DbRep $name - ################################################################");
- }
- # Befehl vor Procedure ausführen
- DbRep_beforeproc($hash, "dump");
- DbRep_Main($hash,$opt,$prop);
- return undef;
- }
-
- if ($opt eq "dumpSQLite" && $hash->{ROLE} ne "Agent") {
- $hash->{LASTCMD} = $prop?"$opt $prop":"$opt";
- Log3 ($name, 3, "DbRep $name - ################################################################");
- Log3 ($name, 3, "DbRep $name - ### New SQLite dump ###");
- Log3 ($name, 3, "DbRep $name - ################################################################");
- # Befehl vor Procedure ausführen
- DbRep_beforeproc($hash, "dump");
- DbRep_Main($hash,$opt,$prop);
- return undef;
- }
-
- if ($opt eq "repairSQLite" && $hash->{ROLE} ne "Agent") {
- $prop = $prop?$prop:36000;
- if($prop) {
- unless($prop =~ /^(\d+)$/) { return " The Value of $opt is not valid. Use only figures 0-9 without decimal places !";};
- # unless ($aVal =~ /^[0-9]+$/) { return " The Value of $aName is not valid. Use only figures 0-9 without decimal places !";}
- }
- $hash->{LASTCMD} = $prop?"$opt $prop":"$opt";
- Log3 ($name, 3, "DbRep $name - ################################################################");
- Log3 ($name, 3, "DbRep $name - ### New SQLite repair attempt ###");
- Log3 ($name, 3, "DbRep $name - ################################################################");
- Log3 ($name, 3, "DbRep $name - start repair attempt of database ".$hash->{DATABASE});
- # closetime Datenbank
- my $dbloghash = $hash->{dbloghash};
- my $dbl = $dbloghash->{NAME};
- CommandSet(undef,"$dbl reopen $prop");
-
- # Befehl vor Procedure ausführen
- DbRep_beforeproc($hash, "repair");
- DbRep_Main($hash,$opt);
- return undef;
- }
-
- if ($opt =~ /restoreMySQL|restoreSQLite/ && $hash->{ROLE} ne "Agent") {
- $hash->{LASTCMD} = $prop?"$opt $prop":"$opt";
- Log3 ($name, 3, "DbRep $name - ################################################################");
- Log3 ($name, 3, "DbRep $name - ### New database Restore/Recovery ###");
- Log3 ($name, 3, "DbRep $name - ################################################################");
- # Befehl vor Procedure ausführen
- DbRep_beforeproc($hash, "restore");
- DbRep_Main($hash,$opt,$prop);
- return undef;
- }
-
- if ($opt =~ /optimizeTables|vacuum/ && $hash->{ROLE} ne "Agent") {
- $hash->{LASTCMD} = $prop?"$opt $prop":"$opt";
- Log3 ($name, 3, "DbRep $name - ################################################################");
- Log3 ($name, 3, "DbRep $name - ### New optimize table / vacuum execution ###");
- Log3 ($name, 3, "DbRep $name - ################################################################");
- # Befehl vor Procedure ausführen
- DbRep_beforeproc($hash, "optimize");
- DbRep_Main($hash,$opt);
- return undef;
- }
-
- if ($opt =~ m/delSeqDoublets/ && $hash->{ROLE} ne "Agent") {
- $hash->{LASTCMD} = $prop?"$opt $prop":"$opt";
- if ($prop =~ /delete/ && !AttrVal($hash->{NAME}, "allowDeletion", 0)) {
- return " Set attribute 'allowDeletion' if you want to allow deletion of any database entries. Use it with care !";
- }
- DbRep_beforeproc($hash, "delSeq");
- DbRep_Main($hash,$opt,$prop);
- return undef;
- }
-
- if ($opt =~ m/reduceLog/ && $hash->{ROLE} ne "Agent") {
- if ($hash->{HELPER}{RUNNING_REDUCELOG} && $hash->{HELPER}{RUNNING_REDUCELOG}{pid} !~ m/DEAD/) {
- return "reduceLog already in progress. Please wait for the current process to finish.";
- } else {
- delete $hash->{HELPER}{RUNNING_REDUCELOG};
- my @b = @a;
- shift(@b);
- $hash->{LASTCMD} = join(" ",@b);
- $hash->{HELPER}{REDUCELOG} = \@a;
- Log3 ($name, 3, "DbRep $name - ################################################################");
- Log3 ($name, 3, "DbRep $name - ### new reduceLog run ###");
- Log3 ($name, 3, "DbRep $name - ################################################################");
- # Befehl vor Procedure ausführen
- DbRep_beforeproc($hash, "reduceLog");
- DbRep_Main($hash,$opt);
- return undef;
- }
- }
-
- if ($hash->{HELPER}{RUNNING_BACKUP_CLIENT}) {
- $setlist = "Unknown argument $opt, choose one of ".
- (($hash->{ROLE} ne "Agent")?"cancelDump:noArg ":"");
- }
-
- if ($hash->{HELPER}{RUNNING_REPAIR}) {
- $setlist = "Unknown argument $opt, choose one of ".
- (($hash->{ROLE} ne "Agent")?"cancelRepair:noArg ":"");
- }
-
- if ($hash->{HELPER}{RUNNING_RESTORE}) {
- $setlist = "Unknown argument $opt, choose one of ".
- (($hash->{ROLE} ne "Agent")?"cancelRestore:noArg ":"");
- }
-
- if ($opt eq "cancelDump" && $hash->{ROLE} ne "Agent") {
- $hash->{LASTCMD} = $prop?"$opt $prop":"$opt";
- BlockingKill($hash->{HELPER}{RUNNING_BACKUP_CLIENT});
- Log3 ($name, 3, "DbRep $name -> running Dump has been canceled");
- ReadingsSingleUpdateValue ($hash, "state", "Dump canceled", 1);
- return undef;
- }
-
- if ($opt eq "cancelRepair" && $hash->{ROLE} ne "Agent") {
- $hash->{LASTCMD} = $prop?"$opt $prop":"$opt";
- BlockingKill($hash->{HELPER}{RUNNING_REPAIR});
- Log3 ($name, 3, "DbRep $name -> running Repair has been canceled");
- ReadingsSingleUpdateValue ($hash, "state", "Repair canceled", 1);
- return undef;
- }
-
- if ($opt eq "cancelRestore" && $hash->{ROLE} ne "Agent") {
- $hash->{LASTCMD} = $prop?"$opt $prop":"$opt";
- BlockingKill($hash->{HELPER}{RUNNING_RESTORE});
- Log3 ($name, 3, "DbRep $name -> running Restore has been canceled");
- ReadingsSingleUpdateValue ($hash, "state", "Restore canceled", 1);
- return undef;
- }
-
- #######################################################################################################
- ## keine Aktionen außer die über diesem Eintrag solange Reopen xxxx im DbLog-Device läuft
- #######################################################################################################
- if ($hash->{dbloghash}{HELPER}{REOPEN_RUNS} && $opt !~ /\?/) {
- my $ro = $hash->{dbloghash}{HELPER}{REOPEN_RUNS_UNTIL};
- Log3 ($name, 3, "DbRep $name - connection $dblogdevice to db $dbname is closed until $ro - $opt postponed");
- ReadingsSingleUpdateValue ($hash, "state", "connection $dblogdevice to $dbname is closed until $ro - $opt postponed", 1);
- return;
- }
- #######################################################################################################
-
- if ($opt =~ /countEntries/ && $hash->{ROLE} ne "Agent") {
- $hash->{LASTCMD} = $prop?"$opt $prop":"$opt";
- my $table = $prop?$prop:"history";
- DbRep_Main($hash,$opt,$table);
-
- } elsif ($opt =~ /fetchrows/ && $hash->{ROLE} ne "Agent") {
- $hash->{LASTCMD} = $prop?"$opt $prop":"$opt";
- my $table = $prop?$prop:"history";
- DbRep_Main($hash,$opt,$table);
-
- } elsif ($opt =~ m/(max|min|sum|average|diff)Value/ && $hash->{ROLE} ne "Agent") {
- $hash->{LASTCMD} = $prop?"$opt $prop":"$opt";
- if (!AttrVal($hash->{NAME}, "reading", "")) {
- return " The attribute reading to analyze is not set !";
- }
- if ($prop && $prop =~ /writeToDB/) {
- if (!AttrVal($hash->{NAME}, "device", "") || AttrVal($hash->{NAME}, "device", "") =~ /[%*:=,]/ || AttrVal($hash->{NAME}, "reading", "") =~ /[,\s]/) {
- return "If you want write results back to database, attributes \"device\" and \"reading\" must be set.devspec and mustn't contain SQL-Wildcard (%).,' ";}
-
- unless ($i_date =~ /(\d{4})-(\d{2})-(\d{2})/) {return "Input for date is not valid. Use format YYYY-MM-DD !";}
- unless ($i_time =~ /(\d{2}):(\d{2}):(\d{2})/) {return "Input for time is not valid. Use format HH:MM:SS !";}
- my $i_timestamp = $i_date." ".$i_time;
- my ($yyyy, $mm, $dd, $hh, $min, $sec) = ($i_timestamp =~ /(\d+)-(\d+)-(\d+) (\d+):(\d+):(\d+)/);
-
- eval { my $ts = timelocal($sec, $min, $hh, $dd, $mm-1, $yyyy-1900); };
-
- if ($@) {
- my @l = split (/at/, $@);
- return " Timestamp is out of range - $l[0]";
- }
-
- my $i_device = AttrVal($hash->{NAME}, "device", "");
- my $i_reading = AttrVal($hash->{NAME}, "reading", "");
-
- # Daten auf maximale Länge (entsprechend der Feldlänge in DbLog DB create-scripts) beschneiden wenn nicht SQLite
- if ($dbmodel ne 'SQLITE') {
- $i_device = substr($i_device,0, $dbrep_col{DEVICE});
- $i_reading = substr($i_reading,0, $dbrep_col{READING});
- $i_value = substr($i_value,0, $dbrep_col{VALUE});
- $i_unit = substr($i_unit,0, $dbrep_col{UNIT}) if($i_unit);
- }
-
- $hash->{HELPER}{I_TIMESTAMP} = $i_timestamp;
- $hash->{HELPER}{I_DEVICE} = $i_device;
- $hash->{HELPER}{I_READING} = $i_reading;
- $hash->{HELPER}{I_VALUE} = $i_value;
- $hash->{HELPER}{I_UNIT} = $i_unit;
- $hash->{HELPER}{I_TYPE} = my $i_type = "manual";
- $hash->{HELPER}{I_EVENT} = my $i_event = "manual";
-
- } else {
- return "Data to insert to table 'history' are needed like this pattern: 'Date,Time,Value,[Unit]'. \"Unit\" is optional. Spaces are not allowed !";
- }
- DbRep_Main($hash,$opt);
-
- } elsif ($opt eq "exportToFile" && $hash->{ROLE} ne "Agent") {
- $hash->{LASTCMD} = $prop?"$opt $prop":"$opt";
- my $f = $prop if($prop);
- if (!AttrVal($hash->{NAME}, "expimpfile", "") && !$f) {
- return "\"$opt\" needs a file as an argument or the attribute \"expimpfile\" (path and filename) to be set !";
- }
- DbRep_Main($hash,$opt,$f);
-
- } elsif ($opt eq "importFromFile" && $hash->{ROLE} ne "Agent") {
- $hash->{LASTCMD} = $prop?"$opt $prop":"$opt";
- my $f = $prop if($prop);
- if (!AttrVal($hash->{NAME}, "expimpfile", "") && !$f) {
- return "\"$opt\" needs a file as an argument or the attribute \"expimpfile\" (path and filename) to be set !";
- }
- DbRep_Main($hash,$opt,$f);
-
- } elsif ($opt =~ /sqlCmd|sqlSpecial|sqlCmdHistory/) {
- return "\"set $opt\" needs at least an argument" if ( @a < 3 );
- # remove arg 0, 1 to get SQL command
- my $sqlcmd;
- if($opt eq "sqlSpecial") {
- $sqlcmd = $prop;
- }
- if($opt eq "sqlCmd") {
- my @cmd = @a;
- shift @cmd; shift @cmd;
- $sqlcmd = join(" ", @cmd);
- $sqlcmd =~ tr/ A-Za-z0-9!"#$§%&'()*+,-.\/:;<=>?@[\\]^_`{|}~äöüÄÖÜ߀/ /cs;
- }
- if($opt eq "sqlCmdHistory") {
- $prop =~ tr/ A-Za-z0-9!"#$%&'()*+,-.\/:;<=>?@[\\]^_`{|}~äöüÄÖÜ߀/ /cs;
- $prop =~ s//,/g;
- $sqlcmd = $prop;
- if($sqlcmd eq "___purge_historylist___") {
- delete($hash->{HELPER}{SQLHIST});
- DbRep_setCmdFile($name."_sqlCmdList","",$hash); # Löschen der sql History Liste im DbRep-Keyfile
- return "SQL command historylist of $name deleted.";
- }
- }
- $hash->{LASTCMD} = $sqlcmd?"$opt $sqlcmd":"$opt";
- if ($sqlcmd =~ m/^\s*delete/is && !AttrVal($hash->{NAME}, "allowDeletion", undef)) {
- return "Attribute 'allowDeletion = 1' is needed for command '$sqlcmd'. Use it with care !";
- }
- DbRep_Main($hash,$opt,$sqlcmd);
-
- } elsif ($opt =~ /changeValue/) {
- shift @a;
- shift @a;
- $prop = join(" ", @a);
- $hash->{LASTCMD} = $prop?"$opt $prop":"$opt";
- unless($prop =~ m/^\s*(".*",".*")\s*$/) {return "Both entries \"old string\", \"new string\" are needed. Use \"set $name changeValue \"old string\",\"new string\" (use quotes)";}
- my $complex = 0;
- my ($oldval,$newval) = ($prop =~ /^\s*"(.*?)","(.*?)"\s*$/);
-
- if($newval =~ m/[{}]/) {
- if($newval =~ m/^\s*(\{.*\})\s*$/s) {
- $newval = $1;
- $complex = 1;
- my %specials = (
- "%VALUE" => $name,
- "%UNIT" => $name,
- );
- $newval = EvalSpecials($newval, %specials);
- } else {
- return "The expression of \"new string\" has to be included in \"{ }\" ";
- }
- }
- $hash->{HELPER}{COMPLEX} = $complex;
- $hash->{HELPER}{OLDVAL} = $oldval;
- $hash->{HELPER}{NEWVAL} = $newval;
- $hash->{HELPER}{RENMODE} = "changeval";
- DbRep_beforeproc($hash, "changeval");
- DbRep_Main($hash,$opt);
-
- } elsif ($opt =~ m/syncStandby/ && $hash->{ROLE} ne "Agent") {
- unless($prop) {return "A DbLog-device (standby) is needed to sync. Use \"set $name syncStandby \" ";}
- if(!exists($defs{$prop}) || $defs{$prop}->{TYPE} ne "DbLog") {
- return "The device \"$prop\" doesn't exist or is not a DbLog-device. ";
- }
- $hash->{LASTCMD} = $prop?"$opt $prop":"$opt";
- DbRep_Main($hash,$opt,$prop);
-
- } else {
- return "$setlist";
- }
-
-return undef;
-}
-
-###################################################################################
-# DbRep_Get
-###################################################################################
-sub DbRep_Get($@) {
- my ($hash, @a) = @_;
- return "\"get X\" needs at least an argument" if ( @a < 2 );
- my $name = $a[0];
- my $opt = $a[1];
- my $prop = $a[2];
- my $dbh = $hash->{DBH};
- my $dblogdevice = $hash->{HELPER}{DBLOGDEVICE};
- $hash->{dbloghash} = $defs{$dblogdevice};
- my $dbmodel = $hash->{dbloghash}{MODEL};
- my $dbname = $hash->{DATABASE};
- my $to = AttrVal($name, "timeout", "86400");
-
- my $getlist = "Unknown argument $opt, choose one of ".
- "svrinfo:noArg ".
- "blockinginfo:noArg ".
- "minTimestamp:noArg ".
- "dbValue:textField-long ".
- (($dbmodel eq "MYSQL")?"dbstatus:noArg ":"").
- (($dbmodel eq "MYSQL")?"tableinfo:noArg ":"").
- (($dbmodel eq "MYSQL")?"procinfo:noArg ":"").
- (($dbmodel eq "MYSQL")?"dbvars:noArg ":"").
- "versionNotes "
- ;
-
- return if(IsDisabled($name));
-
- if ($hash->{dbloghash}{HELPER}{REOPEN_RUNS} && $opt !~ /\?|procinfo|blockinginfo/) {
- my $ro = $hash->{dbloghash}{HELPER}{REOPEN_RUNS_UNTIL};
- Log3 ($name, 3, "DbRep $name - connection $dblogdevice to db $dbname is closed until $ro - $opt postponed");
- ReadingsSingleUpdateValue ($hash, "state", "connection $dblogdevice to $dbname is closed until $ro - $opt postponed", 1);
- return;
- }
-
- if ($opt =~ /dbvars|dbstatus|tableinfo|procinfo/) {
- return "Dump is running - try again later !" if($hash->{HELPER}{RUNNING_BACKUP_CLIENT});
- $hash->{LASTCMD} = $prop?"$opt $prop":"$opt";
- return "The operation \"$opt\" isn't available with database type $dbmodel" if ($dbmodel ne 'MYSQL');
- ReadingsSingleUpdateValue ($hash, "state", "running", 1);
- DbRep_delread($hash); # Readings löschen die nicht in der Ausnahmeliste (Attr readingPreventFromDel) stehen
- $hash->{HELPER}{RUNNING_PID} = BlockingCall("dbmeta_DoParse", "$name|$opt", "dbmeta_ParseDone", $to, "DbRep_ParseAborted", $hash);
-
- } elsif ($opt eq "svrinfo") {
- return "Dump is running - try again later !" if($hash->{HELPER}{RUNNING_BACKUP_CLIENT});
- $hash->{LASTCMD} = $prop?"$opt $prop":"$opt";
- DbRep_delread($hash);
- ReadingsSingleUpdateValue ($hash, "state", "running", 1);
- $hash->{HELPER}{RUNNING_PID} = BlockingCall("dbmeta_DoParse", "$name|$opt", "dbmeta_ParseDone", $to, "DbRep_ParseAborted", $hash);
-
- } elsif ($opt eq "blockinginfo") {
- return "Dump is running - try again later !" if($hash->{HELPER}{RUNNING_BACKUP_CLIENT});
- $hash->{LASTCMD} = $prop?"$opt $prop":"$opt";
- DbRep_delread($hash);
- ReadingsSingleUpdateValue ($hash, "state", "running", 1);
- DbRep_getblockinginfo($hash);
-
- } elsif ($opt eq "minTimestamp") {
- return "Dump is running - try again later !" if($hash->{HELPER}{RUNNING_BACKUP_CLIENT});
- $hash->{LASTCMD} = $prop?"$opt $prop":"$opt";
- DbRep_delread($hash);
- ReadingsSingleUpdateValue ($hash, "state", "running", 1);
- DbRep_firstconnect($hash);
-
- } elsif ($opt =~ /dbValue/) {
- return "get \"$opt\" needs at least an argument" if ( @a < 3 );
- # remove arg 0, 1 to get SQL command
- my @cmd = @a;
- shift @cmd; shift @cmd;
- my $sqlcmd = join(" ",@cmd);
- $sqlcmd =~ tr/ A-Za-z0-9!"#$§%&'()*+,-.\/:;<=>?@[\\]^_`{|}~äöüÄÖÜ߀/ /cs;
- $hash->{LASTCMD} = $sqlcmd?"$opt $sqlcmd":"$opt";
- if ($sqlcmd =~ m/^\s*delete/is && !AttrVal($hash->{NAME}, "allowDeletion", undef)) {
- return "Attribute 'allowDeletion = 1' is needed for command '$sqlcmd'. Use it with care !";
- }
- my ($err,$ret) = DbRep_dbValue($name,$sqlcmd);
- return $err?$err:$ret;
-
- } elsif ($opt =~ /versionNotes/) {
- my $header = "Module release information Helpful hints $header1
");
- $ret .= "
";
- $ret .= "";
- $ret .= "";
- if($prop && $prop =~ /[\d]+/) {
- if(AttrVal("global","language","EN") eq "DE") {
- %hs = ( $prop => $DbRep_vHintsExt_de{$prop} );
- } else {
- %hs = ( $prop => $DbRep_vHintsExt_en{$prop} );
- }
- } else {
- if(AttrVal("global","language","EN") eq "DE") {
- %hs = %DbRep_vHintsExt_de;
- } else {
- %hs = %DbRep_vHintsExt_en;
- }
- }
- $i = 0;
- foreach my $key (reverse sort(keys %hs)) {
- $val0 = $hs{$key};
- $ret .= sprintf("$key $val0 " );
- $ret .= " ";
- $i++;
- if ($i & 1) {
- # $i ist ungerade
- $ret .= "";
- } else {
- $ret .= " ";
- }
- }
- $ret .= " ";
- $ret .= " ";
- $ret .= "
";
- $ret .= "
$header
");
- $ret .= "
";
- $ret .= "";
- $ret .= "";
- $i = 0;
- foreach my $key (reverse sort(keys %DbRep_vNotesExtern)) {
- ($val0,$val1) = split(/\s/,$DbRep_vNotesExtern{$key},2);
- $ret .= sprintf("$key $val0 $val1 " );
- $ret .= " ";
- $i++;
- if ($i & 1) {
- # $i ist ungerade
- $ret .= "";
- } else {
- $ret .= " ";
- }
- }
- $ret .= " ";
- $ret .= " ";
- $ret .= "
";
- $ret .= "
[reading:value]\" ";}
- my @a = split(/ /,$aVal,2);
- $hash->{HELPER}{USEREXITFN} = $a[0];
- $hash->{HELPER}{UEFN_REGEXP} = $a[1] if($a[1]);
- } else {
- delete $hash->{HELPER}{USEREXITFN} if($hash->{HELPER}{USEREXITFN});
- delete $hash->{HELPER}{UEFN_REGEXP} if($hash->{HELPER}{UEFN_REGEXP});
- }
- }
-
- if ($aName eq "role") {
- if($cmd eq "set") {
- if ($aVal eq "Agent") {
- # check ob bereits ein Agent für die angeschlossene Datenbank existiert -> DbRep-Device kann dann keine Agent-Rolle einnehmen
- foreach(devspec2array("TYPE=DbRep")) {
- my $devname = $_;
- next if($devname eq $name);
- my $devrole = $defs{$_}{ROLE};
- my $devdb = $defs{$_}{DATABASE};
- if ($devrole eq "Agent" && $devdb eq $hash->{DATABASE}) { return "There is already an Agent device: $devname defined for database $hash->{DATABASE} !"; }
- }
- # nicht erlaubte Attribute löschen falls gesetzt
- foreach (@agentnoattr) {
- delete($attr{$name}{$_});
- }
- $attr{$name}{icon} = "security";
- }
- $do = $aVal;
- } else {
- $do = "Client";
- }
- $hash->{ROLE} = $do;
- $hash->{MODEL} = $hash->{ROLE};
- delete($attr{$name}{icon}) if($do eq "Client");
- }
-
- if ($cmd eq "set") {
- if ($aName =~ /valueFilter/) {
- eval { "Hallo" =~ m/$aVal/ };
- return "Bad regexp: $@" if($@);
- }
-
- if ($aName =~ /seqDoubletsVariance/) {
- unless (looks_like_number($aVal)) { return " The Value of $aName is not valid. Only figures are allowed !";}
- }
-
- if ($aName eq "timeYearPeriod") {
- # 06-01 02-28
- unless ($aVal =~ /^(\d{2})-(\d{2}) (\d{2})-(\d{2})$/ )
- { return "The Value of \"$aName\" isn't valid. Set the account period as \"MM-DD MM-DD\".";}
- my ($mm1, $dd1, $mm2, $dd2) = ($aVal =~ /^(\d{2})-(\d{2}) (\d{2})-(\d{2})$/);
- my (undef,undef,undef,$mday,$mon,$year1,undef,undef,undef) = localtime(time); # Istzeit Ableitung
- my $year2 = $year1;
- # a b c d
- # 06-01 02-28 , wenn c < a && $mon < a -> Jahr(a)-1, sonst Jahr(c)+1
- my $c = ($mon+1).$mday;
- my $e = $mm2.$dd2;
- if ($mm2 <= $mm1 && $c <= $e) {
- $year1--;
- } else {
- $year2++;
- }
- eval { my $t1 = timelocal(00, 00, 00, $dd1, $mm1-1, $year1-1900);
- my $t2 = timelocal(00, 00, 00, $dd2, $mm2-1, $year2-1900); };
- if ($@) {
- my @l = split (/at/, $@);
- return " The Value of $aName is out of range - $l[0]";
- }
- delete($attr{$name}{timestamp_begin}) if ($attr{$name}{timestamp_begin});
- delete($attr{$name}{timestamp_end}) if ($attr{$name}{timestamp_end});
- delete($attr{$name}{timeDiffToNow}) if ($attr{$name}{timeDiffToNow});
- delete($attr{$name}{timeOlderThan}) if ($attr{$name}{timeOlderThan});
- return undef;
- }
- if ($aName eq "timestamp_begin" || $aName eq "timestamp_end") {
- my ($a,$b,$c) = split('_',$aVal);
- if ($a =~ /^current$|^previous$/ && $b =~ /^hour$|^day$|^week$|^month$|^year$/ && $c =~ /^begin$|^end$/) {
- delete($attr{$name}{timeDiffToNow}) if ($attr{$name}{timeDiffToNow});
- delete($attr{$name}{timeOlderThan}) if ($attr{$name}{timeOlderThan});
- delete($attr{$name}{timeYearPeriod}) if ($attr{$name}{timeYearPeriod});
- return undef;
- }
- $aVal = DbRep_formatpicker($aVal);
- unless ($aVal =~ /^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})$/)
- {return " The Value of $aName is not valid. Use format YYYY-MM-DD HH:MM:SS or one of \"current_[year|month|day|hour]_begin\",\"current_[year|month|day|hour]_end\", \"previous_[year|month|day|hour]_begin\", \"previous_[year|month|day|hour]_end\" !";}
-
- my ($yyyy, $mm, $dd, $hh, $min, $sec) = ($aVal =~ /(\d+)-(\d+)-(\d+) (\d+):(\d+):(\d+)/);
-
- eval { my $epoch_seconds_begin = timelocal($sec, $min, $hh, $dd, $mm-1, $yyyy-1900); };
-
- if ($@) {
- my @l = split (/at/, $@);
- return " The Value of $aName is out of range - $l[0]";
- }
- delete($attr{$name}{timeDiffToNow}) if ($attr{$name}{timeDiffToNow});
- delete($attr{$name}{timeOlderThan}) if ($attr{$name}{timeOlderThan});
- delete($attr{$name}{timeYearPeriod}) if ($attr{$name}{timeYearPeriod});
- }
- if ($aName =~ /ftpTimeout|timeout|diffAccept/) {
- unless ($aVal =~ /^[0-9]+$/) { return " The Value of $aName is not valid. Use only figures 0-9 without decimal places !";}
- }
- if ($aName eq "readingNameMap") {
- unless ($aVal =~ m/^[A-Za-z\d_\.-]+$/) { return " Unsupported character in $aName found. Use only A-Z a-z _ . -";}
- }
- if ($aName eq "timeDiffToNow") {
- unless ($aVal =~ /^[0-9]+$/ || $aVal =~ /^\s*[ydhms]:([\d]+)\s*/ && $aVal !~ /.*,.*/ )
- { return "The Value of \"$aName\" isn't valid. Set simple seconds like \"86400\" or use form like \"y:1 d:10 h:6 m:12 s:20\". Refer to commandref !";}
- delete($attr{$name}{timestamp_begin}) if ($attr{$name}{timestamp_begin});
- delete($attr{$name}{timestamp_end}) if ($attr{$name}{timestamp_end});
- delete($attr{$name}{timeYearPeriod}) if ($attr{$name}{timeYearPeriod});
- }
- if ($aName eq "timeOlderThan") {
- unless ($aVal =~ /^[0-9]+$/ || $aVal =~ /^\s*[ydhms]:([\d]+)\s*/ && $aVal !~ /.*,.*/ )
- { return "The Value of \"$aName\" isn't valid. Set simple seconds like \"86400\" or use form like \"y:1 d:10 h:6 m:12 s:20\". Refer to commandref !";}
- delete($attr{$name}{timestamp_begin}) if ($attr{$name}{timestamp_begin});
- delete($attr{$name}{timestamp_end}) if ($attr{$name}{timestamp_end});
- delete($attr{$name}{timeYearPeriod}) if ($attr{$name}{timeYearPeriod});
- }
- if ($aName eq "dumpMemlimit" || $aName eq "dumpSpeed") {
- unless ($aVal =~ /^[0-9]+$/) { return "The Value of $aName is not valid. Use only figures 0-9 without decimal places.";}
- my $dml = AttrVal($name, "dumpMemlimit", 100000);
- my $ds = AttrVal($name, "dumpSpeed", 10000);
- if($aName eq "dumpMemlimit") {
- unless($aVal >= (10 * $ds)) {return "The Value of $aName has to be at least '10 x dumpSpeed' ! ";}
- }
- if($aName eq "dumpSpeed") {
- unless($aVal <= ($dml / 10)) {return "The Value of $aName mustn't be greater than 'dumpMemlimit / 10' ! ";}
- }
- }
- if ($aName eq "ftpUse") {
- delete($attr{$name}{ftpUseSSL});
- }
- if ($aName eq "ftpUseSSL") {
- delete($attr{$name}{ftpUse});
- }
- if ($aName eq "reading" || $aName eq "device") {
- if ($dbmodel && $dbmodel ne 'SQLITE') {
- my $attrname = uc($aName);
- if ($dbmodel eq 'POSTGRESQL' && $aVal !~ m/,/) {
- return "Length of \"$aName\" is too big. Maximum length for database type $dbmodel is $dbrep_col{$attrname}" if(length($aVal) > $dbrep_col{$attrname});
- } elsif ($dbmodel eq 'MYSQL' && $aVal !~ m/,/) {
- return "Length of \"$aName\" is too big. Maximum length for database type $dbmodel is $dbrep_col{$attrname}" if(length($aVal) > $dbrep_col{$attrname});
- }
- }
- }
-
- }
-return undef;
-}
-
-###################################################################################
-# DbRep_Notify Eventverarbeitung
-###################################################################################
-sub DbRep_Notify($$) {
- # Es werden nur die Events von Geräten verarbeitet die im Hash $hash->{NOTIFYDEV} gelistet sind (wenn definiert).
- # Dadurch kann die Menge der Events verringert werden. In sub DbRep_Define angeben.
- # Beispiele:
- # $hash->{NOTIFYDEV} = "global";
- # $hash->{NOTIFYDEV} = "global,Definition_A,Definition_B";
-
- my ($own_hash, $dev_hash) = @_;
- my $myName = $own_hash->{NAME}; # Name des eigenen Devices
- my $devName = $dev_hash->{NAME}; # Device welches Events erzeugt hat
-
- return if(IsDisabled($myName)); # Return if the module is disabled
-
- my $events = deviceEvents($dev_hash,0);
- return if(!$events);
-
- foreach my $event (@{$events}) {
- $event = "" if(!defined($event));
- my @evl = split("[ \t][ \t]*", $event);
-
-# if ($devName = $myName && $evl[0] =~ /done/) {
-# InternalTimer(time+1, "browser_refresh", $own_hash, 0);
-# }
-
- if ($own_hash->{ROLE} eq "Agent") {
- # wenn Rolle "Agent" Verbeitung von RENAMED Events
- next if ($event !~ /RENAMED/);
-
- my $strucChanged;
- # altes in neues device in der DEF des angeschlossenen DbLog-device ändern (neues device loggen)
- my $dblog_name = $own_hash->{dbloghash}{NAME}; # Name des an den DbRep-Agenten angeschlossenen DbLog-Dev
- my $dblog_hash = $defs{$dblog_name};
-
- if ( $dblog_hash->{DEF} =~ m/( |\(|\|)$evl[1]( |\)|\||:)/ ) {
- $dblog_hash->{DEF} =~ s/$evl[1]/$evl[2]/;
- $dblog_hash->{REGEXP} =~ s/$evl[1]/$evl[2]/;
- # Definitionsänderung wurde vorgenommen
- $strucChanged = 1;
- Log3 ($myName, 3, "DbRep Agent $myName - $dblog_name substituted in DEF, old: \"$evl[1]\", new: \"$evl[2]\" ");
- }
-
- # DEVICE innerhalb angeschlossener Datenbank umbenennen
- Log3 ($myName, 4, "DbRep Agent $myName - Evt RENAMED rec - old device: $evl[1], new device: $evl[2] -> start deviceRename in DB: $own_hash->{DATABASE} ");
- $own_hash->{HELPER}{OLDDEV} = $evl[1];
- $own_hash->{HELPER}{NEWDEV} = $evl[2];
- $own_hash->{HELPER}{RENMODE} = "devren";
- DbRep_Main($own_hash,"deviceRename");
-
- # die Attribute "device" in allen DbRep-Devices mit der Datenbank = DB des Agenten von alten Device in neues Device ändern
- foreach(devspec2array("TYPE=DbRep")) {
- my $repname = $_;
- next if($_ eq $myName);
- my $repattrdevice = $attr{$_}{device};
- next if(!$repattrdevice);
- my $repdb = $defs{$_}{DATABASE};
- if ($repattrdevice eq $evl[1] && $repdb eq $own_hash->{DATABASE}) {
- $attr{$_}{device} = $evl[2];
- # Definitionsänderung wurde vorgenommen
- $strucChanged = 1;
- Log3 ($myName, 3, "DbRep Agent $myName - $_ attr device changed, old: \"$evl[1]\", new: \"$evl[2]\" ");
- }
- }
- # if ($strucChanged) {CommandSave("","")};
- }
- }
-return;
-}
-
-###################################################################################
-# DbRep_Undef
-###################################################################################
-sub DbRep_Undef($$) {
- my ($hash, $arg) = @_;
-
- RemoveInternalTimer($hash);
-
- my $dbh = $hash->{DBH};
- $dbh->disconnect() if(defined($dbh));
-
- BlockingKill($hash->{HELPER}{RUNNING_PID}) if (exists($hash->{HELPER}{RUNNING_PID}));
- BlockingKill($hash->{HELPER}{RUNNING_BACKUP_CLIENT}) if (exists($hash->{HELPER}{RUNNING_BACKUP_CLIENT}));
- BlockingKill($hash->{HELPER}{RUNNING_RESTORE}) if (exists($hash->{HELPER}{RUNNING_RESTORE}));
- BlockingKill($hash->{HELPER}{RUNNING_BCKPREST_SERVER}) if (exists($hash->{HELPER}{RUNNING_BCKPREST_SERVER}));
- BlockingKill($hash->{HELPER}{RUNNING_OPTIMIZE}) if (exists($hash->{HELPER}{RUNNING_OPTIMIZE}));
- BlockingKill($hash->{HELPER}{RUNNING_REPAIR}) if (exists($hash->{HELPER}{RUNNING_REPAIR}));
-
- DbRep_delread($hash,1);
-
-return undef;
-}
-
-###################################################################################
-# DbRep_Shutdown
-###################################################################################
-sub DbRep_Shutdown($) {
- my ($hash) = @_;
-
- my $dbh = $hash->{DBH};
- $dbh->disconnect() if(defined($dbh));
- DbRep_delread($hash,1);
- RemoveInternalTimer($hash);
-
-return undef;
-}
-
-###################################################################################
-# First Init DB Connect
-# Verbindung zur DB aufbauen und den Timestamp des ältesten
-# Datensatzes ermitteln
-###################################################################################
-sub DbRep_firstconnect($) {
- my ($hash) = @_;
- my $name = $hash->{NAME};
- my $to = "120";
- my $dbloghash = $hash->{dbloghash};
- my $dbconn = $dbloghash->{dbconn};
- my $dbuser = $dbloghash->{dbuser};
-
- RemoveInternalTimer($hash, "DbRep_firstconnect");
- return if(IsDisabled($name));
- if ($init_done == 1) {
- Log3 ($name, 3, "DbRep $name - Connectiontest to database $dbconn with user $dbuser") if($hash->{LASTCMD} ne "minTimestamp");
- $hash->{HELPER}{RUNNING_PID} = BlockingCall("DbRep_getMinTs", "$name", "DbRep_getMinTsDone", $to, "DbRep_getMinTsAborted", $hash);
- $hash->{HELPER}{RUNNING_PID}{loglevel} = 5 if($hash->{HELPER}{RUNNING_PID}); # Forum #77057
- } else {
- InternalTimer(time+1, "DbRep_firstconnect", $hash, 0);
- }
-
-return;
-}
-
-####################################################################################################
-# den ältesten Datensatz (Timestamp) in der DB bestimmen
-####################################################################################################
-sub DbRep_getMinTs($) {
- my ($name) = @_;
- my $hash = $defs{$name};
- my $dbloghash = $hash->{dbloghash};
- my $dbconn = $dbloghash->{dbconn};
- my $dbuser = $dbloghash->{dbuser};
- my $dblogname = $dbloghash->{NAME};
- my $dbpassword = $attr{"sec$dblogname"}{secret};
- my $mintsdef = "1970-01-01 01:00:00";
- my ($dbh,$sql,$err,$mints);
-
- # Background-Startzeit
- my $bst = [gettimeofday];
-
- eval { $dbh = DBI->connect("dbi:$dbconn", $dbuser, $dbpassword, { PrintError => 0, RaiseError => 1, AutoInactiveDestroy => 1 }); };
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- return "$name|''|''|$err";
- }
-
- # SQL-Startzeit
- my $st = [gettimeofday];
-
- eval { $mints = $dbh->selectrow_array("SELECT min(TIMESTAMP) FROM history;"); };
- # eval { $mints = $dbh->selectrow_array("select TIMESTAMP from history limit 1;"); };
- # eval { $mints = $dbh->selectrow_array("select TIMESTAMP from history order by TIMESTAMP limit 1;"); };
-
- $dbh->disconnect;
-
- # SQL-Laufzeit ermitteln
- my $rt = tv_interval($st);
-
- $mints = $mints?encode_base64($mints,""):encode_base64($mintsdef,"");
-
- # Background-Laufzeit ermitteln
- my $brt = tv_interval($bst);
-
- $rt = $rt.",".$brt;
-
- return "$name|$mints|$rt|0";
-}
-
-####################################################################################################
-# Auswertungsroutine den ältesten Datensatz (Timestamp) in der DB bestimmen
-####################################################################################################
-sub DbRep_getMinTsDone($) {
- my ($string) = @_;
- my @a = split("\\|",$string);
- my $hash = $defs{$a[0]};
- my $name = $hash->{NAME};
- my $mints = decode_base64($a[1]);
- my $bt = $a[2];
- my ($rt,$brt) = split(",", $bt);
- my $err = $a[3]?decode_base64($a[3]):undef;
- my $dblogdevice = $hash->{HELPER}{DBLOGDEVICE};
- $hash->{dbloghash} = $defs{$dblogdevice};
- my $dbconn = $hash->{dbloghash}{dbconn};
-
- if ($err) {
- readingsBeginUpdate($hash);
- ReadingsBulkUpdateValue ($hash, "errortext", $err);
- ReadingsBulkUpdateValue ($hash, "state", "disconnected");
- readingsEndUpdate($hash, 1);
- delete($hash->{HELPER}{RUNNING_PID});
- Log3 ($name, 2, "DbRep $name - DB connect failed. Make sure credentials of database $hash->{DATABASE} are valid and database is reachable.");
- return;
- }
-
- my $state = ($hash->{LASTCMD} eq "minTimestamp")?"done":"connected";
- $state = "invalid timestamp \"$mints\" found in database - please delete it" if($mints =~ /^0000-00-00.*$/);
-
- readingsBeginUpdate($hash);
- ReadingsBulkUpdateValue ($hash, "timestamp_oldest_dataset", $mints) if($hash->{LASTCMD} eq "minTimestamp");
- ReadingsBulkUpdateTimeState($hash,$brt,$rt,$state);
- readingsEndUpdate($hash, 1);
-
- Log3 ($name, 4, "DbRep $name - Connectiontest to db $dbconn successful") if($hash->{LASTCMD} ne "minTimestamp");
-
- $hash->{HELPER}{MINTS} = $mints;
-
- delete($hash->{HELPER}{RUNNING_PID});
-
-return;
-}
-
-####################################################################################################
-# Abbruchroutine den ältesten Datensatz (Timestamp) in der DB bestimmen
-####################################################################################################
-sub DbRep_getMinTsAborted(@) {
- my ($hash,$cause) = @_;
- my $name = $hash->{NAME};
-
- $cause = $cause?$cause:"Timeout: process terminated";
- Log3 ($name, 1, "DbRep $name -> BlockingCall $hash->{HELPER}{RUNNING_PID}{fn} pid:$hash->{HELPER}{RUNNING_PID}{pid} $cause");
-
- readingsBeginUpdate($hash);
- ReadingsBulkUpdateValue ($hash, "errortext", $cause);
- ReadingsBulkUpdateValue ($hash, "state", "disconnected");
- readingsEndUpdate($hash, 1);
-
- delete($hash->{HELPER}{RUNNING_PID});
-return;
-}
-
-################################################################################################################
-# Hauptroutine
-################################################################################################################
-sub DbRep_Main($$;$) {
- my ($hash,$opt,$prop) = @_;
- my $name = $hash->{NAME};
- my $to = AttrVal($name, "timeout", "86400");
- my $reading = AttrVal($name, "reading", "%");
- my $device = AttrVal($name, "device", "%");
- my $dbloghash = $hash->{dbloghash};
- my $dbmodel = $dbloghash->{MODEL};
-
- # Entkommentieren für Testroutine im Vordergrund
- # testexit($hash);
-
- return if( ($hash->{HELPER}{RUNNING_BACKUP_CLIENT} ||
- $hash->{HELPER}{RUNNING_BCKPREST_SERVER} ||
- $hash->{HELPER}{RUNNING_RESTORE} ||
- $hash->{HELPER}{RUNNING_REPAIR} ||
- $hash->{HELPER}{RUNNING_REDUCELOG} ||
- $hash->{HELPER}{RUNNING_OPTIMIZE}) &&
- $opt !~ /dumpMySQL|restoreMySQL|dumpSQLite|restoreSQLite|optimizeTables|vacuum|repairSQLite/ );
-
- # Readings löschen die nicht in der Ausnahmeliste (Attr readingPreventFromDel) stehen
- DbRep_delread($hash);
-
- if ($opt =~ /dumpMySQL|dumpSQLite/) {
- BlockingKill($hash->{HELPER}{RUNNING_BACKUP_CLIENT}) if (exists($hash->{HELPER}{RUNNING_BACKUP_CLIENT}));
- BlockingKill($hash->{HELPER}{RUNNING_BCKPREST_SERVER}) if (exists($hash->{HELPER}{RUNNING_BCKPREST_SERVER}));
- BlockingKill($hash->{HELPER}{RUNNING_OPTIMIZE}) if (exists($hash->{HELPER}{RUNNING_OPTIMIZE}));
-
- if($dbmodel =~ /MYSQL/) {
- if ($prop eq "serverSide") {
- $hash->{HELPER}{RUNNING_BCKPREST_SERVER} = BlockingCall("mysql_DoDumpServerSide", "$name", "DbRep_DumpDone", $to, "DbRep_DumpAborted", $hash);
- ReadingsSingleUpdateValue ($hash, "state", "serverSide Dump is running - be patient and see Logfile !", 1);
- } else {
- $hash->{HELPER}{RUNNING_BACKUP_CLIENT} = BlockingCall("mysql_DoDumpClientSide", "$name", "DbRep_DumpDone", $to, "DbRep_DumpAborted", $hash);
- ReadingsSingleUpdateValue ($hash, "state", "clientSide Dump is running - be patient and see Logfile !", 1);
- }
- }
- if($dbmodel =~ /SQLITE/) {
- $hash->{HELPER}{RUNNING_BACKUP_CLIENT} = BlockingCall("DbRep_sqliteDoDump", "$name", "DbRep_DumpDone", $to, "DbRep_DumpAborted", $hash);
- ReadingsSingleUpdateValue ($hash, "state", "SQLite Dump is running - be patient and see Logfile !", 1);
- }
- return;
- }
-
- if ($opt =~ /restoreMySQL/) {
- BlockingKill($hash->{HELPER}{RUNNING_RESTORE}) if (exists($hash->{HELPER}{RUNNING_RESTORE}));
- BlockingKill($hash->{HELPER}{RUNNING_OPTIMIZE}) if (exists($hash->{HELPER}{RUNNING_OPTIMIZE}));
-
- if($prop =~ /csv/) {
- $hash->{HELPER}{RUNNING_RESTORE} = BlockingCall("mysql_RestoreServerSide", "$name|$prop", "DbRep_restoreDone", $to, "DbRep_restoreAborted", $hash);
- } elsif ($prop =~ /sql/) {
- $hash->{HELPER}{RUNNING_RESTORE} = BlockingCall("mysql_RestoreClientSide", "$name|$prop", "DbRep_restoreDone", $to, "DbRep_restoreAborted", $hash);
- } else {
- ReadingsSingleUpdateValue ($hash, "state", "restore database error - unknown fileextension \"$prop\"", 1);
- }
-
- ReadingsSingleUpdateValue ($hash, "state", "restore database is running - be patient and see Logfile !", 1);
- return;
- }
-
- if ($opt =~ /restoreSQLite/) {
- BlockingKill($hash->{HELPER}{RUNNING_RESTORE}) if (exists($hash->{HELPER}{RUNNING_RESTORE}));
- BlockingKill($hash->{HELPER}{RUNNING_OPTIMIZE}) if (exists($hash->{HELPER}{RUNNING_OPTIMIZE}));
- $hash->{HELPER}{RUNNING_RESTORE} = BlockingCall("DbRep_sqliteRestore", "$name|$prop", "DbRep_restoreDone", $to, "DbRep_restoreAborted", $hash);
- ReadingsSingleUpdateValue ($hash, "state", "restore database is running - be patient and see Logfile !", 1);
- return;
- }
-
- if ($opt =~ /optimizeTables|vacuum/) {
- BlockingKill($hash->{HELPER}{RUNNING_OPTIMIZE}) if (exists($hash->{HELPER}{RUNNING_OPTIMIZE}));
- BlockingKill($hash->{HELPER}{RUNNING_RESTORE}) if (exists($hash->{HELPER}{RUNNING_RESTORE}));
- $hash->{HELPER}{RUNNING_OPTIMIZE} = BlockingCall("DbRep_optimizeTables", "$name", "DbRep_OptimizeDone", $to, "DbRep_OptimizeAborted", $hash);
- ReadingsSingleUpdateValue ($hash, "state", "optimize tables is running - be patient and see Logfile !", 1);
- return;
- }
-
- if ($opt =~ /repairSQLite/) {
- BlockingKill($hash->{HELPER}{RUNNING_BACKUP_CLIENT}) if (exists($hash->{HELPER}{RUNNING_BACKUP_CLIENT}));
- BlockingKill($hash->{HELPER}{RUNNING_OPTIMIZE}) if (exists($hash->{HELPER}{RUNNING_OPTIMIZE}));
- BlockingKill($hash->{HELPER}{RUNNING_REPAIR}) if (exists($hash->{HELPER}{RUNNING_REPAIR}));
- $hash->{HELPER}{RUNNING_REPAIR} = BlockingCall("DbRep_sqliteRepair", "$name", "DbRep_RepairDone", $to, "DbRep_RepairAborted", $hash);
- ReadingsSingleUpdateValue ($hash, "state", "repair database is running - be patient and see Logfile !", 1);
- return;
- }
-
- if (exists($hash->{HELPER}{RUNNING_PID}) && $hash->{ROLE} ne "Agent") {
- Log3 ($name, 3, "DbRep $name - WARNING - old process $hash->{HELPER}{RUNNING_PID}{pid} will be killed now to start a new BlockingCall");
- BlockingKill($hash->{HELPER}{RUNNING_PID});
- }
-
- ReadingsSingleUpdateValue ($hash, "state", "running", 1);
-
- # only for this block because of warnings if details of readings are not set
- no warnings 'uninitialized';
-
- # Ausgaben und Zeitmanipulationen
- Log3 ($name, 4, "DbRep $name - -------- New selection --------- ");
- Log3 ($name, 4, "DbRep $name - Command: $opt $prop");
-
- # zentrales Timestamp-Array und Zeitgrenzen bereitstellen
- my ($epoch_seconds_begin,$epoch_seconds_end,$runtime_string_first,$runtime_string_next);
- my $ts = "no_aggregation"; # Dummy für eine Select-Schleife wenn != $IsTimeSet || $IsAggrSet
- my ($IsTimeSet,$IsAggrSet,$aggregation) = DbRep_checktimeaggr($hash);
- if($IsTimeSet || $IsAggrSet) {
- ($epoch_seconds_begin,$epoch_seconds_end,$runtime_string_first,$runtime_string_next,$ts) = DbRep_createTimeArray($hash,$aggregation,$opt);
- } else {
- Log3 ($name, 4, "DbRep $name - Timestamp begin human readable: not set") if($opt !~ /tableCurrentPurge/);
- Log3 ($name, 4, "DbRep $name - Timestamp end human readable: not set") if($opt !~ /tableCurrentPurge/);
- }
-
- Log3 ($name, 4, "DbRep $name - Aggregation: $aggregation") if($opt !~ /tableCurrentPurge|tableCurrentFillup|fetchrows|insert|reduceLog/);
-
- ##### Funktionsaufrufe #####
- if ($opt eq "sumValue") {
- $hash->{HELPER}{RUNNING_PID} = BlockingCall("sumval_DoParse", "$name§$device§$reading§$prop§$ts", "sumval_ParseDone", $to, "DbRep_ParseAborted", $hash);
-
- } elsif ($opt =~ m/countEntries/) {
- my $table = $prop;
- $hash->{HELPER}{RUNNING_PID} = BlockingCall("count_DoParse", "$name§$table§$device§$reading§$ts", "count_ParseDone", $to, "DbRep_ParseAborted", $hash);
-
- } elsif ($opt eq "averageValue") {
- Log3 ($name, 4, "DbRep $name - averageValue calculation sceme: ".AttrVal($name,"averageCalcForm","avgArithmeticMean"));
- $hash->{HELPER}{RUNNING_PID} = BlockingCall("averval_DoParse", "$name§$device§$reading§$prop§$ts", "averval_ParseDone", $to, "DbRep_ParseAborted", $hash);
-
- } elsif ($opt eq "fetchrows") {
- my $table = $prop;
- $hash->{HELPER}{RUNNING_PID} = BlockingCall("fetchrows_DoParse", "$name|$table|$device|$reading|$runtime_string_first|$runtime_string_next", "fetchrows_ParseDone", $to, "DbRep_ParseAborted", $hash);
-
- } elsif ($opt =~ /delSeqDoublets/) {
- my $cmd = $prop?$prop:"adviceRemain";
- $hash->{HELPER}{RUNNING_PID} = BlockingCall("delseqdoubl_DoParse", "$name§$cmd§$device§$reading§$ts", "delseqdoubl_ParseDone", $to, "DbRep_ParseAborted", $hash);
-
- } elsif ($opt eq "exportToFile") {
- my $file = $prop;
- DbRep_beforeproc($hash, "export");
- $hash->{HELPER}{RUNNING_PID} = BlockingCall("expfile_DoParse", "$name§$device§$reading§$runtime_string_first§$file§$ts", "expfile_ParseDone", $to, "DbRep_ParseAborted", $hash);
-
- } elsif ($opt eq "importFromFile") {
- my $file = $prop;
- DbRep_beforeproc($hash, "import");
- $hash->{HELPER}{RUNNING_PID} = BlockingCall("impfile_Push", "$name|$runtime_string_first|$file", "impfile_PushDone", $to, "DbRep_ParseAborted", $hash);
-
- } elsif ($opt eq "maxValue") {
- $hash->{HELPER}{RUNNING_PID} = BlockingCall("maxval_DoParse", "$name§$device§$reading§$prop§$ts", "maxval_ParseDone", $to, "DbRep_ParseAborted", $hash);
-
- } elsif ($opt eq "minValue") {
- $hash->{HELPER}{RUNNING_PID} = BlockingCall("minval_DoParse", "$name§$device§$reading§$prop§$ts", "minval_ParseDone", $to, "DbRep_ParseAborted", $hash);
-
- } elsif ($opt eq "delEntries") {
- $hash->{HELPER}{RUNNING_PID} = BlockingCall("del_DoParse", "$name|history|$device|$reading|$runtime_string_first|$runtime_string_next", "del_ParseDone", $to, "DbRep_ParseAborted", $hash);
-
- } elsif ($opt eq "tableCurrentPurge") {
- undef $runtime_string_first;
- undef $runtime_string_next;
- $hash->{HELPER}{RUNNING_PID} = BlockingCall("del_DoParse", "$name|current|$device|$reading|$runtime_string_first|$runtime_string_next", "del_ParseDone", $to, "DbRep_ParseAborted", $hash);
-
- } elsif ($opt eq "tableCurrentFillup") {
- $hash->{HELPER}{RUNNING_PID} = BlockingCall("currentfillup_Push", "$name|$device|$reading|$runtime_string_first|$runtime_string_next", "currentfillup_Done", $to, "DbRep_ParseAborted", $hash);
-
- } elsif ($opt eq "diffValue") {
- $hash->{HELPER}{RUNNING_PID} = BlockingCall("diffval_DoParse", "$name§$device§$reading§$prop§$ts", "diffval_ParseDone", $to, "DbRep_ParseAborted", $hash);
-
- } elsif ($opt eq "insert") {
- $hash->{HELPER}{RUNNING_PID} = BlockingCall("insert_Push", "$name", "insert_Done", $to, "DbRep_ParseAborted", $hash);
-
- } elsif ($opt =~ /deviceRename|readingRename/) {
- $hash->{HELPER}{RUNNING_PID} = BlockingCall("change_Push", "$name|$device|$reading|$runtime_string_first|$runtime_string_next", "change_Done", $to, "DbRep_ParseAborted", $hash);
-
- } elsif ($opt =~ /changeValue/) {
- $hash->{HELPER}{RUNNING_PID} = BlockingCall("changeval_Push", "$name§$device§$reading§$runtime_string_first§$runtime_string_next§$ts", "change_Done", $to, "DbRep_ParseAborted", $hash);
-
- } elsif ($opt =~ /sqlCmd|sqlSpecial/ ) {
- # Execute a generic sql command or special sql
- if ($opt =~ /sqlSpecial/) {
- if($prop eq "50mostFreqLogsLast2days") {
- $prop = "select Device, reading, count(0) AS `countA` from history where ( TIMESTAMP > (now() - interval 2 day)) group by DEVICE, READING order by countA desc, DEVICE limit 50;" if($dbmodel =~ /MYSQL/);
- $prop = "select Device, reading, count(0) AS `countA` from history where ( TIMESTAMP > ('now' - '2 days')) group by DEVICE, READING order by countA desc, DEVICE limit 50;" if($dbmodel =~ /SQLITE/);
- $prop = "select Device, reading, count(0) AS countA from history where ( TIMESTAMP > (NOW() - INTERVAL '2' DAY)) group by DEVICE, READING order by countA desc, DEVICE limit 50;" if($dbmodel =~ /POSTGRESQL/);
- } elsif ($prop eq "allDevReadCount") {
- $prop = "select device, reading, count(*) from history group by DEVICE, READING;";
- } elsif ($prop eq "allDevCount") {
- $prop = "select device, count(*) from history group by DEVICE;";
- }
- }
- $hash->{HELPER}{RUNNING_PID} = BlockingCall("sqlCmd_DoParse", "$name|$opt|$runtime_string_first|$runtime_string_next|$prop", "sqlCmd_ParseDone", $to, "DbRep_ParseAborted", $hash);
-
- } elsif ($opt =~ /syncStandby/ ) {
- # Befehl vor Procedure ausführen
- DbRep_beforeproc($hash, "syncStandby");
- $hash->{HELPER}{RUNNING_PID} = BlockingCall("DbRep_syncStandby", "$name§$device§$reading§$runtime_string_first§$runtime_string_next§$ts§$prop", "DbRep_syncStandbyDone", $to, "DbRep_ParseAborted", $hash);
- }
-
- if ($opt =~ /reduceLog/) {
- $hash->{HELPER}{RUNNING_REDUCELOG} = BlockingCall("DbRep_reduceLog", "$name|$runtime_string_first|$runtime_string_next", "DbRep_reduceLogDone", $to, "DbRep_reduceLogAborted", $hash);
- ReadingsSingleUpdateValue ($hash, "state", "reduceLog database is running - be patient and see Logfile !", 1);
- $hash->{HELPER}{RUNNING_REDUCELOG}{loglevel} = 5 if($hash->{HELPER}{RUNNING_REDUCELOG}); # Forum #77057
- return;
- }
-
-$hash->{HELPER}{RUNNING_PID}{loglevel} = 5 if($hash->{HELPER}{RUNNING_PID}); # Forum #77057
-return;
-}
-
-################################################################################################################
-# Create zentrales Timsstamp-Array
-################################################################################################################
-sub DbRep_createTimeArray($$$) {
- my ($hash,$aggregation,$opt) = @_;
- my $name = $hash->{NAME};
-
- # year als Jahre seit 1900
- # $mon als 0..11
- # $time = timelocal( $sec, $min, $hour, $mday, $mon, $year );
- my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime(time); # Istzeit Ableitung
- my ($tsbegin,$tsend,$dim,$tsub,$tadd);
- my ($rsec,$rmin,$rhour,$rmday,$rmon,$ryear);
-
-
- # absolute Auswertungszeiträume statische und dynamische (Beginn / Ende) berechnen
- if($hash->{HELPER}{MINTS} && $hash->{HELPER}{MINTS} =~ m/0000-00-00/) {
- Log3 ($name, 1, "DbRep $name - ERROR - wrong timestamp \"$hash->{HELPER}{MINTS}\" found in database. Please delete it !");
- delete $hash->{HELPER}{MINTS};
- }
-
- my $mints = $hash->{HELPER}{MINTS}?$hash->{HELPER}{MINTS}:"1970-01-01 01:00:00"; # Timestamp des 1. Datensatzes verwenden falls ermittelt
- $tsbegin = AttrVal($name, "timestamp_begin", $mints);
- $tsbegin = DbRep_formatpicker($tsbegin);
- $tsend = AttrVal($name, "timestamp_end", strftime "%Y-%m-%d %H:%M:%S", localtime(time));
- $tsend = DbRep_formatpicker($tsend);
-
- if ( my $tap = AttrVal($name, "timeYearPeriod", undef)) {
- # a b c d
- # 06-01 02-28 , wenn c < a && $mon < a -> Jahr(a)-1, sonst Jahr(c)+1
- my $ybp = $year+1900;
- my $yep = $year+1900;
- $tap =~ qr/^(\d{2})-(\d{2}) (\d{2})-(\d{2})$/p;
- my $mbp = $1;
- my $dbp = $2;
- my $mep = $3;
- my $dep = $4;
- my $c = ($mon+1).$mday;
- my $e = $mep.$dep;
- if ($mep <= $mbp && $c <= $e) {
- $ybp--;
- } else {
- $yep++;
- }
- $tsbegin = "$ybp-$mbp-$dbp 00:00:00";
- $tsend = "$yep-$mep-$dep 23:59:59";
- }
-
- if (AttrVal($name,"timestamp_begin","") eq "current_year_begin" ||
- AttrVal($name,"timestamp_end","") eq "current_year_begin") {
- $tsbegin = strftime "%Y-%m-%d %T",localtime(timelocal(0,0,0,1,0,$year)) if(AttrVal($name,"timestamp_begin","") eq "current_year_begin");
- $tsend = strftime "%Y-%m-%d %T",localtime(timelocal(0,0,0,1,0,$year)) if(AttrVal($name,"timestamp_end","") eq "current_year_begin");
- }
-
- if (AttrVal($name, "timestamp_begin", "") eq "current_year_end" ||
- AttrVal($name, "timestamp_end", "") eq "current_year_end") {
- $tsbegin = strftime "%Y-%m-%d %T",localtime(timelocal(59,59,23,31,11,$year)) if(AttrVal($name,"timestamp_begin","") eq "current_year_end");
- $tsend = strftime "%Y-%m-%d %T",localtime(timelocal(59,59,23,31,11,$year)) if(AttrVal($name,"timestamp_end","") eq "current_year_end");
- }
-
- if (AttrVal($name, "timestamp_begin", "") eq "previous_year_begin" ||
- AttrVal($name, "timestamp_end", "") eq "previous_year_begin") {
- $tsbegin = strftime "%Y-%m-%d %T",localtime(timelocal(0,0,0,1,0,$year-1)) if(AttrVal($name, "timestamp_begin", "") eq "previous_year_begin");
- $tsend = strftime "%Y-%m-%d %T",localtime(timelocal(0,0,0,1,0,$year-1)) if(AttrVal($name, "timestamp_end", "") eq "previous_year_begin");
- }
-
- if (AttrVal($name, "timestamp_begin", "") eq "previous_year_end" ||
- AttrVal($name, "timestamp_end", "") eq "previous_year_end") {
- $tsbegin = strftime "%Y-%m-%d %T",localtime(timelocal(59,59,23,31,11,$year-1)) if(AttrVal($name, "timestamp_begin", "") eq "previous_year_end");
- $tsend = strftime "%Y-%m-%d %T",localtime(timelocal(59,59,23,31,11,$year-1)) if(AttrVal($name, "timestamp_end", "") eq "previous_year_end");
- }
-
- if (AttrVal($name, "timestamp_begin", "") eq "current_month_begin" ||
- AttrVal($name, "timestamp_end", "") eq "current_month_begin") {
- $tsbegin = strftime "%Y-%m-%d %T",localtime(timelocal(0,0,0,1,$mon,$year)) if(AttrVal($name, "timestamp_begin", "") eq "current_month_begin");
- $tsend = strftime "%Y-%m-%d %T",localtime(timelocal(0,0,0,1,$mon,$year)) if(AttrVal($name, "timestamp_end", "") eq "current_month_begin");
- }
-
- if (AttrVal($name, "timestamp_begin", "") eq "current_month_end" ||
- AttrVal($name, "timestamp_end", "") eq "current_month_end") {
- $dim = $mon-1?30+(($mon+1)*3%7<4):28+!($year%4||$year%400*!($year%100));
- $tsbegin = strftime "%Y-%m-%d %T",localtime(timelocal(59,59,23,$dim,$mon,$year)) if(AttrVal($name, "timestamp_begin", "") eq "current_month_end");
- $tsend = strftime "%Y-%m-%d %T",localtime(timelocal(59,59,23,$dim,$mon,$year)) if(AttrVal($name, "timestamp_end", "") eq "current_month_end");
- }
-
- if (AttrVal($name, "timestamp_begin", "") eq "previous_month_begin" ||
- AttrVal($name, "timestamp_end", "") eq "previous_month_begin") {
- $ryear = ($mon-1<0)?$year-1:$year;
- $rmon = ($mon-1<0)?11:$mon-1;
- $tsbegin = strftime "%Y-%m-%d %T",localtime(timelocal(0,0,0,1,$rmon,$ryear)) if(AttrVal($name, "timestamp_begin", "") eq "previous_month_begin");
- $tsend = strftime "%Y-%m-%d %T",localtime(timelocal(0,0,0,1,$rmon,$ryear)) if(AttrVal($name, "timestamp_end", "") eq "previous_month_begin");
- }
-
- if (AttrVal($name, "timestamp_begin", "") eq "previous_month_end" ||
- AttrVal($name, "timestamp_end", "") eq "previous_month_end") {
- $ryear = ($mon-1<0)?$year-1:$year;
- $rmon = ($mon-1<0)?11:$mon-1;
- $dim = $rmon-1?30+(($rmon+1)*3%7<4):28+!($ryear%4||$ryear%400*!($ryear%100));
- $tsbegin = strftime "%Y-%m-%d %T",localtime(timelocal(59,59,23,$dim,$rmon,$ryear)) if(AttrVal($name, "timestamp_begin", "") eq "previous_month_end");
- $tsend = strftime "%Y-%m-%d %T",localtime(timelocal(59,59,23,$dim,$rmon,$ryear)) if(AttrVal($name, "timestamp_end", "") eq "previous_month_end");
- }
-
- if (AttrVal($name, "timestamp_begin", "") eq "current_week_begin" ||
- AttrVal($name, "timestamp_end", "") eq "current_week_begin") {
- $tsub = 0 if($wday == 1); # wenn Start am "Mo" keine Korrektur
- $tsub = 86400 if($wday == 2); # wenn Start am "Di" dann Korrektur -1 Tage
- $tsub = 172800 if($wday == 3); # wenn Start am "Mi" dann Korrektur -2 Tage
- $tsub = 259200 if($wday == 4); # wenn Start am "Do" dann Korrektur -3 Tage
- $tsub = 345600 if($wday == 5); # wenn Start am "Fr" dann Korrektur -4 Tage
- $tsub = 432000 if($wday == 6); # wenn Start am "Sa" dann Korrektur -5 Tage
- $tsub = 518400 if($wday == 0); # wenn Start am "So" dann Korrektur -6 Tage
- ($rsec,$rmin,$rhour,$rmday,$rmon,$ryear) = localtime(time-$tsub);
- $tsbegin = strftime "%Y-%m-%d %T",localtime(timelocal(0,0,0,$rmday,$rmon,$ryear)) if(AttrVal($name, "timestamp_begin", "") eq "current_week_begin");
- $tsend = strftime "%Y-%m-%d %T",localtime(timelocal(0,0,0,$rmday,$rmon,$ryear)) if(AttrVal($name, "timestamp_end", "") eq "current_week_begin");
- }
-
- if (AttrVal($name, "timestamp_begin", "") eq "current_week_end" ||
- AttrVal($name, "timestamp_end", "") eq "current_week_end") {
- $tadd = 518400 if($wday == 1); # wenn Start am "Mo" dann Korrektur +6 Tage
- $tadd = 432000 if($wday == 2); # wenn Start am "Di" dann Korrektur +5 Tage
- $tadd = 345600 if($wday == 3); # wenn Start am "Mi" dann Korrektur +4 Tage
- $tadd = 259200 if($wday == 4); # wenn Start am "Do" dann Korrektur +3 Tage
- $tadd = 172800 if($wday == 5); # wenn Start am "Fr" dann Korrektur +2 Tage
- $tadd = 86400 if($wday == 6); # wenn Start am "Sa" dann Korrektur +1 Tage
- $tadd = 0 if($wday == 0); # wenn Start am "So" keine Korrektur
- ($rsec,$rmin,$rhour,$rmday,$rmon,$ryear) = localtime(time+$tadd);
- $tsbegin = strftime "%Y-%m-%d %T",localtime(timelocal(59,59,23,$rmday,$rmon,$ryear)) if(AttrVal($name, "timestamp_begin", "") eq "current_week_end");
- $tsend = strftime "%Y-%m-%d %T",localtime(timelocal(59,59,23,$rmday,$rmon,$ryear)) if(AttrVal($name, "timestamp_end", "") eq "current_week_end");
- }
-
- if (AttrVal($name, "timestamp_begin", "") eq "previous_week_begin" ||
- AttrVal($name, "timestamp_end", "") eq "previous_week_begin") {
- $tsub = 604800 if($wday == 1); # wenn Start am "Mo" dann Korrektur -7 Tage
- $tsub = 691200 if($wday == 2); # wenn Start am "Di" dann Korrektur -8 Tage
- $tsub = 777600 if($wday == 3); # wenn Start am "Mi" dann Korrektur -9 Tage
- $tsub = 864000 if($wday == 4); # wenn Start am "Do" dann Korrektur -10 Tage
- $tsub = 950400 if($wday == 5); # wenn Start am "Fr" dann Korrektur -11 Tage
- $tsub = 1036800 if($wday == 6); # wenn Start am "Sa" dann Korrektur -12 Tage
- $tsub = 1123200 if($wday == 0); # wenn Start am "So" dann Korrektur -13 Tage
- ($rsec,$rmin,$rhour,$rmday,$rmon,$ryear) = localtime(time-$tsub);
- $tsbegin = strftime "%Y-%m-%d %T",localtime(timelocal(0,0,0,$rmday,$rmon,$ryear)) if(AttrVal($name, "timestamp_begin", "") eq "previous_week_begin");
- $tsend = strftime "%Y-%m-%d %T",localtime(timelocal(0,0,0,$rmday,$rmon,$ryear)) if(AttrVal($name, "timestamp_end", "") eq "previous_week_begin");
- }
-
- if (AttrVal($name, "timestamp_begin", "") eq "previous_week_end" ||
- AttrVal($name, "timestamp_end", "") eq "previous_week_end") {
- $tsub = 86400 if($wday == 1); # wenn Start am "Mo" dann Korrektur -1 Tage
- $tsub = 172800 if($wday == 2); # wenn Start am "Di" dann Korrektur -2 Tage
- $tsub = 259200 if($wday == 3); # wenn Start am "Mi" dann Korrektur -3 Tage
- $tsub = 345600 if($wday == 4); # wenn Start am "Do" dann Korrektur -4 Tage
- $tsub = 432000 if($wday == 5); # wenn Start am "Fr" dann Korrektur -5 Tage
- $tsub = 518400 if($wday == 6); # wenn Start am "Sa" dann Korrektur -6 Tage
- $tsub = 604800 if($wday == 0); # wenn Start am "So" dann Korrektur -7 Tage
- ($rsec,$rmin,$rhour,$rmday,$rmon,$ryear) = localtime(time-$tsub);
- $tsbegin = strftime "%Y-%m-%d %T",localtime(timelocal(59,59,23,$rmday,$rmon,$ryear)) if(AttrVal($name, "timestamp_begin", "") eq "previous_week_end");
- $tsend = strftime "%Y-%m-%d %T",localtime(timelocal(59,59,23,$rmday,$rmon,$ryear)) if(AttrVal($name, "timestamp_end", "") eq "previous_week_end");
- }
-
- if (AttrVal($name, "timestamp_begin", "") eq "current_day_begin" ||
- AttrVal($name, "timestamp_end", "") eq "current_day_begin") {
- $tsbegin = strftime "%Y-%m-%d %T",localtime(timelocal(0,0,0,$mday,$mon,$year)) if(AttrVal($name, "timestamp_begin", "") eq "current_day_begin");
- $tsend = strftime "%Y-%m-%d %T",localtime(timelocal(0,0,0,$mday,$mon,$year)) if(AttrVal($name, "timestamp_end", "") eq "current_day_begin");
- }
-
- if (AttrVal($name, "timestamp_begin", "") eq "current_day_end" ||
- AttrVal($name, "timestamp_end", "") eq "current_day_end") {
- $tsbegin = strftime "%Y-%m-%d %T",localtime(timelocal(59,59,23,$mday,$mon,$year)) if(AttrVal($name, "timestamp_begin", "") eq "current_day_end");
- $tsend = strftime "%Y-%m-%d %T",localtime(timelocal(59,59,23,$mday,$mon,$year)) if(AttrVal($name, "timestamp_end", "") eq "current_day_end");
- }
-
- if (AttrVal($name, "timestamp_begin", "") eq "previous_day_begin" ||
- AttrVal($name, "timestamp_end", "") eq "previous_day_begin") {
- $rmday = $mday-1;
- $rmon = $mon;
- $ryear = $year;
- if($rmday<1) {
- $rmon--;
- if ($rmon<0) {
- $rmon=11;
- $ryear--;
- }
- $rmday = $rmon-1?30+(($rmon+1)*3%7<4):28+!($ryear%4||$ryear%400*!($ryear%100)); # Achtung: Monat als 1...12 (statt 0...11)
- }
- $tsbegin = strftime "%Y-%m-%d %T",localtime(timelocal(0,0,0,$rmday,$rmon,$ryear)) if(AttrVal($name, "timestamp_begin", "") eq "previous_day_begin");
- $tsend = strftime "%Y-%m-%d %T",localtime(timelocal(0,0,0,$rmday,$rmon,$ryear)) if(AttrVal($name, "timestamp_end", "") eq "previous_day_begin");
- }
-
- if (AttrVal($name, "timestamp_begin", "") eq "previous_day_end" ||
- AttrVal($name, "timestamp_end", "") eq "previous_day_end") {
- $rmday = $mday-1;
- $rmon = $mon;
- $ryear = $year;
- if($rmday<1) {
- $rmon--;
- if ($rmon<0) {
- $rmon=11;
- $ryear--;
- }
- $rmday = $rmon-1?30+(($rmon+1)*3%7<4):28+!($ryear%4||$ryear%400*!($ryear%100)); # Achtung: Monat als 1...12 (statt 0...11)
- }
- $tsbegin = strftime "%Y-%m-%d %T",localtime(timelocal(59,59,23,$rmday,$rmon,$ryear)) if(AttrVal($name, "timestamp_begin", "") eq "previous_day_end");
- $tsend = strftime "%Y-%m-%d %T",localtime(timelocal(59,59,23,$rmday,$rmon,$ryear)) if(AttrVal($name, "timestamp_end", "") eq "previous_day_end");
- }
-
- if (AttrVal($name, "timestamp_begin", "") eq "current_hour_begin" ||
- AttrVal($name, "timestamp_end", "") eq "current_hour_begin") {
- $tsbegin = strftime "%Y-%m-%d %T",localtime(timelocal(0,0,$hour,$mday,$mon,$year)) if(AttrVal($name, "timestamp_begin", "") eq "current_hour_begin");
- $tsend = strftime "%Y-%m-%d %T",localtime(timelocal(0,0,$hour,$mday,$mon,$year)) if(AttrVal($name, "timestamp_end", "") eq "current_hour_begin");
- }
-
- if (AttrVal($name, "timestamp_begin", "") eq "current_hour_end" ||
- AttrVal($name, "timestamp_end", "") eq "current_hour_end") {
- $tsbegin = strftime "%Y-%m-%d %T",localtime(timelocal(59,59,$hour,$mday,$mon,$year)) if(AttrVal($name, "timestamp_begin", "") eq "current_hour_end");
- $tsend = strftime "%Y-%m-%d %T",localtime(timelocal(59,59,$hour,$mday,$mon,$year)) if(AttrVal($name, "timestamp_end", "") eq "current_hour_end");
- }
-
- if (AttrVal($name, "timestamp_begin", "") eq "previous_hour_begin" ||
- AttrVal($name, "timestamp_end", "") eq "previous_hour_begin") {
- $rhour = $hour-1;
- $rmday = $mday;
- $rmon = $mon;
- $ryear = $year;
- if($rhour<0) {
- $rhour = 23;
- $rmday = $mday-1;
- if($rmday<1) {
- $rmon--;
- if ($rmon<0) {
- $rmon=11;
- $ryear--;
- }
- $rmday = $rmon-1?30+(($rmon+1)*3%7<4):28+!($ryear%4||$ryear%400*!($ryear%100)); # Achtung: Monat als 1...12 (statt 0...11)
- }
- }
- $tsbegin = strftime "%Y-%m-%d %T",localtime(timelocal(0,0,$rhour,$rmday,$rmon,$ryear)) if(AttrVal($name, "timestamp_begin", "") eq "previous_hour_begin");
- $tsend = strftime "%Y-%m-%d %T",localtime(timelocal(0,0,$rhour,$rmday,$rmon,$ryear)) if(AttrVal($name, "timestamp_end", "") eq "previous_hour_begin");
- }
-
- if (AttrVal($name, "timestamp_begin", "") eq "previous_hour_end" ||
- AttrVal($name, "timestamp_end", "") eq "previous_hour_end") {
- $rhour = $hour-1;
- $rmday = $mday;
- $rmon = $mon;
- $ryear = $year;
- if($rhour<0) {
- $rhour = 23;
- $rmday = $mday-1;
- if($rmday<1) {
- $rmon--;
- if ($rmon<0) {
- $rmon=11;
- $ryear--;
- }
- $rmday = $rmon-1?30+(($rmon+1)*3%7<4):28+!($ryear%4||$ryear%400*!($ryear%100)); # Achtung: Monat als 1...12 (statt 0...11)
- }
- }
- $tsbegin = strftime "%Y-%m-%d %T",localtime(timelocal(59,59,$rhour,$rmday,$rmon,$ryear)) if(AttrVal($name, "timestamp_begin", "") eq "previous_hour_end");
- $tsend = strftime "%Y-%m-%d %T",localtime(timelocal(59,59,$rhour,$rmday,$rmon,$ryear)) if(AttrVal($name, "timestamp_end", "") eq "previous_hour_end");
- }
-
- # extrahieren der Einzelwerte von Datum/Zeit Beginn
- my ($yyyy1, $mm1, $dd1, $hh1, $min1, $sec1) = ($tsbegin =~ /(\d+)-(\d+)-(\d+) (\d+):(\d+):(\d+)/);
- # extrahieren der Einzelwerte von Datum/Zeit Ende
- my ($yyyy2, $mm2, $dd2, $hh2, $min2, $sec2) = ($tsend =~ /(\d+)-(\d+)-(\d+) (\d+):(\d+):(\d+)/);
-
-
- # relative Auswertungszeit Beginn berücksichtigen # Umwandeln in Epochesekunden Beginn
- my $epoch_seconds_begin = timelocal($sec1, $min1, $hh1, $dd1, $mm1-1, $yyyy1-1900) if($tsbegin);
- my ($timeolderthan,$timedifftonow) = DbRep_normRelTime($hash);
-
- if($timedifftonow) {
- $epoch_seconds_begin = time() - $timedifftonow;
- Log3 ($name, 4, "DbRep $name - Time difference to current time for calculating Timestamp begin: $timedifftonow sec");
- } elsif ($timeolderthan) {
- my $mints = $hash->{HELPER}{MINTS}?$hash->{HELPER}{MINTS}:"1970-01-01 01:00:00"; # Timestamp des 1. Datensatzes verwenden falls ermittelt
- $mints =~ /^(\d+)-(\d+)-(\d+)\s(\d+):(\d+):(\d+)$/;
- $epoch_seconds_begin = timelocal($6, $5, $4, $3, $2-1, $1-1900);
- }
-
- my $tsbegin_string = strftime "%Y-%m-%d %H:%M:%S", localtime($epoch_seconds_begin);
- Log3 ($name, 5, "DbRep $name - Timestamp begin epocheseconds: $epoch_seconds_begin") if($opt !~ /tableCurrentPurge/);
- Log3 ($name, 4, "DbRep $name - Timestamp begin human readable: $tsbegin_string") if($opt !~ /tableCurrentPurge/);
-
-
- # relative Auswertungszeit Ende berücksichtigen # Umwandeln in Epochesekunden Endezeit
- my $epoch_seconds_end = timelocal($sec2, $min2, $hh2, $dd2, $mm2-1, $yyyy2-1900);
-
- $epoch_seconds_end = $timeolderthan ? (time() - $timeolderthan) : $epoch_seconds_end;
-
- #$epoch_seconds_end = AttrVal($name, "timeOlderThan", undef) ?
- # (time() - AttrVal($name, "timeOlderThan", undef)) : $epoch_seconds_end;
- Log3 ($name, 4, "DbRep $name - Time difference to current time for calculating Timestamp end: $timeolderthan sec") if(AttrVal($name, "timeOlderThan", undef));
-
- my $tsend_string = strftime "%Y-%m-%d %H:%M:%S", localtime($epoch_seconds_end);
-
- Log3 ($name, 5, "DbRep $name - Timestamp end epocheseconds: $epoch_seconds_end") if($opt !~ /tableCurrentPurge/);
- Log3 ($name, 4, "DbRep $name - Timestamp end human readable: $tsend_string") if($opt !~ /tableCurrentPurge/);
-
-
- # Erstellung Wertehash für Aggregationen
- my $runtime = $epoch_seconds_begin; # Schleifenlaufzeit auf Beginn der Zeitselektion setzen
- my $runtime_string; # Datum/Zeit im SQL-Format für Readingname Teilstring
- my $runtime_string_first; # Datum/Zeit Auswertungsbeginn im SQL-Format für SQL-Statement
- my $runtime_string_next; # Datum/Zeit + Periode (Granularität) für Auswertungsende im SQL-Format
- my $reading_runtime_string; # zusammengesetzter Readingname+Aggregation für Update
- my $tsstr = strftime "%H:%M:%S", localtime($runtime); # für Berechnung Tagesverschieber / Stundenverschieber
- my $testr = strftime "%H:%M:%S", localtime($epoch_seconds_end); # für Berechnung Tagesverschieber / Stundenverschieber
- my $dsstr = strftime "%Y-%m-%d", localtime($runtime); # für Berechnung Tagesverschieber / Stundenverschieber
- my $destr = strftime "%Y-%m-%d", localtime($epoch_seconds_end); # für Berechnung Tagesverschieber / Stundenverschieber
- my $msstr = strftime "%m", localtime($runtime); # Startmonat für Berechnung Monatsverschieber
- my $mestr = strftime "%m", localtime($epoch_seconds_end); # Endemonat für Berechnung Monatsverschieber
- my $ysstr = strftime "%Y", localtime($runtime); # Startjahr für Berechnung Monatsverschieber
- my $yestr = strftime "%Y", localtime($epoch_seconds_end); # Endejahr für Berechnung Monatsverschieber
-
- my $wd = strftime "%a", localtime($runtime); # Wochentag des aktuellen Startdatum/Zeit
- my $wdadd = 604800 if($wd eq "Mo"); # wenn Start am "Mo" dann nächste Grenze +7 Tage
- $wdadd = 518400 if($wd eq "Di"); # wenn Start am "Di" dann nächste Grenze +6 Tage
- $wdadd = 432000 if($wd eq "Mi"); # wenn Start am "Mi" dann nächste Grenze +5 Tage
- $wdadd = 345600 if($wd eq "Do"); # wenn Start am "Do" dann nächste Grenze +4 Tage
- $wdadd = 259200 if($wd eq "Fr"); # wenn Start am "Fr" dann nächste Grenze +3 Tage
- $wdadd = 172800 if($wd eq "Sa"); # wenn Start am "Sa" dann nächste Grenze +2 Tage
- $wdadd = 86400 if($wd eq "So"); # wenn Start am "So" dann nächste Grenze +1 Tage
-
- Log3 ($name, 5, "DbRep $name - weekday of start for selection: $wd -> wdadd: $wdadd") if($wdadd);
-
- my $aggsec;
- if ($aggregation eq "hour") {
- $aggsec = 3600;
- } elsif ($aggregation eq "day") {
- $aggsec = 86400;
- } elsif ($aggregation eq "week") {
- $aggsec = 604800;
- } elsif ($aggregation eq "month") {
- $aggsec = 2678400; # Initialwert, wird in DbRep_collaggstr für jeden Monat berechnet
- } elsif ($aggregation eq "no") {
- $aggsec = 1;
- } else {
- return;
- }
-
-my %cv = (
- tsstr => $tsstr,
- testr => $testr,
- dsstr => $dsstr,
- destr => $destr,
- msstr => $msstr,
- mestr => $mestr,
- ysstr => $ysstr,
- yestr => $yestr,
- aggsec => $aggsec,
- aggregation => $aggregation,
- epoch_seconds_end => $epoch_seconds_end,
- wdadd => $wdadd
-);
-$hash->{HELPER}{CV} = \%cv;
-
- my $ts; # für Erstellung Timestamp-Array zur nonblocking SQL-Abarbeitung
- my $i = 1; # Schleifenzähler -> nur Indikator für ersten Durchlauf -> anderer $runtime_string_first
- my $ll; # loopindikator, wenn 1 = loopausstieg
-
- # Aufbau Timestampstring mit Zeitgrenzen entsprechend Aggregation
- while (!$ll) {
- # collect aggregation strings
- ($runtime,$runtime_string,$runtime_string_first,$runtime_string_next,$ll) = DbRep_collaggstr($hash,$runtime,$i,$runtime_string_next);
- $ts .= $runtime_string."#".$runtime_string_first."#".$runtime_string_next."|";
- $i++;
- }
-
-return ($epoch_seconds_begin,$epoch_seconds_end,$runtime_string_first,$runtime_string_next,$ts);
-}
-
-####################################################################################################
-# Zusammenstellung Aggregationszeiträume
-####################################################################################################
-sub DbRep_collaggstr($$$$) {
- my ($hash,$runtime,$i,$runtime_string_next) = @_;
- my $name = $hash->{NAME};
- my $runtime_string; # Datum/Zeit im SQL-Format für Readingname Teilstring
- my $runtime_string_first; # Datum/Zeit Auswertungsbeginn im SQL-Format für SQL-Statement
- my $ll; # loopindikator, wenn 1 = loopausstieg
- my $runtime_orig; # orig. runtime als Grundlage für Addition mit $aggsec
- my $tsstr = $hash->{HELPER}{CV}{tsstr}; # für Berechnung Tagesverschieber / Stundenverschieber
- my $testr = $hash->{HELPER}{CV}{testr}; # für Berechnung Tagesverschieber / Stundenverschieber
- my $dsstr = $hash->{HELPER}{CV}{dsstr}; # für Berechnung Tagesverschieber / Stundenverschieber
- my $destr = $hash->{HELPER}{CV}{destr}; # für Berechnung Tagesverschieber / Stundenverschieber
- my $msstr = $hash->{HELPER}{CV}{msstr}; # Startmonat für Berechnung Monatsverschieber
- my $mestr = $hash->{HELPER}{CV}{mestr}; # Endemonat für Berechnung Monatsverschieber
- my $ysstr = $hash->{HELPER}{CV}{ysstr}; # Startjahr für Berechnung Monatsverschieber
- my $yestr = $hash->{HELPER}{CV}{yestr}; # Endejahr für Berechnung Monatsverschieber
- my $aggregation = $hash->{HELPER}{CV}{aggregation}; # Aggregation
- my $aggsec = $hash->{HELPER}{CV}{aggsec}; # laufende Aggregationssekunden
- my $epoch_seconds_end = $hash->{HELPER}{CV}{epoch_seconds_end};
- my $wdadd = $hash->{HELPER}{CV}{wdadd}; # Ergänzungstage. Starttag + Ergänzungstage = der folgende Montag (für week-Aggregation)
-
- # only for this block because of warnings if some values not set
- no warnings 'uninitialized';
-
- # keine Aggregation (all between timestamps)
- if ($aggregation eq "no") {
- $runtime_string = "no_aggregation"; # für Readingname
- $runtime_string_first = strftime "%Y-%m-%d %H:%M:%S", localtime($runtime);
- $runtime_string_next = strftime "%Y-%m-%d %H:%M:%S", localtime($epoch_seconds_end);
- $ll = 1;
- }
-
- # Monatsaggregation
- if ($aggregation eq "month") {
- $runtime_orig = $runtime;
-
- # Hilfsrechnungen
- my $rm = strftime "%m", localtime($runtime); # Monat des aktuell laufenden Startdatums d. SQL-Select
- my $ry = strftime "%Y", localtime($runtime); # Jahr des aktuell laufenden Startdatums d. SQL-Select
- my $dim = $rm-2?30+($rm*3%7<4):28+!($ry%4||$ry%400*!($ry%100)); # Anzahl Tage des aktuell laufenden Monats
- Log3 ($name, 5, "DbRep $name - act year: $ry, act month: $rm, days in month: $dim, endyear: $yestr, endmonth: $mestr");
- $aggsec = $dim * 86400;
-
- $runtime = $runtime+3600 if(DbRep_dsttest($hash,$runtime,$aggsec) && (strftime "%m", localtime($runtime)) > 6); # Korrektur Winterzeitumstellung (Uhr wurde 1 Stunde zurück gestellt)
-
- $runtime_string = strftime "%Y-%m", localtime($runtime); # für Readingname
-
- if ($i==1) {
- # nur im ersten Durchlauf
- $runtime_string_first = strftime "%Y-%m-%d %H:%M:%S", localtime($runtime_orig);
- }
-
- if ($ysstr == $yestr && $msstr == $mestr || $ry == $yestr && $rm == $mestr) {
- $runtime_string_first = strftime "%Y-%m-01", localtime($runtime) if($i>1);
- $runtime_string_next = strftime "%Y-%m-%d %H:%M:%S", localtime($epoch_seconds_end);
- $ll=1;
-
- } else {
- if(($runtime) > $epoch_seconds_end) {
- #$runtime_string_first = strftime "%Y-%m-01", localtime($runtime) if($i>11); # ausgebaut 24.02.2018
- $runtime_string_first = strftime "%Y-%m-01", localtime($runtime);
- $runtime_string_next = strftime "%Y-%m-%d %H:%M:%S", localtime($epoch_seconds_end);
- $ll=1;
- } else {
- $runtime_string_first = strftime "%Y-%m-01", localtime($runtime) if($i>1);
- $runtime_string_next = strftime "%Y-%m-01", localtime($runtime+($dim*86400));
-
- }
- }
- my ($yyyy1, $mm1, $dd1) = ($runtime_string_next =~ /(\d+)-(\d+)-(\d+)/);
- $runtime = timelocal("00", "00", "00", "01", $mm1-1, $yyyy1-1900);
-
- # neue Beginnzeit in Epoche-Sekunden
- $runtime = $runtime_orig+$aggsec;
- }
-
- # Wochenaggregation
- if ($aggregation eq "week") {
- $runtime = $runtime+3600 if($i!=1 && DbRep_dsttest($hash,$runtime,$aggsec) && (strftime "%m", localtime($runtime)) > 6); # Korrektur Winterzeitumstellung (Uhr wurde 1 Stunde zurück gestellt)
- $runtime_orig = $runtime;
-
- my $w = strftime "%V", localtime($runtime); # Wochennummer des aktuellen Startdatum/Zeit
- $runtime_string = "week_".$w; # für Readingname
- my $ms = strftime "%m", localtime($runtime); # Startmonat (01-12)
- my $me = strftime "%m", localtime($epoch_seconds_end); # Endemonat (01-12)
-
- if ($i==1) {
- # nur im ersten Schleifendurchlauf
- $runtime_string_first = strftime "%Y-%m-%d %H:%M:%S", localtime($runtime);
-
- # Korrektur $runtime_orig für Berechnung neue Beginnzeit für nächsten Durchlauf
- my ($yyyy1, $mm1, $dd1) = ($runtime_string_first =~ /(\d+)-(\d+)-(\d+)/);
- $runtime = timelocal("00", "00", "00", $dd1, $mm1-1, $yyyy1-1900);
- $runtime = $runtime+3600 if(DbRep_dsttest($hash,$runtime,$aggsec) && (strftime "%m", localtime($runtime)) > 6); # Korrektur Winterzeitumstellung (Uhr wurde 1 Stunde zurück gestellt)
- $runtime = $runtime+$wdadd;
- $runtime_orig = $runtime-$aggsec;
-
- # die Woche Beginn ist gleich der Woche vom Ende Auswertung
- if((strftime "%V", localtime($epoch_seconds_end)) eq ($w) && ($ms+$me != 13)) {
- $runtime_string_next = strftime "%Y-%m-%d %H:%M:%S", localtime($epoch_seconds_end);
- $ll=1;
- } else {
- $runtime_string_next = strftime "%Y-%m-%d", localtime($runtime);
- }
- } else {
- # weitere Durchläufe
- if(($runtime+$aggsec) > $epoch_seconds_end) {
- $runtime_string_first = strftime "%Y-%m-%d", localtime($runtime_orig);
- $runtime_string_next = strftime "%Y-%m-%d %H:%M:%S", localtime($epoch_seconds_end);
- $ll=1;
- } else {
- $runtime_string_first = strftime "%Y-%m-%d", localtime($runtime_orig) ;
- $runtime_string_next = strftime "%Y-%m-%d", localtime($runtime+$aggsec);
- }
- }
-
- # neue Beginnzeit in Epoche-Sekunden
- $runtime = $runtime_orig+$aggsec;
- }
-
- # Tagesaggregation
- if ($aggregation eq "day") {
- $runtime_string = strftime "%Y-%m-%d", localtime($runtime); # für Readingname
- $runtime_string_first = strftime "%Y-%m-%d %H:%M:%S", localtime($runtime) if($i==1);
- $runtime_string_first = strftime "%Y-%m-%d", localtime($runtime) if($i>1);
- $runtime = $runtime+3600 if(DbRep_dsttest($hash,$runtime,$aggsec) && (strftime "%m", localtime($runtime)) > 6); # Korrektur Winterzeitumstellung (Uhr wurde 1 Stunde zurück gestellt)
-
- if((($tsstr gt $testr) ? $runtime : ($runtime+$aggsec)) > $epoch_seconds_end) {
- $runtime_string_first = strftime "%Y-%m-%d", localtime($runtime);
- $runtime_string_first = strftime "%Y-%m-%d %H:%M:%S", localtime($runtime) if( $dsstr eq $destr);
- $runtime_string_next = strftime "%Y-%m-%d %H:%M:%S", localtime($epoch_seconds_end);
- $ll=1;
- } else {
- $runtime_string_next = strftime "%Y-%m-%d", localtime($runtime+$aggsec);
- }
- Log3 ($name, 5, "DbRep $name - runtime_string: $runtime_string, runtime_string_first: $runtime_string_first, runtime_string_next: $runtime_string_next");
-
- # neue Beginnzeit in Epoche-Sekunden
- $runtime = $runtime+$aggsec;
- }
-
- # Stundenaggregation
- if ($aggregation eq "hour") {
- $runtime_string = strftime "%Y-%m-%d_%H", localtime($runtime); # für Readingname
- $runtime_string_first = strftime "%Y-%m-%d %H:%M:%S", localtime($runtime) if($i==1);
- $runtime = $runtime+3600 if(DbRep_dsttest($hash,$runtime,$aggsec) && (strftime "%m", localtime($runtime)) > 6); # Korrektur Winterzeitumstellung (Uhr wurde 1 Stunde zurück gestellt)
- $runtime_string_first = strftime "%Y-%m-%d %H", localtime($runtime) if($i>1);
-
- my @a = split (":",$tsstr);
- my $hs = $a[0];
- my $msstr = $a[1].":".$a[2];
- @a = split (":",$testr);
- my $he = $a[0];
- my $mestr = $a[1].":".$a[2];
-
- if((($msstr gt $mestr) ? $runtime : ($runtime+$aggsec)) > $epoch_seconds_end) {
- $runtime_string_first = strftime "%Y-%m-%d %H", localtime($runtime);
- $runtime_string_first = strftime "%Y-%m-%d %H:%M:%S", localtime($runtime) if( $dsstr eq $destr && $hs eq $he);
- $runtime_string_next = strftime "%Y-%m-%d %H:%M:%S", localtime($epoch_seconds_end);
- $ll=1;
- } else {
- $runtime_string_next = strftime "%Y-%m-%d %H", localtime($runtime+$aggsec);
- }
-
- # neue Beginnzeit in Epoche-Sekunden
- $runtime = $runtime+$aggsec;
- }
-
-return ($runtime,$runtime_string,$runtime_string_first,$runtime_string_next,$ll);
-}
-
-####################################################################################################
-# nichtblockierende DB-Abfrage averageValue
-####################################################################################################
-sub averval_DoParse($) {
- my ($string) = @_;
- my ($name,$device,$reading,$prop,$ts) = split("\\§", $string);
- my $hash = $defs{$name};
- my $dbloghash = $hash->{dbloghash};
- my $dbconn = $dbloghash->{dbconn};
- my $dbuser = $dbloghash->{dbuser};
- my $dblogname = $dbloghash->{NAME};
- my $dbpassword = $attr{"sec$dblogname"}{secret};
- my $acf = AttrVal($name, "averageCalcForm", "avgArithmeticMean"); # Festlegung Berechnungsschema f. Mittelwert
- my $qlf = "avg";
- my ($dbh,$sql,$sth,$err,$selspec,$addon);
-
- # Background-Startzeit
- my $bst = [gettimeofday];
-
- eval {$dbh = DBI->connect("dbi:$dbconn", $dbuser, $dbpassword, { PrintError => 0, RaiseError => 1, AutoInactiveDestroy => 1 });};
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- return "$name|''|$device|$reading|''|$err|''";
- }
-
- # only for this block because of warnings if details of readings are not set
- no warnings 'uninitialized';
-
- # ist Zeiteingrenzung und/oder Aggregation gesetzt ? (wenn ja -> "?" in SQL sonst undef)
- my ($IsTimeSet,$IsAggrSet) = DbRep_checktimeaggr($hash);
- Log3 ($name, 5, "DbRep $name - IsTimeSet: $IsTimeSet, IsAggrSet: $IsAggrSet");
-
- # Timestampstring to Array
- my @ts = split("\\|", $ts);
- Log3 ($name, 5, "DbRep $name - Timestamp-Array: \n@ts");
-
- if($acf eq "avgArithmeticMean") {
- # arithmetischer Mittelwert
- # vorbereiten der DB-Abfrage, DB-Modell-abhaengig
- $addon = '';
- if ($dbloghash->{MODEL} eq "POSTGRESQL") {
- $selspec = "AVG(VALUE::numeric)";
- } elsif ($dbloghash->{MODEL} eq "MYSQL") {
- $selspec = "AVG(VALUE)";
- } elsif ($dbloghash->{MODEL} eq "SQLITE") {
- $selspec = "AVG(VALUE)";
- } else {
- $selspec = "AVG(VALUE)";
- }
- $qlf = "avgam";
- } elsif ($acf eq "avgDailyMeanGWS") {
- # Tagesmittelwert Temperaturen nach Schema des deutschen Wetterdienstes
- # SELECT VALUE FROM history WHERE DEVICE="MyWetter" AND READING="temperature" AND TIMESTAMP >= "2018-01-28 $i:00:00" AND TIMESTAMP <= "2018-01-28 ($i+1):00:00" ORDER BY TIMESTAMP DESC LIMIT 1;
- $addon = "ORDER BY TIMESTAMP DESC LIMIT 1";
- $selspec = "VALUE";
- $qlf = "avgdmgws";
- } elsif ($acf eq "avgTimeWeightMean") {
- $addon = "ORDER BY TIMESTAMP ASC";
- $selspec = "TIMESTAMP,VALUE";
- $qlf = "avgtwm";
- }
-
- # SQL-Startzeit
- my $st = [gettimeofday];
-
- # DB-Abfrage zeilenweise für jeden Array-Eintrag
- my $arrstr;
- foreach my $row (@ts) {
- my @a = split("#", $row);
- my $runtime_string = $a[0];
- my $runtime_string_first = $a[1];
- my $runtime_string_next = $a[2];
-
- if($acf eq "avgArithmeticMean") {
- # arithmetischer Mittelwert (Standard)
- #
- if ($IsTimeSet || $IsAggrSet) {
- $sql = DbRep_createSelectSql($hash,"history",$selspec,$device,$reading,"'$runtime_string_first'","'$runtime_string_next'",$addon);
- } else {
- $sql = DbRep_createSelectSql($hash,"history",$selspec,$device,$reading,undef,undef,$addon);
- }
- Log3 ($name, 4, "DbRep $name - SQL execute: $sql");
-
- eval{ $sth = $dbh->prepare($sql);
- $sth->execute();
- };
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- $dbh->disconnect;
- return "$name|''|$device|$reading|''|$err|''";
- }
-
- my @line = $sth->fetchrow_array();
-
- Log3 ($name, 5, "DbRep $name - SQL result: $line[0]") if($line[0]);
-
- if(AttrVal($name, "aggregation", "") eq "hour") {
- my @rsf = split(/[" "\|":"]/,$runtime_string_first);
- $arrstr .= $runtime_string."#".$line[0]."#".$rsf[0]."_".$rsf[1]."|";
- } else {
- my @rsf = split(" ",$runtime_string_first);
- $arrstr .= $runtime_string."#".$line[0]."#".$rsf[0]."|";
- }
-
- } elsif ($acf eq "avgDailyMeanGWS") {
- # Berechnung des Tagesmittelwertes (Temperatur) nach der Vorschrift des deutschen Wetterdienstes
- # Berechnung der Tagesmittel aus 24 Stundenwerten, Bezugszeit für einen Tag i.d.R. 23:51 UTC des
- # Vortages bis 23:50 UTC, d.h. 00:51 bis 23:50 MEZ
- # Wenn mehr als 3 Stundenwerte fehlen -> Berechnung aus den 4 Hauptterminen (00, 06, 12, 18 UTC),
- # d.h. 01, 07, 13, 19 MEZ
- # https://www.dwd.de/DE/leistungen/klimadatendeutschland/beschreibung_tagesmonatswerte.html
- #
- my $sum = 0;
- my $anz = 0; # Anzahl der Messwerte am Tag
- my($t01,$t07,$t13,$t19); # Temperaturen der Haupttermine
- my ($bdate,undef) = split(" ",$runtime_string_first);
- for my $i (0..23) {
- my $bsel = $bdate." ".sprintf("%02d",$i).":00:00";
- my $esel = ($i<23)?$bdate." ".sprintf("%02d",$i).":59:59":$runtime_string_next;
-
- $sql = DbRep_createSelectSql($hash,"history",$selspec,$device,$reading,"'$bsel'","'$esel'",$addon);
- Log3 ($name, 4, "DbRep $name - SQL execute: $sql");
-
- eval{ $sth = $dbh->prepare($sql);
- $sth->execute();
- };
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- $dbh->disconnect;
- return "$name|''|$device|$reading|''|$err|''";
- }
- my $val = $sth->fetchrow_array();
- Log3 ($name, 5, "DbRep $name - SQL result: $val") if($val);
- $val = DbRep_numval ($val); # nichtnumerische Zeichen eliminieren
- if(defined($val) && looks_like_number($val)) {
- $sum += $val;
- $t01 = $val if($val && $i == 00); # Wert f. Stunde 01 ist zw. letzter Wert vor 01
- $t07 = $val if($val && $i == 06);
- $t13 = $val if($val && $i == 12);
- $t19 = $val if($val && $i == 18);
- $anz++;
- }
- }
- if($anz >= 21) {
- $sum = $sum/24;
- } elsif ($anz >= 4 && $t01 && $t07 && $t13 && $t19) {
- $sum = ($t01+$t07+$t13+$t19)/4;
- } else {
- $sum = "insufficient values";
- }
-
- if(AttrVal($name, "aggregation", "") eq "hour") {
- my @rsf = split(/[" "\|":"]/,$runtime_string_first);
- $arrstr .= $runtime_string."#".$sum."#".$rsf[0]."_".$rsf[1]."|";
- } else {
- my @rsf = split(" ",$runtime_string_first);
- $arrstr .= $runtime_string."#".$sum."#".$rsf[0]."|";
- }
-
- } elsif ($acf eq "avgTimeWeightMean") {
- # zeitgewichteten Mittelwert berechnen
- # http://massmatics.de/merkzettel/#!837:Gewichteter_Mittelwert
- #
- # $tsum = timestamp letzter Messpunkt - timestamp erster Messpunkt
- # $t1 = timestamp wert1
- # $t2 = timestamp wert2
- # $dt = $t2 - $t1
- # $t1 = $t2
- # .....
- # (val1*$dt/$tsum) + (val2*$dt/$tsum) + .... + (valn*$dt/$tsum)
- #
-
- # gesamte Zeitspanne $tsum zwischen ersten und letzten Datensatz der Zeitscheibe ermitteln
- my ($tsum,$tf,$tl,$tn,$to,$dt,$val,$val1);
- my $sum = 0;
- my $addonf = 'ORDER BY TIMESTAMP ASC LIMIT 1';
- my $addonl = 'ORDER BY TIMESTAMP DESC LIMIT 1';
- my $sqlf = DbRep_createSelectSql($hash,"history","TIMESTAMP",$device,$reading,"'$runtime_string_first'","'$runtime_string_next'",$addonf);
- my $sqll = DbRep_createSelectSql($hash,"history","TIMESTAMP",$device,$reading,"'$runtime_string_first'","'$runtime_string_next'",$addonl);
-
- eval { $tf = ($dbh->selectrow_array($sqlf))[0];
- $tl = ($dbh->selectrow_array($sqll))[0];
- };
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- $dbh->disconnect;
- return "$name|''|$device|$reading|''|$err|''";
- }
-
- if(!$tf || !$tl) {
- # kein Start- und/oder Ende Timestamp in Zeitscheibe vorhanden -> keine Werteberechnung möglich
- $sum = "insufficient values";
- } else {
- my ($yyyyf, $mmf, $ddf, $hhf, $minf, $secf) = ($tf =~ /(\d+)-(\d+)-(\d+) (\d+):(\d+):(\d+)/);
- my ($yyyyl, $mml, $ddl, $hhl, $minl, $secl) = ($tl =~ /(\d+)-(\d+)-(\d+) (\d+):(\d+):(\d+)/);
- $tsum = (timelocal($secl, $minl, $hhl, $ddl, $mml-1, $yyyyl-1900))-(timelocal($secf, $minf, $hhf, $ddf, $mmf-1, $yyyyf-1900));
-
- if ($IsTimeSet || $IsAggrSet) {
- $sql = DbRep_createSelectSql($hash,"history",$selspec,$device,$reading,"'$runtime_string_first'","'$runtime_string_next'",$addon);
- } else {
- $sql = DbRep_createSelectSql($hash,"history",$selspec,$device,$reading,undef,undef,$addon);
- }
- Log3 ($name, 4, "DbRep $name - SQL execute: $sql");
-
- eval{ $sth = $dbh->prepare($sql);
- $sth->execute();
- };
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- $dbh->disconnect;
- return "$name|''|$device|$reading|''|$err|''";
- }
-
- my @twm_array = map { $_->[0]."_ESC_".$_->[1] } @{$sth->fetchall_arrayref()};
-
- foreach my $twmrow (@twm_array) {
- ($tn,$val) = split("_ESC_",$twmrow);
- $val = DbRep_numval ($val); # nichtnumerische Zeichen eliminieren
- my ($yyyyt1, $mmt1, $ddt1, $hht1, $mint1, $sect1) = ($tn =~ /(\d+)-(\d+)-(\d+) (\d+):(\d+):(\d+)/);
- $tn = timelocal($sect1, $mint1, $hht1, $ddt1, $mmt1-1, $yyyyt1-1900);
- if(!$to) {
- $val1 = $val;
- $to = $tn;
- next;
- }
- $dt = $tn - $to;
- $sum += $val1*($dt/$tsum);
- $val1 = $val;
- $to = $tn;
- Log3 ($name, 5, "DbRep $name - data element: $twmrow");
- Log3 ($name, 5, "DbRep $name - time sum: $tsum, delta time: $dt, value: $val1, twm: ".$val1*($dt/$tsum));
- }
- }
- if(AttrVal($name, "aggregation", "") eq "hour") {
- my @rsf = split(/[" "\|":"]/,$runtime_string_first);
- $arrstr .= $runtime_string."#".$sum."#".$rsf[0]."_".$rsf[1]."|";
- } else {
- my @rsf = split(" ",$runtime_string_first);
- $arrstr .= $runtime_string."#".$sum."#".$rsf[0]."|";
- }
- }
- }
-
- $sth->finish;
- $dbh->disconnect;
-
- # SQL-Laufzeit ermitteln
- my $rt = tv_interval($st);
-
- # Ergebnisse in Datenbank schreiben
- my ($wrt,$irowdone);
- if($prop =~ /writeToDB/) {
- ($wrt,$irowdone,$err) = DbRep_OutputWriteToDB($name,$device,$reading,$arrstr,$qlf);
- if ($err) {
- Log3 $hash->{NAME}, 2, "DbRep $name - $err";
- $err = encode_base64($err,"");
- return "$name|''|$device|$reading|''|$err|''";
- }
- $rt = $rt+$wrt;
- }
-
- # Daten müssen als Einzeiler zurückgegeben werden
- $arrstr = encode_base64($arrstr,"");
-
- # Background-Laufzeit ermitteln
- my $brt = tv_interval($bst);
-
- $rt = $rt.",".$brt;
-
- return "$name|$arrstr|$device|$reading|$rt|0|$irowdone";
-}
-
-####################################################################################################
-# Auswertungsroutine der nichtblockierenden DB-Abfrage averageValue
-####################################################################################################
-sub averval_ParseDone($) {
- my ($string) = @_;
- my @a = split("\\|",$string);
- my $hash = $defs{$a[0]};
- my $name = $hash->{NAME};
- my $arrstr = decode_base64($a[1]);
- my $device = $a[2];
- $device =~ s/[^A-Za-z\/\d_\.-]/\//g;
- my $reading = $a[3];
- $reading =~ s/[^A-Za-z\/\d_\.-]/\//g;
- my $bt = $a[4];
- my ($rt,$brt) = split(",", $bt);
- my $err = $a[5]?decode_base64($a[5]):undef;
- my $irowdone = $a[6];
- my $reading_runtime_string;
-
- if ($err) {
- ReadingsSingleUpdateValue ($hash, "errortext", $err, 1);
- ReadingsSingleUpdateValue ($hash, "state", "error", 1);
- delete($hash->{HELPER}{RUNNING_PID});
- return;
- }
-
- # only for this block because of warnings if details of readings are not set
- no warnings 'uninitialized';
-
- my $acf = AttrVal($name, "averageCalcForm", "avgArithmeticMean");
- if($acf eq "avgArithmeticMean") {
- $acf = "AM"
- } elsif ($acf eq "avgDailyMeanGWS") {
- $acf = "DMGWS";
- } elsif ($acf eq "avgTimeWeightMean") {
- $acf = "TWM";
- }
-
- # Readingaufbereitung
- readingsBeginUpdate($hash);
-
- my @arr = split("\\|", $arrstr);
- foreach my $row (@arr) {
- my @a = split("#", $row);
- my $runtime_string = $a[0];
- my $c = $a[1];
- my $rsf = $a[2]."__";
-
- if (AttrVal($hash->{NAME}, "readingNameMap", "")) {
- $reading_runtime_string = $rsf.AttrVal($hash->{NAME}, "readingNameMap", "")."__".$runtime_string;
- } else {
- my $ds = $device."__" if ($device);
- my $rds = $reading."__" if ($reading);
- $reading_runtime_string = $rsf.$ds.$rds."AVG".$acf."__".$runtime_string;
- }
- if($acf eq "DMGWS") {
- ReadingsBulkUpdateValue ($hash, $reading_runtime_string, looks_like_number($c)?sprintf("%.1f",$c):$c);
- } else {
- ReadingsBulkUpdateValue ($hash, $reading_runtime_string, $c?sprintf("%.4f",$c):"-");
- }
- }
-
- ReadingsBulkUpdateValue ($hash, "db_lines_processed", $irowdone) if($hash->{LASTCMD} =~ /writeToDB/);
- ReadingsBulkUpdateTimeState($hash,$brt,$rt,"done");
- readingsEndUpdate($hash, 1);
-
- delete($hash->{HELPER}{RUNNING_PID});
-
-return;
-}
-
-####################################################################################################
-# nichtblockierende DB-Abfrage count
-####################################################################################################
-sub count_DoParse($) {
- my ($string) = @_;
- my ($name,$table,$device,$reading,$ts) = split("\\§", $string);
- my $hash = $defs{$name};
- my $dbloghash = $hash->{dbloghash};
- my $dbconn = $dbloghash->{dbconn};
- my $dbuser = $dbloghash->{dbuser};
- my $dblogname = $dbloghash->{NAME};
- my $dbpassword = $attr{"sec$dblogname"}{secret};
- my $ced = AttrVal($name,"countEntriesDetail",0);
- my ($dbh,$sql,$sth,$err);
-
- # Background-Startzeit
- my $bst = [gettimeofday];
-
- eval {$dbh = DBI->connect("dbi:$dbconn", $dbuser, $dbpassword, { PrintError => 0, RaiseError => 1, AutoInactiveDestroy => 1 });};
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- return "$name|''|$device|$reading|''|$err|$table";
- }
-
- # only for this block because of warnings if details of readings are not set
- no warnings 'uninitialized';
-
- # ist Zeiteingrenzung und/oder Aggregation gesetzt ? (wenn ja -> "?" in SQL sonst undef)
- my ($IsTimeSet,$IsAggrSet,$aggregation) = DbRep_checktimeaggr($hash);
- Log3 ($name, 5, "DbRep $name - IsTimeSet: $IsTimeSet, IsAggrSet: $IsAggrSet");
-
- # Timestampstring to Array
- my @ts = split("\\|", $ts);
- Log3 ($name, 5, "DbRep $name - Timestamp-Array: \n@ts");
-
- # SQL-Startzeit
- my $st = [gettimeofday];
-
- # DB-Abfrage zeilenweise für jeden Timearray-Eintrag
- my ($arrstr,@rsf,$ttail);
- my $addon = '';
- my $selspec = "COUNT(*)";
- if($ced) {
- $addon = "group by READING";
- $selspec = "READING, COUNT(*)";
- }
-
- foreach my $row (@ts) {
- my @a = split("#", $row);
- my $runtime_string = $a[0];
- my $runtime_string_first = $a[1];
- my $runtime_string_next = $a[2];
- my $tc = 0;
-
- if($aggregation eq "hour") {
- @rsf = split(/[" "\|":"]/,$runtime_string_first);
- $ttail = $rsf[0]."_".$rsf[1]."|";
- } else {
- @rsf = split(" ",$runtime_string_first);
- $ttail = $rsf[0]."|";
- }
-
- if ($IsTimeSet || $IsAggrSet) {
- $sql = DbRep_createSelectSql($hash,$table,$selspec,$device,$reading,"'$runtime_string_first'","'$runtime_string_next'",$addon);
- } else {
- $sql = DbRep_createSelectSql($hash,$table,$selspec,$device,$reading,undef,undef,$addon);
- }
- Log3 ($name, 4, "DbRep $name - SQL execute: $sql");
-
- eval{ $sth = $dbh->prepare($sql);
- $sth->execute();
- };
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- $dbh->disconnect;
- return "$name|''|$device|$reading|''|$err|$table";
- }
-
- if($ced) {
- # detaillierter Readings-Count
- while (my @line = $sth->fetchrow_array()) {
- Log3 ($name, 5, "DbRep $name - SQL result: @line");
- $tc += $line[1] if($line[1]); # total count für Reading
- $arrstr .= $runtime_string."#".$line[0]."#".$line[1]."#".$ttail;
- }
- # total count (über alle selected Readings) für Zeitabschnitt einfügen
- $arrstr .= $runtime_string."#"."ALLREADINGS"."#".$tc."#".$ttail;
- } else {
- my @line = $sth->fetchrow_array();
- Log3 ($name, 5, "DbRep $name - SQL result: $line[0]") if($line[0]);
- $arrstr .= $runtime_string."#"."ALLREADINGS"."#".$line[0]."#".$ttail;
- }
- }
-
- $sth->finish;
- $dbh->disconnect;
-
- # SQL-Laufzeit ermitteln
- my $rt = tv_interval($st);
-
- # Daten müssen als Einzeiler zurückgegeben werden
- $arrstr = encode_base64($arrstr,"");
-
- # Background-Laufzeit ermitteln
- my $brt = tv_interval($bst);
-
- $rt = $rt.",".$brt;
-
- return "$name|$arrstr|$device|$rt|0|$table";
-}
-
-####################################################################################################
-# Auswertungsroutine der nichtblockierenden DB-Abfrage count
-####################################################################################################
-sub count_ParseDone($) {
- my ($string) = @_;
- my @a = split("\\|",$string);
- my $hash = $defs{$a[0]};
- my $name = $hash->{NAME};
- my $arrstr = decode_base64($a[1]);
- my $device = $a[2];
- $device =~ s/[^A-Za-z\/\d_\.-]/\//g;
- my $bt = $a[3];
- my ($rt,$brt) = split(",", $bt);
- my $err = $a[4]?decode_base64($a[4]):undef;
- my $table = $a[5];
- my $reading_runtime_string;
-
- if ($err) {
- ReadingsSingleUpdateValue ($hash, "errortext", $err, 1);
- ReadingsSingleUpdateValue ($hash, "state", "error", 1);
- delete($hash->{HELPER}{RUNNING_PID});
- return;
- }
-
- Log3 ($name, 5, "DbRep $name - SQL result decoded: $arrstr") if($arrstr);
-
- # only for this block because of warnings if details of readings are not set
- no warnings 'uninitialized';
-
- # Readingaufbereitung
- readingsBeginUpdate($hash);
-
- my @arr = split("\\|", $arrstr);
- foreach my $row (@arr) {
- my @a = split("#", $row);
- my $runtime_string = $a[0];
- my $reading = $a[1];
- $reading =~ s/[^A-Za-z\/\d_\.-]/\//g;
- my $c = $a[2];
- my $rsf = $a[3]."__";
-
- if (AttrVal($hash->{NAME}, "readingNameMap", "")) {
- $reading_runtime_string = $rsf.AttrVal($hash->{NAME}, "readingNameMap", "")."__".$runtime_string;
- } else {
- my $ds = $device."__" if ($device);
- my $rds = $reading."__" if ($reading);
- $reading_runtime_string = $rsf.$ds.$rds."COUNT_".$table."__".$runtime_string;
- }
-
- ReadingsBulkUpdateValue ($hash, $reading_runtime_string, $c?$c:"-");
- }
-
- ReadingsBulkUpdateTimeState($hash,$brt,$rt,"done");
- readingsEndUpdate($hash, 1);
-
- delete($hash->{HELPER}{RUNNING_PID});
-
-return;
-}
-
-####################################################################################################
-# nichtblockierende DB-Abfrage maxValue
-####################################################################################################
-sub maxval_DoParse($) {
- my ($string) = @_;
- my ($name,$device,$reading,$prop,$ts) = split("\\§", $string);
- my $hash = $defs{$name};
- my $dbloghash = $hash->{dbloghash};
- my $dbconn = $dbloghash->{dbconn};
- my $dbuser = $dbloghash->{dbuser};
- my $dblogname = $dbloghash->{NAME};
- my $dbpassword = $attr{"sec$dblogname"}{secret};
- my ($dbh,$sql,$sth,$err);
-
- # Background-Startzeit
- my $bst = [gettimeofday];
-
- eval {$dbh = DBI->connect("dbi:$dbconn", $dbuser, $dbpassword, { PrintError => 0, RaiseError => 1, AutoInactiveDestroy => 1 });};
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- return "$name|''|$device|$reading|''|$err|''";
- }
-
- # only for this block because of warnings if details of readings are not set
- no warnings 'uninitialized';
-
- # ist Zeiteingrenzung und/oder Aggregation gesetzt ? (wenn ja -> "?" in SQL sonst undef)
- my ($IsTimeSet,$IsAggrSet) = DbRep_checktimeaggr($hash);
- Log3 ($name, 5, "DbRep $name - IsTimeSet: $IsTimeSet, IsAggrSet: $IsAggrSet");
-
- # Timestampstring to Array
- my @ts = split("\\|", $ts);
- Log3 ($name, 5, "DbRep $name - Timestamp-Array: \n@ts");
-
- # SQL-Startzeit
- my $st = [gettimeofday];
-
- # DB-Abfrage zeilenweise für jeden Array-Eintrag
- my @row_array;
- foreach my $row (@ts) {
- my @a = split("#", $row);
- my $runtime_string = $a[0];
- my $runtime_string_first = $a[1];
- my $runtime_string_next = $a[2];
-
- $runtime_string = encode_base64($runtime_string,"");
-
- if ($IsTimeSet || $IsAggrSet) {
- $sql = DbRep_createSelectSql($hash,"history","VALUE,TIMESTAMP",$device,$reading,"'$runtime_string_first'","'$runtime_string_next'","ORDER BY TIMESTAMP");
- } else {
- $sql = DbRep_createSelectSql($hash,"history","VALUE,TIMESTAMP",$device,$reading,undef,undef,"ORDER BY TIMESTAMP");
- }
- Log3 ($name, 4, "DbRep $name - SQL execute: $sql");
-
- eval{ $sth = $dbh->prepare($sql);
- $sth->execute();
- };
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- $dbh->disconnect;
- return "$name|''|$device|$reading|''|$err|''";
- }
-
- my @array= map { $runtime_string." ".$_ -> [0]." ".$_ -> [1]."\n" } @{ $sth->fetchall_arrayref() };
-
- if(!@array) {
- if(AttrVal($name, "aggregation", "") eq "hour") {
- my @rsf = split(/[" "\|":"]/,$runtime_string_first);
- @array = ($runtime_string." "."0"." ".$rsf[0]."_".$rsf[1]."\n");
- } else {
- my @rsf = split(" ",$runtime_string_first);
- @array = ($runtime_string." "."0"." ".$rsf[0]."\n");
- }
- }
- push(@row_array, @array);
- }
-
- $sth->finish;
- $dbh->disconnect;
-
- # SQL-Laufzeit ermitteln
- my $rt = tv_interval($st);
-
- Log3 ($name, 5, "DbRep $name -> raw data of row_array result:\n @row_array");
-
- #---------- Berechnung Ergebnishash maxValue ------------------------
- my $i = 1;
- my %rh = ();
- my ($lastruntimestring,$row_max_time,$max_value);
-
- foreach my $row (@row_array) {
- my @a = split("[ \t][ \t]*", $row);
- my $runtime_string = decode_base64($a[0]);
- $lastruntimestring = $runtime_string if ($i == 1);
- my $value = $a[1];
- $a[-1] =~ s/:/-/g if($a[-1]); # substituieren unsupported characters -> siehe fhem.pl
- my $timestamp = ($a[-1]&&$a[-2])?$a[-2]."_".$a[-1]:$a[-1];
-
- # Leerzeichen am Ende $timestamp entfernen
- $timestamp =~ s/\s+$//g;
-
- # Test auf $value = "numeric"
- if (!looks_like_number($value)) {
- Log3 ($name, 2, "DbRep $name - ERROR - value isn't numeric in maxValue function. Faulty dataset was \nTIMESTAMP: $timestamp, DEVICE: $device, READING: $reading, VALUE: $value.");
- $err = encode_base64("Value isn't numeric. Faulty dataset was - TIMESTAMP: $timestamp, VALUE: $value", "");
- return "$name|''|$device|$reading|''|$err|''";
- }
-
- Log3 ($name, 5, "DbRep $name - Runtimestring: $runtime_string, DEVICE: $device, READING: $reading, TIMESTAMP: $timestamp, VALUE: $value");
-
- if ($runtime_string eq $lastruntimestring) {
- if (!defined($max_value) || $value >= $max_value) {
- $max_value = $value;
- $row_max_time = $timestamp;
- $rh{$runtime_string} = $runtime_string."|".$max_value."|".$row_max_time;
- }
- } else {
- # neuer Zeitabschnitt beginnt, ersten Value-Wert erfassen
- $lastruntimestring = $runtime_string;
- undef $max_value;
- if (!defined($max_value) || $value >= $max_value) {
- $max_value = $value;
- $row_max_time = $timestamp;
- $rh{$runtime_string} = $runtime_string."|".$max_value."|".$row_max_time;
- }
- }
- $i++;
- }
- #---------------------------------------------------------------------------------------------
-
- Log3 ($name, 5, "DbRep $name - result of maxValue calculation before encoding:");
- foreach my $key (sort(keys(%rh))) {
- Log3 ($name, 5, "runtimestring Key: $key, value: ".$rh{$key});
- }
-
- # Ergebnishash als Einzeiler zurückgeben bzw. Übergabe Schreibroutine
- my $rows = join('§', %rh);
-
- # Ergebnisse in Datenbank schreiben
- my ($wrt,$irowdone);
- if($prop =~ /writeToDB/) {
- ($wrt,$irowdone,$err) = DbRep_OutputWriteToDB($name,$device,$reading,$rows,"max");
- if ($err) {
- Log3 $hash->{NAME}, 2, "DbRep $name - $err";
- $err = encode_base64($err,"");
- return "$name|''|$device|$reading|''|$err|''";
- }
- $rt = $rt+$wrt;
- }
-
- my $rowlist = encode_base64($rows,"");
-
- # Background-Laufzeit ermitteln
- my $brt = tv_interval($bst);
-
- $rt = $rt.",".$brt;
-
- return "$name|$rowlist|$device|$reading|$rt|0|$irowdone";
-}
-
-####################################################################################################
-# Auswertungsroutine der nichtblockierenden DB-Abfrage maxValue
-####################################################################################################
-sub maxval_ParseDone($) {
- my ($string) = @_;
- my @a = split("\\|",$string);
- my $hash = $defs{$a[0]};
- my $name = $hash->{NAME};
- my $rowlist = decode_base64($a[1]);
- my $device = $a[2];
- $device =~ s/[^A-Za-z\/\d_\.-]/\//g;
- my $reading = $a[3];
- $reading =~ s/[^A-Za-z\/\d_\.-]/\//g;
- my $bt = $a[4];
- my ($rt,$brt) = split(",", $bt);
- my $err = $a[5]?decode_base64($a[5]):undef;
- my $irowdone = $a[6];
- my $reading_runtime_string;
-
- if ($err) {
- ReadingsSingleUpdateValue ($hash, "errortext", $err, 1);
- ReadingsSingleUpdateValue ($hash, "state", "error", 1);
- delete($hash->{HELPER}{RUNNING_PID});
- return;
- }
-
- my %rh = split("§", $rowlist);
-
- Log3 ($name, 5, "DbRep $name - result of maxValue calculation after decoding:");
- foreach my $key (sort(keys(%rh))) {
- Log3 ($name, 5, "DbRep $name - runtimestring Key: $key, value: ".$rh{$key});
- }
-
- # Readingaufbereitung
- readingsBeginUpdate($hash);
-
- # only for this block because of warnings if details of readings are not set
- no warnings 'uninitialized';
-
- foreach my $key (sort(keys(%rh))) {
- my @k = split("\\|",$rh{$key});
- my $rsf = $k[2]."__" if($k[2]);
-
- if (AttrVal($hash->{NAME}, "readingNameMap", "")) {
- $reading_runtime_string = $rsf.AttrVal($hash->{NAME}, "readingNameMap", "")."__".$k[0];
- } else {
- my $ds = $device."__" if ($device);
- my $rds = $reading."__" if ($reading);
- $reading_runtime_string = $rsf.$ds.$rds."MAX__".$k[0];
- }
- my $rv = $k[1];
-
- ReadingsBulkUpdateValue ($hash, $reading_runtime_string, defined($rv)?sprintf("%.4f",$rv):"-");
- }
-
- ReadingsBulkUpdateValue ($hash, "db_lines_processed", $irowdone) if($hash->{LASTCMD} =~ /writeToDB/);
- ReadingsBulkUpdateTimeState($hash,$brt,$rt,"done");
- readingsEndUpdate($hash, 1);
-
- delete($hash->{HELPER}{RUNNING_PID});
-
-return;
-}
-
-####################################################################################################
-# nichtblockierende DB-Abfrage minValue
-####################################################################################################
-sub minval_DoParse($) {
- my ($string) = @_;
- my ($name,$device,$reading,$prop,$ts) = split("\\§", $string);
- my $hash = $defs{$name};
- my $dbloghash = $hash->{dbloghash};
- my $dbconn = $dbloghash->{dbconn};
- my $dbuser = $dbloghash->{dbuser};
- my $dblogname = $dbloghash->{NAME};
- my $dbpassword = $attr{"sec$dblogname"}{secret};
- my ($dbh,$sql,$sth,$err);
-
- # Background-Startzeit
- my $bst = [gettimeofday];
-
- eval {$dbh = DBI->connect("dbi:$dbconn", $dbuser, $dbpassword, { PrintError => 0, RaiseError => 1, AutoInactiveDestroy => 1 });};
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- return "$name|''|$device|$reading|''|$err|''";
- }
-
- # only for this block because of warnings if details of readings are not set
- no warnings 'uninitialized';
-
- # ist Zeiteingrenzung und/oder Aggregation gesetzt ? (wenn ja -> "?" in SQL sonst undef)
- my ($IsTimeSet,$IsAggrSet) = DbRep_checktimeaggr($hash);
- Log3 ($name, 5, "DbRep $name - IsTimeSet: $IsTimeSet, IsAggrSet: $IsAggrSet");
-
- # Timestampstring to Array
- my @ts = split("\\|", $ts);
- Log3 ($name, 5, "DbRep $name - Timestamp-Array: \n@ts");
-
- # SQL-Startzeit
- my $st = [gettimeofday];
-
- # DB-Abfrage zeilenweise für jeden Array-Eintrag
- my @row_array;
- foreach my $row (@ts) {
- my @a = split("#", $row);
- my $runtime_string = $a[0];
- my $runtime_string_first = $a[1];
- my $runtime_string_next = $a[2];
-
- $runtime_string = encode_base64($runtime_string,"");
-
- if ($IsTimeSet || $IsAggrSet) {
- $sql = DbRep_createSelectSql($hash,"history","VALUE,TIMESTAMP",$device,$reading,"'$runtime_string_first'","'$runtime_string_next'","ORDER BY TIMESTAMP");
- } else {
- $sql = DbRep_createSelectSql($hash,"history","VALUE,TIMESTAMP",$device,$reading,undef,undef,"ORDER BY TIMESTAMP");
- }
- Log3 ($name, 4, "DbRep $name - SQL execute: $sql");
-
- eval{ $sth = $dbh->prepare($sql);
- $sth->execute();
- };
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- $dbh->disconnect;
- return "$name|''|$device|$reading|''|$err|''";
- }
-
- my @array= map { $runtime_string." ".$_ -> [0]." ".$_ -> [1]."\n" } @{ $sth->fetchall_arrayref() };
-
- if(!@array) {
- if(AttrVal($name, "aggregation", "") eq "hour") {
- my @rsf = split(/[" "\|":"]/,$runtime_string_first);
- @array = ($runtime_string." "."0"." ".$rsf[0]."_".$rsf[1]."\n");
- } else {
- my @rsf = split(" ",$runtime_string_first);
- @array = ($runtime_string." "."0"." ".$rsf[0]."\n");
- }
- }
- push(@row_array, @array);
- }
-
- $sth->finish;
- $dbh->disconnect;
-
- # SQL-Laufzeit ermitteln
- my $rt = tv_interval($st);
-
- Log3 ($name, 5, "DbRep $name -> raw data of row_array result:\n @row_array");
-
- #---------- Berechnung Ergebnishash minValue ------------------------
- my $i = 1;
- my %rh = ();
- my $lastruntimestring;
- my $row_min_time;
- my ($min_value,$value);
-
- foreach my $row (@row_array) {
- my @a = split("[ \t][ \t]*", $row);
- my $runtime_string = decode_base64($a[0]);
- $lastruntimestring = $runtime_string if ($i == 1);
- $value = $a[1];
- $min_value = $a[1] if ($i == 1);
- $a[-1] =~ s/:/-/g if($a[-1]); # substituieren unsupported characters -> siehe fhem.pl
- my $timestamp = ($a[-1]&&$a[-2])?$a[-2]."_".$a[-1]:$a[-1];
-
- # Leerzeichen am Ende $timestamp entfernen
- $timestamp =~ s/\s+$//g;
-
- # Test auf $value = "numeric"
- if (!looks_like_number($value)) {
- # $a[-1] =~ s/\s+$//g;
- Log3 ($name, 2, "DbRep $name - ERROR - value isn't numeric in minValue function. Faulty dataset was \nTIMESTAMP: $timestamp, DEVICE: $device, READING: $reading, VALUE: $value.");
- $err = encode_base64("Value isn't numeric. Faulty dataset was - TIMESTAMP: $timestamp, VALUE: $value", "");
- return "$name|''|$device|$reading|''|$err|''";
- }
-
- Log3 ($name, 5, "DbRep $name - Runtimestring: $runtime_string, DEVICE: $device, READING: $reading, TIMESTAMP: $timestamp, VALUE: $value");
-
- $rh{$runtime_string} = $runtime_string."|".$min_value."|".$timestamp if ($i == 1); # minValue des ersten SQL-Statements in hash einfügen
-
- if ($runtime_string eq $lastruntimestring) {
- if (!defined($min_value) || $value < $min_value) {
- $min_value = $value;
- $row_min_time = $timestamp;
- $rh{$runtime_string} = $runtime_string."|".$min_value."|".$row_min_time;
- }
- } else {
- # neuer Zeitabschnitt beginnt, ersten Value-Wert erfassen
- $lastruntimestring = $runtime_string;
- $min_value = $value;
- $row_min_time = $timestamp;
- $rh{$runtime_string} = $runtime_string."|".$min_value."|".$row_min_time;
- }
- $i++;
- }
- #---------------------------------------------------------------------------------------------
-
- Log3 ($name, 5, "DbRep $name - result of minValue calculation before encoding:");
- foreach my $key (sort(keys(%rh))) {
- Log3 ($name, 5, "runtimestring Key: $key, value: ".$rh{$key});
- }
-
- # Ergebnishash als Einzeiler zurückgeben bzw. an Schreibroutine übergeben
- my $rows = join('§', %rh);
-
- # Ergebnisse in Datenbank schreiben
- my ($wrt,$irowdone);
- if($prop =~ /writeToDB/) {
- ($wrt,$irowdone,$err) = DbRep_OutputWriteToDB($name,$device,$reading,$rows,"min");
- if ($err) {
- Log3 $hash->{NAME}, 2, "DbRep $name - $err";
- $err = encode_base64($err,"");
- return "$name|''|$device|$reading|''|$err|''";
- }
- $rt = $rt+$wrt;
- }
-
- my $rowlist = encode_base64($rows,"");
-
- # Background-Laufzeit ermitteln
- my $brt = tv_interval($bst);
-
- $rt = $rt.",".$brt;
-
- return "$name|$rowlist|$device|$reading|$rt|0|$irowdone";
-}
-
-####################################################################################################
-# Auswertungsroutine der nichtblockierenden DB-Abfrage minValue
-####################################################################################################
-sub minval_ParseDone($) {
- my ($string) = @_;
- my @a = split("\\|",$string);
- my $hash = $defs{$a[0]};
- my $name = $hash->{NAME};
- my $rowlist = decode_base64($a[1]);
- my $device = $a[2];
- $device =~ s/[^A-Za-z\/\d_\.-]/\//g;
- my $reading = $a[3];
- $reading =~ s/[^A-Za-z\/\d_\.-]/\//g;
- my $bt = $a[4];
- my ($rt,$brt) = split(",", $bt);
- my $err = $a[5]?decode_base64($a[5]):undef;
- my $irowdone = $a[6];
- my $reading_runtime_string;
-
- if ($err) {
- ReadingsSingleUpdateValue ($hash, "errortext", $err, 1);
- ReadingsSingleUpdateValue ($hash, "state", "error", 1);
- delete($hash->{HELPER}{RUNNING_PID});
- return;
- }
-
- my %rh = split("§", $rowlist);
-
- Log3 ($name, 5, "DbRep $name - result of minValue calculation after decoding:");
- foreach my $key (sort(keys(%rh))) {
- Log3 ($name, 5, "DbRep $name - runtimestring Key: $key, value: ".$rh{$key});
- }
-
- # Readingaufbereitung
- readingsBeginUpdate($hash);
-
- # only for this block because of warnings if details of readings are not set
- no warnings 'uninitialized';
-
- foreach my $key (sort(keys(%rh))) {
- my @k = split("\\|",$rh{$key});
- my $rsf = $k[2]."__" if($k[2]);
-
- if (AttrVal($hash->{NAME}, "readingNameMap", "")) {
- $reading_runtime_string = $rsf.AttrVal($hash->{NAME}, "readingNameMap", "")."__".$k[0];
- } else {
- my $ds = $device."__" if ($device);
- my $rds = $reading."__" if ($reading);
- $reading_runtime_string = $rsf.$ds.$rds."MIN__".$k[0];
- }
- my $rv = $k[1];
-
- ReadingsBulkUpdateValue ($hash, $reading_runtime_string, defined($rv)?sprintf("%.4f",$rv):"-");
- }
-
- ReadingsBulkUpdateValue ($hash, "db_lines_processed", $irowdone) if($hash->{LASTCMD} =~ /writeToDB/);
- ReadingsBulkUpdateTimeState($hash,$brt,$rt,"done");
- readingsEndUpdate($hash, 1);
-
- delete($hash->{HELPER}{RUNNING_PID});
-
-return;
-}
-
-####################################################################################################
-# nichtblockierende DB-Abfrage diffValue
-####################################################################################################
-sub diffval_DoParse($) {
- my ($string) = @_;
- my ($name,$device,$reading,$prop,$ts) = split("\\§", $string);
- my $hash = $defs{$name};
- my $dbloghash = $hash->{dbloghash};
- my $dbconn = $dbloghash->{dbconn};
- my $dbuser = $dbloghash->{dbuser};
- my $dblogname = $dbloghash->{NAME};
- my $dbmodel = $dbloghash->{MODEL};
- my $dbpassword = $attr{"sec$dblogname"}{secret};
- my ($dbh,$sql,$sth,$err,$selspec);
-
- # Background-Startzeit
- my $bst = [gettimeofday];
-
- eval {$dbh = DBI->connect("dbi:$dbconn", $dbuser, $dbpassword, { PrintError => 0, RaiseError => 1, AutoInactiveDestroy => 1 });};
-
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- return "$name|''|$device|$reading|''|''|''|$err|''";
- }
-
- # only for this block because of warnings if details of readings are not set
- no warnings 'uninitialized';
-
- # ist Zeiteingrenzung und/oder Aggregation gesetzt ? (wenn ja -> "?" in SQL sonst undef)
- my ($IsTimeSet,$IsAggrSet) = DbRep_checktimeaggr($hash);
- Log3 ($name, 5, "DbRep $name - IsTimeSet: $IsTimeSet, IsAggrSet: $IsAggrSet");
-
- # Timestampstring to Array
- my @ts = split("\\|", $ts);
- Log3 ($name, 5, "DbRep $name - Timestamp-Array: \n@ts");
-
- #vorbereiten der DB-Abfrage, DB-Modell-abhaengig
- if($dbmodel eq "MYSQL") {
- $selspec = "TIMESTAMP,VALUE, if(VALUE-\@V < 0 OR \@RB = 1 , \@diff:= 0, \@diff:= VALUE-\@V ) as DIFF, \@V:= VALUE as VALUEBEFORE, \@RB:= '0' as RBIT ";
- } else {
- $selspec = "TIMESTAMP,VALUE";
- }
-
- # SQL-Startzeit
- my $st = [gettimeofday];
-
- # DB-Abfrage zeilenweise für jeden Array-Eintrag
- my @row_array;
- my @array;
-
- foreach my $row (@ts) {
- my @a = split("#", $row);
- my $runtime_string = $a[0];
- my $runtime_string_first = $a[1];
- my $runtime_string_next = $a[2];
- $runtime_string = encode_base64($runtime_string,"");
-
- if($dbmodel eq "MYSQL") {
- eval {$dbh->do("set \@V:= 0, \@diff:= 0, \@diffTotal:= 0, \@RB:= 1;");}; # @\RB = Resetbit wenn neues Selektionsintervall beginnt
- }
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- $dbh->disconnect;
- return "$name|''|$device|$reading|''|''|''|$err|''";
- }
-
- if ($IsTimeSet || $IsAggrSet) {
- $sql = DbRep_createSelectSql($hash,"history",$selspec,$device,$reading,"'$runtime_string_first'","'$runtime_string_next'",'');
- } else {
- $sql = DbRep_createSelectSql($hash,"history",$selspec,$device,$reading,undef,undef,'');
- }
- Log3 ($name, 4, "DbRep $name - SQL execute: $sql");
-
- eval{ $sth = $dbh->prepare($sql);
- $sth->execute();
- };
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- $dbh->disconnect;
- return "$name|''|$device|$reading|''|''|''|$err|''";
-
- } else {
- if($dbmodel eq "MYSQL") {
- @array = map { $runtime_string." ".$_ -> [0]." ".$_ -> [1]." ".$_ -> [2]."\n" } @{ $sth->fetchall_arrayref() };
- } else {
- @array = map { $runtime_string." ".$_ -> [0]." ".$_ -> [1]."\n" } @{ $sth->fetchall_arrayref() };
-
- if (@array) {
- my @sp;
- my $dse = 0;
- my $vold;
- my @sqlite_array;
- foreach my $row (@array) {
- @sp = split("[ \t][ \t]*", $row, 4);
- my $runtime_string = $sp[0];
- my $timestamp = $sp[2]?$sp[1]." ".$sp[2]:$sp[1];
- my $vnew = $sp[3];
- $vnew =~ tr/\n//d;
-
- $dse = ($vold && (($vnew-$vold) > 0))?($vnew-$vold):0;
- @sp = $runtime_string." ".$timestamp." ".$vnew." ".$dse."\n";
- $vold = $vnew;
- push(@sqlite_array, @sp);
- }
- @array = @sqlite_array;
- }
- }
-
- if(!@array) {
- if(AttrVal($name, "aggregation", "") eq "hour") {
- my @rsf = split(/[" "\|":"]/,$runtime_string_first);
- @array = ($runtime_string." ".$rsf[0]."_".$rsf[1]."\n");
- } else {
- my @rsf = split(" ",$runtime_string_first);
- @array = ($runtime_string." ".$rsf[0]."\n");
- }
- }
- push(@row_array, @array);
- }
- }
-
- # SQL-Laufzeit ermitteln
- my $rt = tv_interval($st);
-
- $dbh->disconnect;
-
- Log3 ($name, 5, "DbRep $name - raw data of row_array result:\n @row_array");
-
- my $difflimit = AttrVal($name, "diffAccept", "20"); # legt fest, bis zu welchem Wert Differenzen akzeptiert werden (Ausreißer eliminieren)
-
- # Berechnung diffValue aus Selektionshash
- my %rh = (); # Ergebnishash, wird alle Ergebniszeilen enthalten
- my %ch = (); # counthash, enthält die Anzahl der verarbeiteten Datasets pro runtime_string
- my $lastruntimestring;
- my $i = 1;
- my $lval; # immer der letzte Wert von $value
- my $rslval; # runtimestring von lval
- my $uediff; # Übertragsdifferenz (Differenz zwischen letzten Wert einer Aggregationsperiode und dem ersten Wert der Folgeperiode)
- my $diff_current; # Differenzwert des aktuellen Datasets
- my $diff_before; # Differenzwert vorheriger Datensatz
- my $rejectstr; # String der ignorierten Differenzsätze
- my $diff_total; # Summenwert aller berücksichtigten Teildifferenzen
- my $max = ($#row_array)+1; # Anzahl aller Listenelemente
-
- Log3 ($name, 5, "DbRep $name - data of row_array result assigned to fields:\n");
-
- foreach my $row (@row_array) {
- my @a = split("[ \t][ \t]*", $row, 6);
- my $runtime_string = decode_base64($a[0]);
- $lastruntimestring = $runtime_string if ($i == 1);
- my $timestamp = $a[2]?$a[1]."_".$a[2]:$a[1];
- my $value = $a[3]?$a[3]:0;
- my $diff = $a[4]?sprintf("%.4f",$a[4]):0;
-
-# if ($uediff) {
-# $diff = $diff + $uediff;
-# Log3 ($name, 4, "DbRep $name - balance difference of $uediff between $rslval and $runtime_string");
-# $uediff = 0;
-# }
-
- # Leerzeichen am Ende $timestamp entfernen
- $timestamp =~ s/\s+$//g;
-
- # Test auf $value = "numeric"
- if (!looks_like_number($value)) {
- $a[3] =~ s/\s+$//g;
- Log3 ($name, 2, "DbRep $name - ERROR - value isn't numeric in diffValue function. Faulty dataset was \nTIMESTAMP: $timestamp, DEVICE: $device, READING: $reading, VALUE: $value.");
- $err = encode_base64("Value isn't numeric. Faulty dataset was - TIMESTAMP: $timestamp, VALUE: $value", "");
- return "$name|''|$device|$reading|''|''|''|$err|''";
- }
-
- Log3 ($name, 5, "DbRep $name - Runtimestring: $runtime_string, DEVICE: $device, READING: $reading, \nTIMESTAMP: $timestamp, VALUE: $value, DIFF: $diff");
-
- # String ignorierter Zeilen erzeugen
- $diff_current = $timestamp." ".$diff;
- if($diff > $difflimit) {
- $rejectstr .= $diff_before." -> ".$diff_current."\n";
- }
- $diff_before = $diff_current;
-
- # Ergebnishash erzeugen
- if ($runtime_string eq $lastruntimestring) {
- if ($i == 1) {
- $diff_total = $diff?$diff:0 if($diff <= $difflimit);
- $rh{$runtime_string} = $runtime_string."|".$diff_total."|".$timestamp;
- $ch{$runtime_string} = 1 if($value);
- $lval = $value;
- $rslval = $runtime_string;
- }
-
- if ($diff) {
- if($diff <= $difflimit) {
- $diff_total = $diff_total+$diff;
- }
- $rh{$runtime_string} = $runtime_string."|".$diff_total."|".$timestamp;
- $ch{$runtime_string}++ if($value && $i > 1);
- $lval = $value;
- $rslval = $runtime_string;
- }
- } else {
- # neuer Zeitabschnitt beginnt, ersten Value-Wert erfassen und Übertragsdifferenz bilden
- $lastruntimestring = $runtime_string;
- $i = 1;
-
- $uediff = $value - $lval if($value > $lval);
- $diff = $uediff;
- $lval = $value if($value); # Übetrag über Perioden mit value = 0 hinweg !
- $rslval = $runtime_string;
- Log3 ($name, 4, "DbRep $name - balance difference of $uediff between $rslval and $runtime_string");
-
-
- $diff_total = $diff?$diff:0 if($diff <= $difflimit);
- $rh{$runtime_string} = $runtime_string."|".$diff_total."|".$timestamp;
- $ch{$runtime_string} = 1 if($value);
-
- $uediff = 0;
- }
- $i++;
- }
-
- Log3 ($name, 4, "DbRep $name - result of diffValue calculation before encoding:");
- foreach my $key (sort(keys(%rh))) {
- Log3 ($name, 4, "runtimestring Key: $key, value: ".$rh{$key});
- }
-
- my $ncp = DbRep_calcount($hash,\%ch);
-
- my ($ncps,$ncpslist);
- if(%$ncp) {
- Log3 ($name, 3, "DbRep $name - time/aggregation periods containing only one dataset -> no diffValue calc was possible in period:");
- foreach my $key (sort(keys%{$ncp})) {
- Log3 ($name, 3, $key) ;
- }
- $ncps = join('§', %$ncp);
- $ncpslist = encode_base64($ncps,"");
- }
-
- # Ergebnishash als Einzeiler zurückgeben
- # ignorierte Zeilen ($diff > $difflimit)
- my $rowsrej = encode_base64($rejectstr,"") if($rejectstr);
-
- # Ergebnishash
- my $rows = join('§', %rh);
-
- # Ergebnisse in Datenbank schreiben
- my ($wrt,$irowdone);
- if($prop =~ /writeToDB/) {
- ($wrt,$irowdone,$err) = DbRep_OutputWriteToDB($name,$device,$reading,$rows,"diff");
- if ($err) {
- Log3 $hash->{NAME}, 2, "DbRep $name - $err";
- $err = encode_base64($err,"");
- return "$name|''|$device|$reading|''|''|''|$err|''";
- }
- $rt = $rt+$wrt;
- }
-
- my $rowlist = encode_base64($rows,"");
-
- # Background-Laufzeit ermitteln
- my $brt = tv_interval($bst);
-
- $rt = $rt.",".$brt;
-
- return "$name|$rowlist|$device|$reading|$rt|$rowsrej|$ncpslist|0|$irowdone";
-}
-
-####################################################################################################
-# Auswertungsroutine der nichtblockierenden DB-Abfrage diffValue
-####################################################################################################
-sub diffval_ParseDone($) {
- my ($string) = @_;
- my @a = split("\\|",$string);
- my $hash = $defs{$a[0]};
- my $name = $hash->{NAME};
- my $rowlist = decode_base64($a[1]);
- my $device = $a[2];
- $device =~ s/[^A-Za-z\/\d_\.-]/\//g;
- my $reading = $a[3];
- $reading =~ s/[^A-Za-z\/\d_\.-]/\//g;
- my $bt = $a[4];
- my ($rt,$brt) = split(",", $bt);
- my $rowsrej = $a[5]?decode_base64($a[5]):undef; # String von Datensätzen die nicht berücksichtigt wurden (diff Schwellenwert Überschreitung)
- my $ncpslist = decode_base64($a[6]); # Hash von Perioden die nicht kalkuliert werden konnten "no calc in period"
- my $err = $a[7]?decode_base64($a[7]):undef;
- my $irowdone = $a[8];
- my $reading_runtime_string;
- my $difflimit = AttrVal($name, "diffAccept", "20"); # legt fest, bis zu welchem Wert Differenzen akzeptoert werden (Ausreißer eliminieren)AttrVal($name, "diffAccept", "20");
-
- if ($err) {
- ReadingsSingleUpdateValue ($hash, "errortext", $err, 1);
- ReadingsSingleUpdateValue ($hash, "state", "error", 1);
- delete($hash->{HELPER}{RUNNING_PID});
- return;
- }
-
- # only for this block because of warnings if details of readings are not set
- no warnings 'uninitialized';
-
- # Auswertung hashes für state-Warning
- $rowsrej =~ s/_/ /g;
- Log3 ($name, 3, "DbRep $name -> data ignored while calc diffValue due to threshold overrun (diffAccept = $difflimit): \n$rowsrej")
- if($rowsrej);
- $rowsrej =~ s/\n/ \|\| /g;
-
- my %ncp = split("§", $ncpslist);
- my $ncpstr;
- if(%ncp) {
- foreach my $ncpkey (sort(keys(%ncp))) {
- $ncpstr .= $ncpkey." || ";
- }
- }
-
- # Readingaufbereitung
- my %rh = split("§", $rowlist);
-
- Log3 ($name, 4, "DbRep $name - result of diffValue calculation after decoding:");
- foreach my $key (sort(keys(%rh))) {
- Log3 ($name, 4, "DbRep $name - runtimestring Key: $key, value: ".$rh{$key});
- }
-
- readingsBeginUpdate($hash);
-
- foreach my $key (sort(keys(%rh))) {
- my @k = split("\\|",$rh{$key});
- my $rts = $k[2]."__";
- $rts =~ s/:/-/g; # substituieren unsupported characters -> siehe fhem.pl
-
- if (AttrVal($hash->{NAME}, "readingNameMap", "")) {
- $reading_runtime_string = $rts.AttrVal($hash->{NAME}, "readingNameMap", "")."__".$k[0];
- } else {
- my $ds = $device."__" if ($device);
- my $rds = $reading."__" if ($reading);
- $reading_runtime_string = $rts.$ds.$rds."DIFF__".$k[0];
- }
- my $rv = $k[1];
-
- ReadingsBulkUpdateValue ($hash, $reading_runtime_string, $rv?sprintf("%.4f",$rv):"-");
-
- }
-
- ReadingsBulkUpdateValue ($hash, "db_lines_processed", $irowdone) if($hash->{LASTCMD} =~ /writeToDB/);
- ReadingsBulkUpdateValue ($hash, "diff_overrun_limit_".$difflimit, $rowsrej) if($rowsrej);
- ReadingsBulkUpdateValue ($hash, "less_data_in_period", $ncpstr) if($ncpstr);
- ReadingsBulkUpdateTimeState($hash,$brt,$rt,($ncpstr||$rowsrej)?"Warning":"done");
-
- readingsEndUpdate($hash, 1);
-
- delete($hash->{HELPER}{RUNNING_PID});
-
-return;
-}
-
-####################################################################################################
-# nichtblockierende DB-Abfrage sumValue
-####################################################################################################
-sub sumval_DoParse($) {
- my ($string) = @_;
- my ($name,$device,$reading,$prop,$ts) = split("\\§", $string);
- my $hash = $defs{$name};
- my $dbloghash = $hash->{dbloghash};
- my $dbconn = $dbloghash->{dbconn};
- my $dbuser = $dbloghash->{dbuser};
- my $dblogname = $dbloghash->{NAME};
- my $dbpassword = $attr{"sec$dblogname"}{secret};
- my ($dbh,$sql,$sth,$err,$selspec);
-
- # Background-Startzeit
- my $bst = [gettimeofday];
-
- eval {$dbh = DBI->connect("dbi:$dbconn", $dbuser, $dbpassword, { PrintError => 0, RaiseError => 1, AutoInactiveDestroy => 1 });};
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- return "$name|''|$device|$reading|''|$err|''";
- }
-
- # only for this block because of warnings if details of readings are not set
- no warnings 'uninitialized';
-
- # ist Zeiteingrenzung und/oder Aggregation gesetzt ? (wenn ja -> "?" in SQL sonst undef)
- my ($IsTimeSet,$IsAggrSet) = DbRep_checktimeaggr($hash);
- Log3 ($name, 5, "DbRep $name - IsTimeSet: $IsTimeSet, IsAggrSet: $IsAggrSet");
-
- # Timestampstring to Array
- my @ts = split("\\|", $ts);
- Log3 ($name, 5, "DbRep $name - Timestamp-Array: \n@ts");
-
- #vorbereiten der DB-Abfrage, DB-Modell-abhaengig
- if ($dbloghash->{MODEL} eq "POSTGRESQL") {
- $selspec = "SUM(VALUE::numeric)";
- } elsif ($dbloghash->{MODEL} eq "MYSQL") {
- $selspec = "SUM(VALUE)";
- } elsif ($dbloghash->{MODEL} eq "SQLITE") {
- $selspec = "SUM(VALUE)";
- } else {
- $selspec = "SUM(VALUE)";
- }
-
- # SQL-Startzeit
- my $st = [gettimeofday];
-
- # DB-Abfrage zeilenweise für jeden Array-Eintrag
- my $arrstr;
- foreach my $row (@ts) {
- my @a = split("#", $row);
- my $runtime_string = $a[0];
- my $runtime_string_first = $a[1];
- my $runtime_string_next = $a[2];
-
- if ($IsTimeSet || $IsAggrSet) {
- $sql = DbRep_createSelectSql($hash,"history",$selspec,$device,$reading,"'$runtime_string_first'","'$runtime_string_next'",'');
- } else {
- $sql = DbRep_createSelectSql($hash,"history",$selspec,$device,$reading,undef,undef,'');
- }
- Log3 ($name, 4, "DbRep $name - SQL execute: $sql");
-
- eval{ $sth = $dbh->prepare($sql);
- $sth->execute();
- };
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- $dbh->disconnect;
- return "$name|''|$device|$reading|''|$err|''";
- }
-
- # DB-Abfrage -> Ergebnis in @arr aufnehmen
- my @line = $sth->fetchrow_array();
-
- Log3 ($name, 5, "DbRep $name - SQL result: $line[0]") if($line[0]);
-
- if(AttrVal($name, "aggregation", "") eq "hour") {
- my @rsf = split(/[" "\|":"]/,$runtime_string_first);
- $arrstr .= $runtime_string."#".$line[0]."#".$rsf[0]."_".$rsf[1]."|";
- } else {
- my @rsf = split(" ",$runtime_string_first);
- $arrstr .= $runtime_string."#".$line[0]."#".$rsf[0]."|";
- }
- }
-
- $sth->finish;
- $dbh->disconnect;
-
- # SQL-Laufzeit ermitteln
- my $rt = tv_interval($st);
-
- # Ergebnisse in Datenbank schreiben
- my ($wrt,$irowdone);
- if($prop =~ /writeToDB/) {
- ($wrt,$irowdone,$err) = DbRep_OutputWriteToDB($name,$device,$reading,$arrstr,"sum");
- if ($err) {
- Log3 $hash->{NAME}, 2, "DbRep $name - $err";
- $err = encode_base64($err,"");
- return "$name|''|$device|$reading|''|$err|''";
- }
- $rt = $rt+$wrt;
- }
-
- # Daten müssen als Einzeiler zurückgegeben werden
- $arrstr = encode_base64($arrstr,"");
-
- # Background-Laufzeit ermitteln
- my $brt = tv_interval($bst);
-
- $rt = $rt.",".$brt;
-
- return "$name|$arrstr|$device|$reading|$rt|0|$irowdone";
-}
-
-####################################################################################################
-# Auswertungsroutine der nichtblockierenden DB-Abfrage sumValue
-####################################################################################################
-sub sumval_ParseDone($) {
- my ($string) = @_;
- my @a = split("\\|",$string);
- my $hash = $defs{$a[0]};
- my $name = $hash->{NAME};
- my $arrstr = decode_base64($a[1]);
- my $device = $a[2];
- $device =~ s/[^A-Za-z\/\d_\.-]/\//g;
- my $reading = $a[3];
- $reading =~ s/[^A-Za-z\/\d_\.-]/\//g;
- my $bt = $a[4];
- my ($rt,$brt) = split(",", $bt);
- my $err = $a[5]?decode_base64($a[5]):undef;
- my $irowdone = $a[6];
- my $reading_runtime_string;
-
- if ($err) {
- ReadingsSingleUpdateValue ($hash, "errortext", $err, 1);
- ReadingsSingleUpdateValue ($hash, "state", "error", 1);
- delete($hash->{HELPER}{RUNNING_PID});
- return;
- }
-
- # only for this block because of warnings if details of readings are not set
- no warnings 'uninitialized';
-
- # Readingaufbereitung
- readingsBeginUpdate($hash);
-
- my @arr = split("\\|", $arrstr);
- foreach my $row (@arr) {
- my @a = split("#", $row);
- my $runtime_string = $a[0];
- my $c = $a[1];
- my $rsf = $a[2]."__";
-
- if (AttrVal($hash->{NAME}, "readingNameMap", "")) {
- $reading_runtime_string = $rsf.AttrVal($hash->{NAME}, "readingNameMap", "")."__".$runtime_string;
- } else {
- my $ds = $device."__" if ($device);
- my $rds = $reading."__" if ($reading);
- $reading_runtime_string = $rsf.$ds.$rds."SUM__".$runtime_string;
- }
-
- ReadingsBulkUpdateValue ($hash, $reading_runtime_string, $c?sprintf("%.4f",$c):"-");
- }
-
- ReadingsBulkUpdateValue ($hash, "db_lines_processed", $irowdone) if($hash->{LASTCMD} =~ /writeToDB/);
- ReadingsBulkUpdateTimeState($hash,$brt,$rt,"done");
- readingsEndUpdate($hash, 1);
-
- delete($hash->{HELPER}{RUNNING_PID});
-
-return;
-}
-
-####################################################################################################
-# nichtblockierendes DB delete
-####################################################################################################
-sub del_DoParse($) {
- my ($string) = @_;
- my ($name,$table,$device,$reading,$runtime_string_first,$runtime_string_next) = split("\\|", $string);
- my $hash = $defs{$name};
- my $dbloghash = $hash->{dbloghash};
- my $dbconn = $dbloghash->{dbconn};
- my $dbuser = $dbloghash->{dbuser};
- my $dblogname = $dbloghash->{NAME};
- my $dbpassword = $attr{"sec$dblogname"}{secret};
- my ($dbh,$sql,$sth,$err,$rows);
-
- # Background-Startzeit
- my $bst = [gettimeofday];
-
- eval {$dbh = DBI->connect("dbi:$dbconn", $dbuser, $dbpassword, { PrintError => 0, RaiseError => 1, AutoCommit => 1, AutoInactiveDestroy => 1 });};
-
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- return "$name|''|''|$err|''|''|''";
- }
-
- # ist Zeiteingrenzung und/oder Aggregation gesetzt ? (wenn ja -> "?" in SQL sonst undef)
- my ($IsTimeSet,$IsAggrSet) = DbRep_checktimeaggr($hash);
- Log3 ($name, 5, "DbRep $name - IsTimeSet: $IsTimeSet, IsAggrSet: $IsAggrSet");
-
- # SQL zusammenstellen für DB-Operation
- if ($IsTimeSet || $IsAggrSet) {
- $sql = DbRep_createDeleteSql($hash,$table,$device,$reading,$runtime_string_first,$runtime_string_next,'');
- } else {
- $sql = DbRep_createDeleteSql($hash,$table,$device,$reading,undef,undef,'');
- }
-
- $sth = $dbh->prepare($sql);
-
- Log3 ($name, 4, "DbRep $name - SQL execute: $sql");
-
- # SQL-Startzeit
- my $st = [gettimeofday];
-
- eval {$sth->execute();};
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- $dbh->disconnect;
- return "$name|''|''|$err|''|''|''";
- }
-
- $rows = $sth->rows;
- $dbh->commit() if(!$dbh->{AutoCommit});
- $dbh->disconnect;
-
- # SQL-Laufzeit ermitteln
- my $rt = tv_interval($st);
-
- Log3 ($name, 5, "DbRep $name - Number of deleted rows: $rows");
-
- # Background-Laufzeit ermitteln
- my $brt = tv_interval($bst);
-
- $rt = $rt.",".$brt;
-
- return "$name|$rows|$rt|0|$table|$device|$reading";
-}
-
-####################################################################################################
-# Auswertungsroutine DB delete
-####################################################################################################
-sub del_ParseDone($) {
- my ($string) = @_;
- my @a = split("\\|",$string);
- my $hash = $defs{$a[0]};
- my $name = $hash->{NAME};
- my $rows = $a[1];
- my $bt = $a[2];
- my ($rt,$brt) = split(",", $bt);
- my $err = $a[3]?decode_base64($a[3]):undef;
- my $table = $a[4];
- my $device = $a[5];
- $device =~ s/[^A-Za-z\/\d_\.-]/\//g;
- my $reading = $a[6];
- $reading =~ s/[^A-Za-z\/\d_\.-]/\//g;
- my $erread;
-
- # Befehl nach Procedure ausführen
- $erread = DbRep_afterproc($hash, "delEntries");
-
- if ($err) {
- ReadingsSingleUpdateValue ($hash, "errortext", $err, 1);
- ReadingsSingleUpdateValue ($hash, "state", "error", 1);
- delete($hash->{HELPER}{RUNNING_PID});
- return;
- }
-
- # only for this block because of warnings if details of readings are not set
- no warnings 'uninitialized';
-
- my ($reading_runtime_string, $ds, $rds);
- if (AttrVal($hash->{NAME}, "readingNameMap", "")) {
- $reading_runtime_string = AttrVal($hash->{NAME}, "readingNameMap", "")."--DELETED_ROWS--";
- } else {
- $ds = $device."--" if ($device && $table ne "current");
- $rds = $reading."--" if ($reading && $table ne "current");
- $reading_runtime_string = $ds.$rds."--DELETED_ROWS_".uc($table)."--";
- }
-
- readingsBeginUpdate($hash);
-
- ReadingsBulkUpdateValue ($hash, $reading_runtime_string, $rows);
-
- $rows = ($table eq "current")?$rows:$ds.$rds.$rows;
- Log3 ($name, 3, "DbRep $name - Entries of $hash->{DATABASE}.$table deleted: $rows");
-
- my $state = $erread?$erread:"done";
- ReadingsBulkUpdateTimeState($hash,$brt,$rt,$state);
-
- readingsEndUpdate($hash, 1);
-
- delete($hash->{HELPER}{RUNNING_PID});
-
-return;
-}
-
-####################################################################################################
-# nichtblockierendes DB insert
-####################################################################################################
-sub insert_Push($) {
- my ($name) = @_;
- my $hash = $defs{$name};
- my $dbloghash = $hash->{dbloghash};
- my $dbconn = $dbloghash->{dbconn};
- my $dbuser = $dbloghash->{dbuser};
- my $dblogname = $dbloghash->{NAME};
- my $dbpassword = $attr{"sec$dblogname"}{secret};
- my $utf8 = defined($hash->{UTF8})?$hash->{UTF8}:0;
- my ($err,$sth);
-
- # Background-Startzeit
- my $bst = [gettimeofday];
-
- my $dbh;
- eval {$dbh = DBI->connect("dbi:$dbconn", $dbuser, $dbpassword, { PrintError => 0, RaiseError => 1, AutoCommit => 1, AutoInactiveDestroy => 1, mysql_enable_utf8 => $utf8 });};
-
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- return "$name|''|''|$err";
- }
-
- # check ob PK verwendet wird, @usepkx?Anzahl der Felder im PK:0 wenn kein PK, $pkx?Namen der Felder:none wenn kein PK
- my ($usepkh,$usepkc,$pkh,$pkc) = DbRep_checkUsePK($hash,$dbloghash,$dbh);
-
- my $i_timestamp = $hash->{HELPER}{I_TIMESTAMP};
- my $i_device = $hash->{HELPER}{I_DEVICE};
- my $i_type = $hash->{HELPER}{I_TYPE};
- my $i_event = $hash->{HELPER}{I_EVENT};
- my $i_reading = $hash->{HELPER}{I_READING};
- my $i_value = $hash->{HELPER}{I_VALUE};
- my $i_unit = $hash->{HELPER}{I_UNIT} ? $hash->{HELPER}{I_UNIT} : " ";
-
- # SQL zusammenstellen für DB-Operation
- Log3 ($name, 5, "DbRep $name -> data to insert Timestamp: $i_timestamp, Device: $i_device, Type: $i_type, Event: $i_event, Reading: $i_reading, Value: $i_value, Unit: $i_unit");
-
- # SQL-Startzeit
- my $st = [gettimeofday];
-
- # insert history mit/ohne primary key
- if ($usepkh && $dbloghash->{MODEL} eq 'MYSQL') {
- eval { $sth = $dbh->prepare("INSERT IGNORE INTO history (TIMESTAMP, DEVICE, TYPE, EVENT, READING, VALUE, UNIT) VALUES (?,?,?,?,?,?,?)"); };
- } elsif ($usepkh && $dbloghash->{MODEL} eq 'SQLITE') {
- eval { $sth = $dbh->prepare("INSERT OR IGNORE INTO history (TIMESTAMP, DEVICE, TYPE, EVENT, READING, VALUE, UNIT) VALUES (?,?,?,?,?,?,?)"); };
- } elsif ($usepkh && $dbloghash->{MODEL} eq 'POSTGRESQL') {
- eval { $sth = $dbh->prepare("INSERT INTO history (TIMESTAMP, DEVICE, TYPE, EVENT, READING, VALUE, UNIT) VALUES (?,?,?,?,?,?,?) ON CONFLICT DO NOTHING"); };
- } else {
- eval { $sth = $dbh->prepare("INSERT INTO history (TIMESTAMP, DEVICE, TYPE, EVENT, READING, VALUE, UNIT) VALUES (?,?,?,?,?,?,?)"); };
- }
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- $dbh->disconnect();
- return "$name|''|''|$err";
- }
-
- $dbh->begin_work();
-
- eval {$sth->execute($i_timestamp, $i_device, $i_type, $i_event, $i_reading, $i_value, $i_unit);};
-
- my $irow;
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - Insert new dataset into database failed".($usepkh?" (possible PK violation) ":": ")."$@");
- $dbh->rollback();
- $dbh->disconnect();
- return "$name|''|''|$err";
- } else {
- $dbh->commit();
- $irow = $sth->rows;
- $dbh->disconnect();
- }
-
- # SQL-Laufzeit ermitteln
- my $rt = tv_interval($st);
-
- # Background-Laufzeit ermitteln
- my $brt = tv_interval($bst);
-
- $rt = $rt.",".$brt;
-
- return "$name|$irow|$rt|0";
-}
-
-####################################################################################################
-# Auswertungsroutine DB insert
-####################################################################################################
-sub insert_Done($) {
- my ($string) = @_;
- my @a = split("\\|",$string);
- my $hash = $defs{$a[0]};
- my $name = $hash->{NAME};
- my $irow = $a[1];
- my $bt = $a[2];
- my ($rt,$brt) = split(",", $bt);
- my $err = $a[3]?decode_base64($a[3]):undef;
-
- my $i_timestamp = delete $hash->{HELPER}{I_TIMESTAMP};
- my $i_device = delete $hash->{HELPER}{I_DEVICE};
- my $i_type = delete $hash->{HELPER}{I_TYPE};
- my $i_event = delete $hash->{HELPER}{I_EVENT};
- my $i_reading = delete $hash->{HELPER}{I_READING};
- my $i_value = delete $hash->{HELPER}{I_VALUE};
- my $i_unit = delete $hash->{HELPER}{I_UNIT};
-
- if ($err) {
- ReadingsSingleUpdateValue ($hash, "errortext", $err, 1);
- ReadingsSingleUpdateValue ($hash, "state", "error", 1);
- delete($hash->{HELPER}{RUNNING_PID});
- return;
- }
-
- # only for this block because of warnings if details of readings are not set
- no warnings 'uninitialized';
-
- readingsBeginUpdate($hash);
-
- ReadingsBulkUpdateValue ($hash, "number_lines_inserted", $irow);
- ReadingsBulkUpdateValue ($hash, "data_inserted", $i_timestamp.", ".$i_device.", ".$i_type.", ".$i_event.", ".$i_reading.", ".$i_value.", ".$i_unit);
- ReadingsBulkUpdateTimeState($hash,$brt,$rt,"done");
-
- readingsEndUpdate($hash, 1);
-
- Log3 ($name, 5, "DbRep $name - Inserted into database $hash->{DATABASE} table 'history': Timestamp: $i_timestamp, Device: $i_device, Type: $i_type, Event: $i_event, Reading: $i_reading, Value: $i_value, Unit: $i_unit");
-
- delete($hash->{HELPER}{RUNNING_PID});
-
-return;
-}
-
-####################################################################################################
-# Current-Tabelle mit Device,Reading Kombinationen aus history auffüllen
-####################################################################################################
-sub currentfillup_Push($) {
- my ($string) = @_;
- my ($name,$device,$reading,$runtime_string_first,$runtime_string_next) = split("\\|", $string);
- my $hash = $defs{$name};
- my $dbloghash = $hash->{dbloghash};
- my $dbconn = $dbloghash->{dbconn};
- my $dbuser = $dbloghash->{dbuser};
- my $dblogname = $dbloghash->{NAME};
- my $dbpassword = $attr{"sec$dblogname"}{secret};
- my $utf8 = defined($hash->{UTF8})?$hash->{UTF8}:0;
- my ($err,$sth,$sql,$devs,$danz,$ranz);
-
- # Background-Startzeit
- my $bst = [gettimeofday];
-
- my $dbh;
- eval {$dbh = DBI->connect("dbi:$dbconn", $dbuser, $dbpassword, { PrintError => 0, RaiseError => 1, AutoCommit => 1, AutoInactiveDestroy => 1, mysql_enable_utf8 => $utf8 });};
-
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- return "$name|''|''|$err|''|''";
- }
-
- # check ob PK verwendet wird, @usepkx?Anzahl der Felder im PK:0 wenn kein PK, $pkx?Namen der Felder:none wenn kein PK
- my ($usepkh,$usepkc,$pkh,$pkc) = DbRep_checkUsePK($hash,$dbloghash,$dbh);
-
- # ist Zeiteingrenzung und/oder Aggregation gesetzt ? (wenn ja -> "?" in SQL sonst undef)
- my ($IsTimeSet,$IsAggrSet) = DbRep_checktimeaggr($hash);
- Log3 ($name, 5, "DbRep $name - IsTimeSet: $IsTimeSet, IsAggrSet: $IsAggrSet");
-
- ($devs,$danz,$reading,$ranz) = DbRep_specsForSql($hash,$device,$reading);
-
- # SQL-Startzeit
- my $st = [gettimeofday];
-
- # insert history mit/ohne primary key
- # SQL zusammenstellen für DB-Operation
- if ($usepkc && $dbloghash->{MODEL} eq 'MYSQL') {
- $sql = "INSERT IGNORE INTO current (TIMESTAMP,DEVICE,READING) SELECT timestamp,device,reading FROM history where ";
- $sql .= "DEVICE LIKE '$devs' AND " if($danz <= 1 && $devs !~ m(^%$) && $devs =~ m(\%));
- $sql .= "DEVICE = '$devs' AND " if($danz <= 1 && $devs !~ m(\%));
- $sql .= "DEVICE IN ($devs) AND " if($danz > 1);
- $sql .= "READING LIKE '$reading' AND " if($ranz <= 1 && $reading !~ m(^%$) && $reading =~ m(\%));
- $sql .= "READING = '$reading' AND " if($ranz <= 1 && $reading !~ m(\%));
- $sql .= "READING IN ($reading) AND " if($ranz > 1);
- if ($IsTimeSet) {
- $sql .= "TIMESTAMP >= '$runtime_string_first' AND TIMESTAMP < '$runtime_string_next' ";
- } else {
- $sql .= "1 ";
- }
- $sql .= "group by timestamp,device,reading ;";
-
- } elsif ($usepkc && $dbloghash->{MODEL} eq 'SQLITE') {
- $sql = "INSERT OR IGNORE INTO current (TIMESTAMP,DEVICE,READING) SELECT timestamp,device,reading FROM history where ";
- $sql .= "DEVICE LIKE '$devs' AND " if($danz <= 1 && $devs !~ m(^%$) && $devs =~ m(\%));
- $sql .= "DEVICE = '$devs' AND " if($danz <= 1 && $devs !~ m(\%));
- $sql .= "DEVICE IN ($devs) AND " if($danz > 1);
- $sql .= "READING LIKE '$reading' AND " if($ranz <= 1 && $reading !~ m(^%$) && $reading =~ m(\%));
- $sql .= "READING = '$reading' AND " if($ranz <= 1 && $reading !~ m(\%));
- $sql .= "READING IN ($reading) AND " if($ranz > 1);
- if ($IsTimeSet) {
- $sql .= "TIMESTAMP >= '$runtime_string_first' AND TIMESTAMP < '$runtime_string_next' ";
- } else {
- $sql .= "1 ";
- }
- $sql .= "group by timestamp,device,reading ;";
-
- } elsif ($usepkc && $dbloghash->{MODEL} eq 'POSTGRESQL') {
- $sql = "INSERT INTO current (DEVICE,TIMESTAMP,READING) SELECT device, (array_agg(timestamp ORDER BY reading ASC))[1], reading FROM history where ";
- $sql .= "DEVICE LIKE '$devs' AND " if($danz <= 1 && $devs !~ m(^%$) && $devs =~ m(\%));
- $sql .= "DEVICE = '$devs' AND " if($danz <= 1 && $devs !~ m(\%));
- $sql .= "DEVICE IN ($devs) AND " if($danz > 1);
- $sql .= "READING LIKE '$reading' AND " if($ranz <= 1 && $reading !~ m(^%$) && $reading =~ m(\%));
- $sql .= "READING = '$reading' AND " if($ranz <= 1 && $reading !~ m(\%));
- $sql .= "READING IN ($reading) AND " if($ranz > 1);
- if ($IsTimeSet) {
- $sql .= "TIMESTAMP >= '$runtime_string_first' AND TIMESTAMP < '$runtime_string_next' ";
- } else {
- $sql .= "true ";
- }
- $sql .= "group by device,reading ON CONFLICT ($pkc) DO NOTHING; ";
-
- } else {
- if($dbloghash->{MODEL} ne 'POSTGRESQL') {
- # MySQL und SQLite
- $sql = "INSERT INTO current (TIMESTAMP,DEVICE,READING) SELECT timestamp,device,reading FROM history where ";
- $sql .= "DEVICE LIKE '$devs' AND " if($danz <= 1 && $devs !~ m(^%$) && $devs =~ m(\%));
- $sql .= "DEVICE = '$devs' AND " if($danz <= 1 && $devs !~ m(\%));
- $sql .= "DEVICE IN ($devs) AND " if($danz > 1);
- $sql .= "READING LIKE '$reading' AND " if($ranz <= 1 && $reading !~ m(^%$) && $reading =~ m(\%));
- $sql .= "READING = '$reading' AND " if($ranz <= 1 && $reading !~ m(\%));
- $sql .= "READING IN ($reading) AND " if($ranz > 1);
- if ($IsTimeSet) {
- $sql .= "TIMESTAMP >= '$runtime_string_first' AND TIMESTAMP < '$runtime_string_next' ";
- } else {
- $sql .= "1 ";
- }
- $sql .= "group by device,reading ;";
- } else {
- # PostgreSQL
- $sql = "INSERT INTO current (DEVICE,TIMESTAMP,READING) SELECT device, (array_agg(timestamp ORDER BY reading ASC))[1], reading FROM history where ";
- $sql .= "DEVICE LIKE '$devs' AND " if($danz <= 1 && $devs !~ m(^%$) && $devs =~ m(\%));
- $sql .= "DEVICE = '$devs' AND " if($danz <= 1 && $devs !~ m(\%));
- $sql .= "DEVICE IN ($devs) AND " if($danz > 1);
- $sql .= "READING LIKE '$reading' AND " if($ranz <= 1 && $reading !~ m(^%$) && $reading =~ m(\%));
- $sql .= "READING = '$reading' AND " if($ranz <= 1 && $reading !~ m(\%));
- $sql .= "READING IN ($reading) AND " if($ranz > 1);
- if ($IsTimeSet) {
- $sql .= "TIMESTAMP >= '$runtime_string_first' AND TIMESTAMP < '$runtime_string_next' ";
- } else {
- $sql .= "true ";
- }
- $sql .= "group by device,reading;";
- }
- }
-
- # Log SQL Statement
- Log3 ($name, 4, "DbRep $name - SQL execute: $sql");
-
- eval { $sth = $dbh->prepare($sql); };
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- $dbh->disconnect();
- return "$name|''|''|$err|''|''";
- }
-
-
- my $irow;
- $dbh->begin_work();
-
- eval {$sth->execute();};
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - Insert new dataset into database failed".($usepkh?" (possible PK violation) ":": ")."$@");
- $dbh->rollback();
- $dbh->disconnect();
- return "$name|''|''|$err|''|''";
- } else {
- $dbh->commit();
- $irow = $sth->rows;
- $dbh->disconnect();
- }
-
- # SQL-Laufzeit ermitteln
- my $rt = tv_interval($st);
-
- # Background-Laufzeit ermitteln
- my $brt = tv_interval($bst);
-
- $rt = $rt.",".$brt;
-
- return "$name|$irow|$rt|0|$device|$reading";
-}
-
-####################################################################################################
-# Auswertungsroutine Current-Tabelle auffüllen
-####################################################################################################
-sub currentfillup_Done($) {
- my ($string) = @_;
- my @a = split("\\|",$string);
- my $hash = $defs{$a[0]};
- my $name = $hash->{NAME};
- my $irow = $a[1];
- my $bt = $a[2];
- my ($rt,$brt) = split(",", $bt);
- my $err = $a[3]?decode_base64($a[3]):undef;
- my $device = $a[4];
- my $reading = $a[5];
-
- undef $device if ($device =~ m(^%$));
- undef $reading if ($reading =~ m(^%$));
-
- if ($err) {
- ReadingsSingleUpdateValue ($hash, "errortext", $err, 1);
- ReadingsSingleUpdateValue ($hash, "state", "error", 1);
- delete($hash->{HELPER}{RUNNING_PID});
- return;
- }
-
- # only for this block because of warnings if details of readings are not set
- no warnings 'uninitialized';
-
- my $rowstr;
- $rowstr = $irow if(!$device && !$reading);
- $rowstr = $irow." - limited by device: ".$device if($device && !$reading);
- $rowstr = $irow." - limited by reading: ".$reading if(!$device && $reading);
- $rowstr = $irow." - limited by device: ".$device." and reading: ".$reading if($device && $reading);
-
- readingsBeginUpdate($hash);
- ReadingsBulkUpdateValue($hash, "number_lines_inserted", $rowstr);
- ReadingsBulkUpdateTimeState($hash,$brt,$rt,"done");
- readingsEndUpdate($hash, 1);
-
- Log3 ($name, 3, "DbRep $name - Table '$hash->{DATABASE}'.'current' filled up with rows: $rowstr");
-
- delete($hash->{HELPER}{RUNNING_PID});
-
-return;
-}
-
-####################################################################################################
-# nichtblockierendes DB deviceRename / readingRename
-####################################################################################################
-sub change_Push($) {
- my ($string) = @_;
- my ($name,$device,$reading,$runtime_string_first,$runtime_string_next) = split("\\|", $string);
- my $hash = $defs{$name};
- my $dbloghash = $hash->{dbloghash};
- my $dbconn = $dbloghash->{dbconn};
- my $dbuser = $dbloghash->{dbuser};
- my $dblogname = $dbloghash->{NAME};
- my $dbpassword = $attr{"sec$dblogname"}{secret};
- my $table = "history";
- my ($dbh,$err,$sql);
-
- # Background-Startzeit
- my $bst = [gettimeofday];
-
- eval {$dbh = DBI->connect("dbi:$dbconn", $dbuser, $dbpassword, { PrintError => 0, RaiseError => 1, AutoCommit => 1, AutoInactiveDestroy => 1 });};
-
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- return "$name|''|''|$err";
- }
-
- my $renmode = $hash->{HELPER}{RENMODE};
-
- # SQL-Startzeit
- my $st = [gettimeofday];
-
- my ($sth,$old,$new);
- eval { $dbh->begin_work() if($dbh->{AutoCommit}); }; # Transaktion wenn gewünscht und autocommit ein
- if ($@) {
- Log3($name, 2, "DbRep $name -> Error start transaction - $@");
- }
-
- if ($renmode eq "devren") {
- $old = delete $hash->{HELPER}{OLDDEV};
- $new = delete $hash->{HELPER}{NEWDEV};
-
- # SQL zusammenstellen für DB-Operation
- Log3 ($name, 5, "DbRep $name -> Rename old device name \"$old\" to new device name \"$new\" in database $dblogname ");
-
- # prepare DB operation
- $old =~ s/'/''/g; # escape ' with ''
- $new =~ s/'/''/g; # escape ' with ''
- $sql = "UPDATE history SET TIMESTAMP=TIMESTAMP,DEVICE='$new' WHERE DEVICE='$old'; ";
- Log3 ($name, 4, "DbRep $name - SQL execute: $sql");
- $sth = $dbh->prepare($sql) ;
-
- } elsif ($renmode eq "readren") {
- $old = delete $hash->{HELPER}{OLDREAD};
- $new = delete $hash->{HELPER}{NEWREAD};
-
- # SQL zusammenstellen für DB-Operation
- Log3 ($name, 5, "DbRep $name -> Rename old reading name \"$old\" to new reading name \"$new\" in database $dblogname ");
-
- # prepare DB operation
- $old =~ s/'/''/g; # escape ' with ''
- $new =~ s/'/''/g; # escape ' with ''
- $sql = "UPDATE history SET TIMESTAMP=TIMESTAMP,READING='$new' WHERE READING='$old'; ";
- Log3 ($name, 4, "DbRep $name - SQL execute: $sql");
- $sth = $dbh->prepare($sql) ;
-
- }
-
- $old =~ s/''/'/g; # escape back
- $new =~ s/''/'/g; # escape back
-
- my $urow;
- eval { $sth->execute(); };
- if ($@) {
- $err = encode_base64($@,"");
- my $m = ($renmode eq "devren")?"device":"reading";
- Log3 ($name, 2, "DbRep $name - Failed to rename old $m name \"$old\" to new $m name \"$new\": $@");
- $dbh->rollback() if(!$dbh->{AutoCommit});
- $dbh->disconnect();
- return "$name|''|''|$err";
- } else {
- $dbh->commit() if(!$dbh->{AutoCommit});
- $urow = $sth->rows;
- $dbh->disconnect();
- }
-
- # SQL-Laufzeit ermitteln
- my $rt = tv_interval($st);
-
- # Background-Laufzeit ermitteln
- my $brt = tv_interval($bst);
-
- $rt = $rt.",".$brt;
-
- return "$name|$urow|$rt|0|$old|$new";
-}
-
-####################################################################################################
-# nichtblockierendes DB deviceRename / readingRename
-####################################################################################################
-sub changeval_Push($) {
- my ($string) = @_;
- my ($name,$device,$reading,$runtime_string_first,$runtime_string_next,$ts) = split("\\§", $string);
- my $hash = $defs{$name};
- my $dbloghash = $hash->{dbloghash};
- my $dbconn = $dbloghash->{dbconn};
- my $dbuser = $dbloghash->{dbuser};
- my $dblogname = $dbloghash->{NAME};
- my $dbpassword = $attr{"sec$dblogname"}{secret};
- my $table = "history";
- my $complex = $hash->{HELPER}{COMPLEX}; # einfache oder komplexe Werteersetzung
- my ($dbh,$err,$sql,$urow);
-
- # Background-Startzeit
- my $bst = [gettimeofday];
-
- eval {$dbh = DBI->connect("dbi:$dbconn", $dbuser, $dbpassword, { PrintError => 0, RaiseError => 1, AutoCommit => 1, AutoInactiveDestroy => 1 });};
-
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- return "$name|''|''|$err";
- }
-
- # ist Zeiteingrenzung und/oder Aggregation gesetzt ? (wenn ja -> "?" in SQL sonst undef)
- my ($IsTimeSet,$IsAggrSet) = DbRep_checktimeaggr($hash);
- Log3 ($name, 5, "DbRep $name - IsTimeSet: $IsTimeSet, IsAggrSet: $IsAggrSet");
-
- # SQL-Startzeit
- my $st = [gettimeofday];
-
- my ($sth,$old,$new);
- eval { $dbh->begin_work() if($dbh->{AutoCommit}); }; # Transaktion wenn gewünscht und autocommit ein
- if ($@) {
- Log3($name, 2, "DbRep $name -> Error start transaction - $@");
- }
-
- if (!$complex) {
- $old = delete $hash->{HELPER}{OLDVAL};
- $new = delete $hash->{HELPER}{NEWVAL};
-
- # SQL zusammenstellen für DB-Operation
- Log3 ($name, 5, "DbRep $name -> Change old value \"$old\" to new value \"$new\" in database $dblogname ");
-
- # prepare DB operation
- $old =~ s/'/''/g; # escape ' with ''
- $new =~ s/'/''/g; # escape ' with ''
-
- # SQL zusammenstellen für DB-Update
- my $addon = $old =~ /%/?"WHERE VALUE LIKE '$old'":"WHERE VALUE='$old'";
- if ($IsTimeSet) {
- $sql = DbRep_createUpdateSql($hash,$table,"TIMESTAMP=TIMESTAMP,VALUE='$new' $addon",$device,$reading,"'$runtime_string_first'","'$runtime_string_next'",'');
- } else {
- $sql = DbRep_createUpdateSql($hash,$table,"TIMESTAMP=TIMESTAMP,VALUE='$new' $addon",$device,$reading,undef,undef,'');
- }
- Log3 ($name, 4, "DbRep $name - SQL execute: $sql");
- $sth = $dbh->prepare($sql) ;
-
- $old =~ s/''/'/g; # escape back
- $new =~ s/''/'/g; # escape back
-
- eval { $sth->execute(); };
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - Failed to change old value \"$old\" to new value \"$new\": $@");
- $dbh->rollback() if(!$dbh->{AutoCommit});
- $dbh->disconnect();
- return "$name|''|''|$err";
- } else {
- $dbh->commit() if(!$dbh->{AutoCommit});
- $urow = $sth->rows;
- }
-
- } else {
- $old = delete $hash->{HELPER}{OLDVAL};
- $new = delete $hash->{HELPER}{NEWVAL};
- $old =~ s/'/''/g; # escape ' with ''
-
- # Timestampstring to Array
- my @ts = split("\\|", $ts);
- Log3 ($name, 5, "DbRep $name - Timestamp-Array: \n@ts");
-
- # DB-Abfrage zeilenweise für jeden Array-Eintrag
- $urow = 0;
- my $selspec = "DEVICE,READING,TIMESTAMP,VALUE,UNIT";
- my $addon = $old =~ /%/?"AND VALUE LIKE '$old'":"AND VALUE='$old'";
- foreach my $row (@ts) {
- my @a = split("#", $row);
- my $runtime_string = $a[0];
- my $runtime_string_first = $a[1];
- my $runtime_string_next = $a[2];
-
- if ($IsTimeSet || $IsAggrSet) {
- $sql = DbRep_createSelectSql($hash,"history",$selspec,$device,$reading,"'$runtime_string_first'","'$runtime_string_next'",$addon);
- } else {
- $sql = DbRep_createSelectSql($hash,"history",$selspec,$device,$reading,undef,undef,$addon);
- }
- Log3 ($name, 4, "DbRep $name - SQL execute: $sql");
-
- eval{ $sth = $dbh->prepare($sql);
- $sth->execute();
- };
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- $dbh->disconnect;
- return "$name|''|''|$err";
- }
-
- no warnings 'uninitialized';
- # DEVICE _ESC_ READING _ESC_ DATE _ESC_ TIME _ESC_ VALUE _ESC_ UNIT
- my @row_array = map { $_->[0]."_ESC_".$_->[1]."_ESC_".($_->[2] =~ s/ /_ESC_/r)."_ESC_".$_->[3]."_ESC_".$_->[4]."\n" } @{$sth->fetchall_arrayref()};
- use warnings;
-
- Log3 ($name, 4, "DbRep $name - Now change values of selected array ... ");
-
- foreach my $upd (@row_array) {
- # für jeden selektierten (zu ändernden) Datensatz Userfunktion anwenden und updaten
- my ($device,$reading,$date,$time,$value,$unit) = ($upd =~ /^(.*)_ESC_(.*)_ESC_(.*)_ESC_(.*)_ESC_(.*)_ESC_(.*)$/);
-
- my $oval = $value; # Selektkriterium für Update alter Valuewert
- my $VALUE = $value;
- my $UNIT = $unit;
- eval $new;
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- $dbh->disconnect;
- return "$name|''|''|$err";
- }
-
- $value = $VALUE if(defined $VALUE);
- $unit = $UNIT if(defined $UNIT);
- # Daten auf maximale Länge beschneiden (DbLog-Funktion !)
- (undef,undef,undef,undef,$value,$unit) = DbLog_cutCol($hash->{dbloghash},"1","1","1","1",$value,$unit);
-
- $value =~ s/'/''/g; # escape ' with ''
- $unit =~ s/'/''/g; # escape ' with ''
-
- # SQL zusammenstellen für DB-Update
- $sql = "UPDATE history SET TIMESTAMP=TIMESTAMP,VALUE='$value',UNIT='$unit' WHERE TIMESTAMP = '$date $time' AND DEVICE = '$device' AND READING = '$reading' AND VALUE='$oval'";
- Log3 ($name, 5, "DbRep $name - SQL execute: $sql");
- $sth = $dbh->prepare($sql) ;
-
- $value =~ s/''/'/g; # escape back
- $unit =~ s/''/'/g; # escape back
-
- eval { $sth->execute(); };
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - Failed to change old value \"$old\" to new value \"$new\": $@");
- $dbh->rollback() if(!$dbh->{AutoCommit});
- $dbh->disconnect();
- return "$name|''|''|$err";
- } else {
- $dbh->commit() if(!$dbh->{AutoCommit});
- $urow++;
- }
- }
- }
- }
-
- $dbh->disconnect();
-
- # SQL-Laufzeit ermitteln
- my $rt = tv_interval($st);
-
- # Background-Laufzeit ermitteln
- my $brt = tv_interval($bst);
-
- $rt = $rt.",".$brt;
-
- return "$name|$urow|$rt|0|$old|$new";
-}
-
-####################################################################################################
-# Auswertungsroutine DB deviceRename/readingRename/changeValue
-####################################################################################################
-sub change_Done($) {
- my ($string) = @_;
- my @a = split("\\|",$string);
- my $hash = $defs{$a[0]};
- my $name = $hash->{NAME};
- my $urow = $a[1];
- my $bt = $a[2];
- my ($rt,$brt) = split(",", $bt);
- my $err = $a[3]?decode_base64($a[3]):undef;
- my $old = $a[4];
- my $new = $a[5];
-
- my $renmode = delete $hash->{HELPER}{RENMODE};
-
- # Befehl nach Procedure ausführen
- my $erread = DbRep_afterproc($hash, $renmode);
-
- if ($err) {
- ReadingsSingleUpdateValue ($hash, "errortext", $err, 1);
- ReadingsSingleUpdateValue ($hash, "state", "error", 1);
- delete($hash->{HELPER}{RUNNING_PID});
- return;
- }
-
- # only for this block because of warnings if details of readings are not set
- no warnings 'uninitialized';
-
- readingsBeginUpdate($hash);
- ReadingsBulkUpdateValue ($hash, "number_lines_updated", $urow);
-
- if($renmode eq "devren") {
- ReadingsBulkUpdateValue ($hash, "device_renamed", "old: ".$old." to new: ".$new) if($urow != 0);
- ReadingsBulkUpdateValue ($hash, "device_not_renamed", "Warning - old: ".$old." not found, not renamed to new: ".$new)
- if($urow == 0);
- }
- if($renmode eq "readren") {
- ReadingsBulkUpdateValue ($hash, "reading_renamed", "old: ".$old." to new: ".$new) if($urow != 0);
- ReadingsBulkUpdateValue ($hash, "reading_not_renamed", "Warning - old: ".$old." not found, not renamed to new: ".$new)
- if ($urow == 0);
- }
- if($renmode eq "changeval") {
- ReadingsBulkUpdateValue ($hash, "value_changed", "old: ".$old." to new: ".$new) if($urow != 0);
- ReadingsBulkUpdateValue ($hash, "value_not_changed", "Warning - old: ".$old." not found, not changed to new: ".$new)
- if ($urow == 0);
- }
-
- ReadingsBulkUpdateTimeState($hash,$brt,$rt,"done");
- readingsEndUpdate($hash, 1);
-
- if ($urow != 0) {
- Log3 ($name, 3, "DbRep ".(($hash->{ROLE} eq "Agent")?"Agent ":"")."$name - DEVICE renamed in \"$hash->{DATABASE}\", old: \"$old\", new: \"$new\", number: $urow ") if($renmode eq "devren");
- Log3 ($name, 3, "DbRep ".(($hash->{ROLE} eq "Agent")?"Agent ":"")."$name - READING renamed in \"$hash->{DATABASE}\", old: \"$old\", new: \"$new\", number: $urow ") if($renmode eq "readren");
- Log3 ($name, 3, "DbRep ".(($hash->{ROLE} eq "Agent")?"Agent ":"")."$name - VALUE changed in \"$hash->{DATABASE}\", old: \"$old\", new: \"$new\", number: $urow ") if($renmode eq "changeval");
- } else {
- Log3 ($name, 3, "DbRep ".(($hash->{ROLE} eq "Agent")?"Agent ":"")."$name - WARNING - old device \"$old\" was not found in database \"$hash->{DATABASE}\" ") if($renmode eq "devren");
- Log3 ($name, 3, "DbRep ".(($hash->{ROLE} eq "Agent")?"Agent ":"")."$name - WARNING - old reading \"$old\" was not found in database \"$hash->{DATABASE}\" ") if($renmode eq "readren");
- Log3 ($name, 3, "DbRep ".(($hash->{ROLE} eq "Agent")?"Agent ":"")."$name - WARNING - old value \"$old\" not found in database \"$hash->{DATABASE}\" ") if($renmode eq "changeval");
- }
-
- delete($hash->{HELPER}{RUNNING_PID});
-
-return;
-}
-
-####################################################################################################
-# nichtblockierende DB-Abfrage fetchrows
-####################################################################################################
-sub fetchrows_DoParse($) {
- my ($string) = @_;
- my ($name,$table,$device,$reading,$runtime_string_first,$runtime_string_next) = split("\\|", $string);
- my $hash = $defs{$name};
- my $dbloghash = $hash->{dbloghash};
- my $dbconn = $dbloghash->{dbconn};
- my $dbuser = $dbloghash->{dbuser};
- my $dblogname = $dbloghash->{NAME};
- my $dbpassword = $attr{"sec$dblogname"}{secret};
- my $limit = AttrVal($name, "limit", 1000);
- my $utf8 = defined($hash->{UTF8})?$hash->{UTF8}:0;
- my $fetchroute = AttrVal($name, "fetchRoute", "descent");
- my $valfilter = AttrVal($name, "valueFilter", undef); # nur Anzeige von Datensätzen die "valueFilter" enthalten
- $fetchroute = ($fetchroute eq "descent")?"DESC":"ASC";
- my ($err,$dbh,$sth,$sql,$rowlist,$nrows);
-
- # Background-Startzeit
- my $bst = [gettimeofday];
-
- eval {$dbh = DBI->connect("dbi:$dbconn", $dbuser, $dbpassword, { PrintError => 0, RaiseError => 1, AutoInactiveDestroy => 1, mysql_enable_utf8 => $utf8 });};
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- return "$name|''|''|$err|''";
- }
-
- # ist Zeiteingrenzung und/oder Aggregation gesetzt ? (wenn ja -> "?" in SQL sonst undef)
- my ($IsTimeSet,$IsAggrSet) = DbRep_checktimeaggr($hash);
- Log3 ($name, 5, "DbRep $name - IsTimeSet: $IsTimeSet, IsAggrSet: $IsAggrSet");
-
- # SQL zusammenstellen für DB-Abfrage
- if ($IsTimeSet) {
- $sql = DbRep_createSelectSql($hash,$table,"DEVICE,READING,TIMESTAMP,VALUE,UNIT",$device,$reading,"'$runtime_string_first'","'$runtime_string_next'","ORDER BY TIMESTAMP $fetchroute LIMIT ".($limit+1));
- } else {
- $sql = DbRep_createSelectSql($hash,$table,"DEVICE,READING,TIMESTAMP,VALUE,UNIT",$device,$reading,undef,undef,"ORDER BY TIMESTAMP $fetchroute LIMIT ".($limit+1));
- }
-
- $sth = $dbh->prepare($sql);
-
- Log3 ($name, 4, "DbRep $name - SQL execute: $sql");
-
- # SQL-Startzeit
- my $st = [gettimeofday];
-
- eval{$sth->execute();};
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- $dbh->disconnect;
- return "$name|''|''|$err|''";
- }
-
- no warnings 'uninitialized';
- my @row_array = map { $_->[0]."_ESC_".$_->[1]."_ESC_".($_->[2] =~ s/ /_ESC_/r)."_ESC_".$_->[3]."_ESC_".$_->[4]."\n" } @{$sth->fetchall_arrayref()};
-
- # eventuell gesetzten Datensatz-Filter anwenden
- if($valfilter) {
- my @fiarr;
- foreach my $row (@row_array) {
- next if($row !~ /$valfilter/);
- push @fiarr,$row;
- }
- @row_array = @fiarr;
- }
-
- use warnings;
- $nrows = $#row_array+1; # Anzahl der Ergebniselemente
- pop @row_array if($nrows>$limit); # das zuviel selektierte Element wegpoppen wenn Limit überschritten
-
- s/\|/_E#S#C_/g for @row_array; # escape Pipe "|"
- if ($utf8) {
- $rowlist = Encode::encode_utf8(join('|', @row_array));
- } else {
- $rowlist = join('|', @row_array);
- }
- Log3 ($name, 5, "DbRep $name -> row result list:\n$rowlist");
-
- # SQL-Laufzeit ermitteln
- my $rt = tv_interval($st);
-
- $dbh->disconnect;
-
- # Daten müssen als Einzeiler zurückgegeben werden
- $rowlist = encode_base64($rowlist,"");
-
- # Background-Laufzeit ermitteln
- my $brt = tv_interval($bst);
-
- $rt = $rt.",".$brt;
-
- return "$name|$rowlist|$rt|0|$nrows";
-}
-
-####################################################################################################
-# Auswertungsroutine der nichtblockierenden DB-Abfrage fetchrows
-####################################################################################################
-sub fetchrows_ParseDone($) {
- my ($string) = @_;
- my @a = split("\\|",$string);
- my $hash = $defs{$a[0]};
- my $rowlist = decode_base64($a[1]);
- my $bt = $a[2];
- my ($rt,$brt) = split(",", $bt);
- my $err = $a[3]?decode_base64($a[3]):undef;
- my $nrows = $a[4];
- my $name = $hash->{NAME};
- my $reading = AttrVal($name, "reading", undef);
- my $limit = AttrVal($name, "limit", 1000);
- my $color = ""; # Highlighting doppelter DB-Einträge
- $color =~ s/#// if($color =~ /red|blue|brown|green|orange/);
- my $ecolor = " "; # Ende Highlighting
- my @row;
- my $reading_runtime_string;
-
- if ($err) {
- ReadingsSingleUpdateValue ($hash, "errortext", $err, 1);
- ReadingsSingleUpdateValue ($hash, "state", "error", 1);
- delete($hash->{HELPER}{RUNNING_PID});
- return;
- }
-
- my @row_array = split("\\|", $rowlist);
- s/_E#S#C_/\|/g for @row_array; # escaped Pipe return to "|"
-
- Log3 ($name, 5, "DbRep $name - row_array decoded: @row_array");
-
- # Readingaufbereitung
- readingsBeginUpdate($hash);
- my ($orow,$nrow,$oval,$nval);
- my $dz = 1; # Index des Vorkommens im Selektionsarray
- my $zs = ""; # Zusatz wenn device + Reading + Timestamp von folgenden DS gleich ist UND Value unterschiedlich
- my $zsz = 1; # Zusatzzähler
- foreach my $row (@row_array) {
- my @a = split("_ESC_", $row, 6);
- my $dev = $a[0];
- my $rea = $a[1];
- $a[3] =~ s/:/-/g; # substituieren unsupported characters ":" -> siehe fhem.pl
- my $ts = $a[2]."_".$a[3];
- my $val = $a[4];
- my $unt = $a[5];
- $val = $unt?$val." ".$unt:$val;
-
- $nrow = $ts.$dev.$rea;
- $nval = $val;
- if($orow) {
- if($orow.$oval eq $nrow.$val) {
- $dz++;
- $zs = "";
- $zsz = 1;
- } else {
- # wenn device + Reading + Timestamp gleich ist UND Value unterschiedlich -> dann Zusatz an Reading hängen
- if(($orow eq $nrow) && ($oval ne $val)) {
- $zs = "_".$zsz;
- $zsz++;
- } else {
- $zs = "";
- $zsz = 1;
- }
- $dz = 1;
-
- }
- }
- $orow = $nrow;
- $oval = $val;
-
- if ($reading && AttrVal($hash->{NAME}, "readingNameMap", "")) {
- if($dz > 1 && AttrVal($name, "fetchMarkDuplicates", undef)) {
- $reading_runtime_string = $ts."__".$color.$dz."__".AttrVal($hash->{NAME}, "readingNameMap", "").$zs.$ecolor;
- } else {
- $reading_runtime_string = $ts."__".$dz."__".AttrVal($hash->{NAME}, "readingNameMap", "").$zs;
- }
- } else {
- if($dz > 1 && AttrVal($name, "fetchMarkDuplicates", undef)) {
- $reading_runtime_string = $ts."__".$color.$dz."__".$dev."__".$rea.$zs.$ecolor;
- } else {
- $reading_runtime_string = $ts."__".$dz."__".$dev."__".$rea.$zs;
- }
- }
-
- ReadingsBulkUpdateValue($hash, $reading_runtime_string, $val);
- }
- my $sfx = AttrVal("global", "language", "EN");
- $sfx = ($sfx eq "EN" ? "" : "_$sfx");
-
- ReadingsBulkUpdateValue($hash, "number_fetched_rows", ($nrows>$limit)?$nrows-1:$nrows);
- ReadingsBulkUpdateTimeState($hash,$brt,$rt,($nrows-$limit>0)?
- "done - Warning: present rows exceed specified limit, adjust attribute limit ":"done");
- readingsEndUpdate($hash, 1);
-
- delete($hash->{HELPER}{RUNNING_PID});
-
-return;
-}
-
-####################################################################################################
-# DB-Abfrage delSeqDoublets
-####################################################################################################
-sub delseqdoubl_DoParse($) {
- my ($string) = @_;
- my ($name,$opt,$device,$reading,$ts) = split("\\§", $string);
- my $hash = $defs{$name};
- my $dbloghash = $hash->{dbloghash};
- my $dbconn = $dbloghash->{dbconn};
- my $dbuser = $dbloghash->{dbuser};
- my $dblogname = $dbloghash->{NAME};
- my $dbpassword = $attr{"sec$dblogname"}{secret};
- my $utf8 = defined($hash->{UTF8})?$hash->{UTF8}:0;
- my $limit = AttrVal($name, "limit", 1000);
- my $var = AttrVal($name, "seqDoubletsVariance", undef);
- my $table = "history";
- my ($err,$dbh,$sth,$sql,$rowlist,$nrows,$selspec,$st,$var1,$var2);
-
- # Background-Startzeit
- my $bst = [gettimeofday];
-
- eval {$dbh = DBI->connect("dbi:$dbconn", $dbuser, $dbpassword, { PrintError => 0, RaiseError => 1, AutoInactiveDestroy => 1, mysql_enable_utf8 => $utf8 });};
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- return "$name|''|''|$err|''|$opt";
- }
-
- # Timestampstring to Array
- my @ts = split("\\|", $ts);
- Log3 ($name, 5, "DbRep $name - Timestamp-Array: \n@ts");
-
- $selspec = "DEVICE,READING,TIMESTAMP,VALUE";
-
- # SQL zusammenstellen für DB-Abfrage
- $sql = DbRep_createSelectSql($hash,$table,$selspec,$device,$reading,"?","?","ORDER BY DEVICE,READING,TIMESTAMP ASC");
- $sth = $dbh->prepare_cached($sql);
-
- # DB-Abfrage zeilenweise für jeden Timearray-Eintrag
- my @remain;
- my @todel;
- my $nremain = 0;
- my $ntodel = 0;
- my $ndel = 0;
- my $rt = 0;
-
- no warnings 'uninitialized';
-
- foreach my $row (@ts) {
- my @a = split("#", $row);
- my $runtime_string = $a[0];
- my $runtime_string_first = $a[1];
- my $runtime_string_next = $a[2];
- $runtime_string = encode_base64($runtime_string,"");
-
- # SQL-Startzeit
- $st = [gettimeofday];
-
- # SQL zusammenstellen für Logausgabe
- my $sql1 = DbRep_createSelectSql($hash,$table,$selspec,$device,$reading,"'$runtime_string_first'","'$runtime_string_next'",'');
- Log3 ($name, 4, "DbRep $name - SQL execute: $sql1");
-
- eval{$sth->execute($runtime_string_first, $runtime_string_next);};
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- $dbh->disconnect;
- return "$name|''|''|$err|''|$opt";
- }
-
- # SQL-Laufzeit ermitteln
- $rt = $rt+tv_interval($st);
-
- # Beginn Löschlogik, Zusammenstellen der löschenden DS (warping)
- # Array @sel -> die VERBLEIBENDEN Datensätze, @warp -> die zu löschenden Datensätze
- my (@sel,@warp);
- my ($or,$oor,$odev,$oread,$oval,$ooval,$ndev,$nread,$nval);
- my $i = 0;
- foreach my $nr (map { $_->[0]."_ESC_".$_->[1]."_ESC_".($_->[2] =~ s/ /_ESC_/r)."_ESC_".$_->[3] } @{$sth->fetchall_arrayref()}) {
- ($ndev,$nread,undef,undef,$nval) = split("_ESC_", $nr); # Werte des aktuellen Elements
- $or = pop @sel; # das letzte Element der Liste
- ($odev,$oread,undef,undef,$oval) = split("_ESC_", $or); # Value des letzten Elements
- if (looks_like_number($oval) && $var) { # Varianz +- falls $val numerischer Wert
- $var1 = $oval + $var;
- $var2 = $oval - $var;
- } else {
- undef $var1;
- undef $var2;
- }
- $oor = pop @sel; # das vorletzte Element der Liste
- $ooval = (split '_ESC_', $oor)[-1]; # Value des vorletzten Elements
- if ($ndev.$nread ne $odev.$oread) {
- $i = 0; # neues Device/Reading in einer Periode -> ooor soll erhalten bleiben
- push (@sel,$oor) if($oor);
- push (@sel,$or) if($or);
- push (@sel,$nr);
- } elsif ($i>=2 && ($ooval eq $oval && $oval eq $nval) || ($i>=2 && $var1 && $var2 && ($ooval <= $var1) && ($var2 <= $ooval) && ($nval <= $var1) && ($var2 <= $nval)) ) {
- push (@sel,$oor);
- push (@sel,$nr);
- push (@warp,$or); # Array der zu löschenden Datensätze
- if ($opt =~ /delete/ && $or) { # delete Datensätze
- my ($dev,$read,$date,$time,$val) = split("_ESC_", $or);
- my $dt = $date." ".$time;
- chomp($val);
- $dev =~ s/'/''/g; # escape ' with ''
- $read =~ s/'/''/g; # escape ' with ''
- $val =~ s/'/''/g; # escape ' with ''
- $st = [gettimeofday];
- my $dsql = "delete FROM $table where TIMESTAMP = '$dt' AND DEVICE = '$dev' AND READING = '$read' AND VALUE = '$val';";
- my $sthd = $dbh->prepare($dsql);
- Log3 ($name, 4, "DbRep $name - SQL execute: $dsql");
-
- eval {$sthd->execute();};
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- $dbh->disconnect;
- return "$name|''|''|$err|''|$opt";
- }
- $ndel = $ndel+$sthd->rows;
- $dbh->commit() if(!$dbh->{AutoCommit});
-
- $rt = $rt+tv_interval($st);
- }
- } else {
- push (@sel,$oor) if($oor);
- push (@sel,$or) if($or);
- push (@sel,$nr);
- }
- $i++;
- }
- if(@sel && $opt =~ /adviceRemain/) {
- # die verbleibenden Datensätze nach Ausführung (nur zur Anzeige)
- push(@remain,@sel) if($#remain+1 < $limit);
- }
- if(@warp && $opt =~ /adviceDelete/) {
- # die zu löschenden Datensätze (nur zur Anzeige)
- push(@todel,@warp) if($#todel+1 < $limit);
- }
-
- $nremain = $nremain + $#sel+1 if(@sel);
- $ntodel = $ntodel + $#warp+1 if(@warp);
- my $sum = $nremain+$ntodel;
- Log3 ($name, 3, "DbRep $name -> rows analyzed by \"$hash->{LASTCMD}\": $sum") if($sum && $opt =~ /advice/);
- }
-
- Log3 ($name, 3, "DbRep $name -> rows deleted by \"$hash->{LASTCMD}\": $ndel") if($ndel);
-
- my $retn = ($opt =~ /adviceRemain/)?$nremain:($opt =~ /adviceDelete/)?$ntodel:$ndel;
-
- my @retarray = ($opt =~ /adviceRemain/)?@remain:($opt =~ /adviceDelete/)?@todel:" ";
- s/\|/_E#S#C_/g for @retarray; # escape Pipe "|"
- if ($utf8 && @retarray) {
- $rowlist = Encode::encode_utf8(join('|', @retarray));
- } elsif(@retarray) {
- $rowlist = join('|', @retarray);
- } else {
- $rowlist = 0;
- }
-
- use warnings;
- Log3 ($name, 5, "DbRep $name -> row result list:\n$rowlist");
-
- $dbh->disconnect;
-
- # Daten müssen als Einzeiler zurückgegeben werden
- $rowlist = encode_base64($rowlist,"");
-
- # Background-Laufzeit ermitteln
- my $brt = tv_interval($bst);
-
- $rt = $rt.",".$brt;
-
-return "$name|$rowlist|$rt|0|$retn|$opt";
-}
-
-####################################################################################################
-# Auswertungsroutine delSeqDoublets
-####################################################################################################
-sub delseqdoubl_ParseDone($) {
- my ($string) = @_;
- my @a = split("\\|",$string);
- my $hash = $defs{$a[0]};
- my $rowlist = decode_base64($a[1]);
- my $bt = $a[2];
- my ($rt,$brt) = split(",", $bt);
- my $err = $a[3]?decode_base64($a[3]):undef;
- my $nrows = $a[4];
- my $opt = $a[5];
- my $name = $hash->{NAME};
- my $reading = AttrVal($name, "reading", undef);
- my $limit = AttrVal($name, "limit", 1000);
- my @row;
- my $l = 1;
- my $reading_runtime_string;
- my $erread;
-
- if ($err) {
- ReadingsSingleUpdateValue ($hash, "errortext", $err, 1);
- ReadingsSingleUpdateValue ($hash, "state", "error", 1);
- delete($hash->{HELPER}{RUNNING_PID});
- return;
- }
-
- # Befehl nach Procedure ausführen
- $erread = DbRep_afterproc($hash, "delSeq");
-
- # Readingaufbereitung
- readingsBeginUpdate($hash);
-
- no warnings 'uninitialized';
- if ($opt !~ /delete/ && $rowlist) {
- my @row_array = split("\\|", $rowlist);
- s/_E#S#C_/\|/g for @row_array; # escaped Pipe return to "|"
- Log3 ($name, 5, "DbRep $name - row_array decoded: @row_array");
- foreach my $row (@row_array) {
- last if($l >= $limit);
- my @a = split("_ESC_", $row, 5);
- my $dev = $a[0];
- my $rea = $a[1];
- $a[3] =~ s/:/-/g; # substituieren unsupported characters ":" -> siehe fhem.pl
- my $ts = $a[2]."_".$a[3];
- my $val = $a[4];
-
- if ($reading && AttrVal($hash->{NAME}, "readingNameMap", "")) {
- $reading_runtime_string = $ts."__".AttrVal($hash->{NAME}, "readingNameMap", "") ;
- } else {
- $reading_runtime_string = $ts."__".$dev."__".$rea;
- }
- ReadingsBulkUpdateValue($hash, $reading_runtime_string, $val);
- $l++;
- }
- }
-
- use warnings;
- my $sfx = AttrVal("global", "language", "EN");
- $sfx = ($sfx eq "EN" ? "" : "_$sfx");
-
- my $rnam = ($opt =~ /adviceRemain/)?"number_rows_to_remain":($opt =~ /adviceDelete/)?"number_rows_to_delete":"number_rows_deleted";
- ReadingsBulkUpdateValue($hash, "$rnam", "$nrows");
- ReadingsBulkUpdateTimeState($hash,$brt,$rt,($l >= $limit)?
- "done - Warning: not all items are shown, adjust attribute limit if you want see more":"done");
- readingsEndUpdate($hash, 1);
-
- delete($hash->{HELPER}{RUNNING_PID});
-return;
-}
-
-####################################################################################################
-# nichtblockierende DB-Funktion expfile
-####################################################################################################
-sub expfile_DoParse($) {
- my ($string) = @_;
- my ($name, $device, $reading, $rsf, $file, $ts) = split("\\§", $string);
- my $hash = $defs{$name};
- my $dbloghash = $hash->{dbloghash};
- my $dbconn = $dbloghash->{dbconn};
- my $dbuser = $dbloghash->{dbuser};
- my $dblogname = $dbloghash->{NAME};
- my $dbpassword = $attr{"sec$dblogname"}{secret};
- my $utf8 = defined($hash->{UTF8})?$hash->{UTF8}:0;
- my ($dbh,$sth,$sql);
- my $err=0;
-
- # Background-Startzeit
- my $bst = [gettimeofday];
-
- eval {$dbh = DBI->connect("dbi:$dbconn", $dbuser, $dbpassword, { PrintError => 0, RaiseError => 1, AutoInactiveDestroy => 1, mysql_enable_utf8 => $utf8 });};
-
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- return "$name|''|''|$err|''|''|''";
- }
-
- $rsf =~ s/[:\s]/_/g;
- my $outfile = $file?$file:AttrVal($name, "expimpfile", undef);
- $outfile =~ s/%TSB/$rsf/g;
- my @t = localtime;
- $outfile = ResolveDateWildcards($outfile, @t);
- if (open(FH, ">:utf8", "$outfile")) {
- binmode (FH) if(!$utf8);
- } else {
- $err = encode_base64("could not open ".$outfile.": ".$!,"");
- return "$name|''|''|$err|''|''|''";
- }
-
- # ist Zeiteingrenzung und/oder Aggregation gesetzt ? (wenn ja -> "?" in SQL sonst undef)
- my ($IsTimeSet,$IsAggrSet) = DbRep_checktimeaggr($hash);
- Log3 ($name, 5, "DbRep $name - IsTimeSet: $IsTimeSet, IsAggrSet: $IsAggrSet");
-
- # Timestampstring to Array
- my @ts = split("\\|", $ts);
- Log3 ($name, 5, "DbRep $name - Timestamp-Array: \n@ts");
-
- # SQL-Startzeit
- my $st = [gettimeofday];
-
- # DB-Abfrage zeilenweise für jeden Array-Eintrag
- my $arrstr;
- my $nrows = 0;
- my $addon = "ORDER BY TIMESTAMP";
- no warnings 'uninitialized';
- foreach my $row (@ts) {
- my @a = split("#", $row);
- my $runtime_string = $a[0];
- my $runtime_string_first = $a[1];
- my $runtime_string_next = $a[2];
-
- if ($IsTimeSet || $IsAggrSet) {
- $sql = DbRep_createSelectSql($hash,"history","TIMESTAMP,DEVICE,TYPE,EVENT,READING,VALUE,UNIT",$device,$reading,"'$runtime_string_first'","'$runtime_string_next'",$addon);
- } else {
- $sql = DbRep_createSelectSql($hash,"history","TIMESTAMP,DEVICE,TYPE,EVENT,READING,VALUE,UNIT",$device,$reading,undef,undef,$addon);
- }
- Log3 ($name, 4, "DbRep $name - SQL execute: $sql");
-
- eval{ $sth = $dbh->prepare($sql);
- $sth->execute();
- };
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- $dbh->disconnect;
- return "$name|''|''|$err|''|''|''";
- }
-
- while (my $row = $sth->fetchrow_arrayref) {
- print FH DbRep_charfilter(join(',', map { s{"}{""}g; "\"$_\"";} @$row)), "\n";
- Log3 ($name, 5, "DbRep $name -> write row: @$row");
- # Anzahl der Datensätze
- $nrows++;
- }
-
- }
- close(FH);
-
- # SQL-Laufzeit ermitteln
- my $rt = tv_interval($st);
-
- $sth->finish;
- $dbh->disconnect;
-
- # Background-Laufzeit ermitteln
- my $brt = tv_interval($bst);
-
- $rt = $rt.",".$brt;
-
- return "$name|$nrows|$rt|$err|$device|$reading|$outfile";
-}
-
-####################################################################################################
-# Auswertungsroutine der nichtblockierenden DB-Funktion expfile
-####################################################################################################
-sub expfile_ParseDone($) {
- my ($string) = @_;
- my @a = split("\\|",$string);
- my $hash = $defs{$a[0]};
- my $nrows = $a[1];
- my $bt = $a[2];
- my ($rt,$brt) = split(",", $bt);
- my $err = $a[3]?decode_base64($a[3]):undef;
- my $name = $hash->{NAME};
- my $device = $a[4];
- $device =~ s/[^A-Za-z\/\d_\.-]/\//g;
- my $reading = $a[5];
- $reading =~ s/[^A-Za-z\/\d_\.-]/\//g;
- my $outfile = $a[6];
- my $erread;
-
- # Befehl nach Procedure ausführen
- $erread = DbRep_afterproc($hash, "export");
-
- if ($err) {
- ReadingsSingleUpdateValue ($hash, "errortext", $err, 1);
- ReadingsSingleUpdateValue ($hash, "state", "error", 1);
- delete($hash->{HELPER}{RUNNING_PID});
- return;
- }
-
- # only for this block because of warnings if details of readings are not set
- no warnings 'uninitialized';
-
- my $ds = $device." -- " if ($device);
- my $rds = $reading." -- " if ($reading);
- my $export_string = $ds.$rds." -- ROWS EXPORTED TO FILE -- ";
-
- my $state = $erread?$erread:"done";
- readingsBeginUpdate($hash);
- ReadingsBulkUpdateValue ($hash, $export_string, $nrows);
- ReadingsBulkUpdateTimeState($hash,$brt,$rt,$state);
- readingsEndUpdate($hash, 1);
-
- my $rows = $ds.$rds.$nrows;
- Log3 ($name, 3, "DbRep $name - Number of exported datasets from $hash->{DATABASE} to file $outfile: ".$rows);
-
- delete($hash->{HELPER}{RUNNING_PID});
-
-return;
-}
-
-####################################################################################################
-# nichtblockierende DB-Funktion impfile
-####################################################################################################
-sub impfile_Push($) {
- my ($string) = @_;
- my ($name, $rsf, $file) = split("\\|", $string);
- my $hash = $defs{$name};
- my $dbloghash = $hash->{dbloghash};
- my $dbconn = $dbloghash->{dbconn};
- my $dbuser = $dbloghash->{dbuser};
- my $dblogname = $dbloghash->{NAME};
- my $dbmodel = $hash->{dbloghash}{MODEL};
- my $dbpassword = $attr{"sec$dblogname"}{secret};
- my $utf8 = defined($hash->{UTF8})?$hash->{UTF8}:0;
- my $err=0;
- my $sth;
-
- # Background-Startzeit
- my $bst = [gettimeofday];
-
- my $dbh;
- eval {$dbh = DBI->connect("dbi:$dbconn", $dbuser, $dbpassword, { PrintError => 0, RaiseError => 1, AutoCommit => 1, AutoInactiveDestroy => 1, mysql_enable_utf8 => $utf8 });};
-
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- return "$name|''|''|$err|''";
- }
-
- # check ob PK verwendet wird, @usepkx?Anzahl der Felder im PK:0 wenn kein PK, $pkx?Namen der Felder:none wenn kein PK
- my ($usepkh,$usepkc,$pkh,$pkc) = DbRep_checkUsePK($hash,$dbloghash,$dbh);
-
- $rsf =~ s/[:\s]/_/g;
- my $infile = $file?$file:AttrVal($name, "expimpfile", undef);
- $infile =~ s/%TSB/$rsf/g;
- my @t = localtime;
- $infile = ResolveDateWildcards($infile, @t);
- if (open(FH, "<:utf8", "$infile")) {
- binmode (FH) if(!$utf8);
- } else {
- $err = encode_base64("could not open ".$infile.": ".$!,"");
- return "$name|''|''|$err|''";
- }
-
- # only for this block because of warnings if details inline is not set
- no warnings 'uninitialized';
-
- # SQL-Startzeit
- my $st = [gettimeofday];
-
- my $al;
- # Datei zeilenweise einlesen und verarbeiten !
- # Beispiel Inline:
- # "2016-09-25 08:53:56","STP_5000","SMAUTILS","etotal: 11859.573","etotal","11859.573",""
-
- # insert history mit/ohne primary key
- if ($usepkh && $dbloghash->{MODEL} eq 'MYSQL') {
- eval { $sth = $dbh->prepare_cached("INSERT IGNORE INTO history (TIMESTAMP, DEVICE, TYPE, EVENT, READING, VALUE, UNIT) VALUES (?,?,?,?,?,?,?)"); };
- } elsif ($usepkh && $dbloghash->{MODEL} eq 'SQLITE') {
- eval { $sth = $dbh->prepare_cached("INSERT OR IGNORE INTO history (TIMESTAMP, DEVICE, TYPE, EVENT, READING, VALUE, UNIT) VALUES (?,?,?,?,?,?,?)"); };
- } elsif ($usepkh && $dbloghash->{MODEL} eq 'POSTGRESQL') {
- eval { $sth = $dbh->prepare_cached("INSERT INTO history (TIMESTAMP, DEVICE, TYPE, EVENT, READING, VALUE, UNIT) VALUES (?,?,?,?,?,?,?) ON CONFLICT DO NOTHING"); };
- } else {
- eval { $sth = $dbh->prepare_cached("INSERT INTO history (TIMESTAMP, DEVICE, TYPE, EVENT, READING, VALUE, UNIT) VALUES (?,?,?,?,?,?,?)"); };
- }
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- $dbh->disconnect();
- return "$name|''|''|$err|''";
- }
-
- $dbh->begin_work();
-
- my $irowdone = 0;
- my $irowcount = 0;
- my $warn = 0;
- while () {
- $al = $_;
- chomp $al;
- my @alarr = split("\",\"", $al);
- foreach(@alarr) {
- tr/"//d;
- }
- my $i_timestamp = $alarr[0];
- # $i_timestamp =~ tr/"//d;
- my $i_device = $alarr[1];
- my $i_type = $alarr[2];
- my $i_event = $alarr[3];
- my $i_reading = $alarr[4];
- my $i_value = $alarr[5];
- my $i_unit = $alarr[6] ? $alarr[6]: " ";
- $irowcount++;
- next if(!$i_timestamp); #leerer Datensatz
-
- # check ob TIMESTAMP Format ok ?
- my ($i_date, $i_time) = split(" ",$i_timestamp);
- if ($i_date !~ /(\d{4})-(\d{2})-(\d{2})/ || $i_time !~ /(\d{2}):(\d{2}):(\d{2})/) {
- $err = encode_base64("Format of date/time is not valid in row $irowcount of $infile. Must be format \"YYYY-MM-DD HH:MM:SS\" !","");
- Log3 ($name, 2, "DbRep $name -> ERROR - Import from file $infile was not done. Invalid date/time field format in row $irowcount.");
- close(FH);
- $dbh->rollback;
- return "$name|''|''|$err|''";
- }
-
- # Daten auf maximale Länge (entsprechend der Feldlänge in DbLog DB create-scripts) beschneiden wenn nicht SQLite
- if ($dbmodel ne 'SQLITE') {
- $i_device = substr($i_device,0, $dbrep_col{DEVICE});
- $i_event = substr($i_event,0, $dbrep_col{EVENT});
- $i_reading = substr($i_reading,0, $dbrep_col{READING});
- $i_value = substr($i_value,0, $dbrep_col{VALUE});
- $i_unit = substr($i_unit,0, $dbrep_col{UNIT}) if($i_unit);
- }
-
- Log3 ($name, 5, "DbRep $name -> data to insert Timestamp: $i_timestamp, Device: $i_device, Type: $i_type, Event: $i_event, Reading: $i_reading, Value: $i_value, Unit: $i_unit");
-
- if($i_timestamp && $i_device && $i_reading) {
-
- eval {$sth->execute($i_timestamp, $i_device, $i_type, $i_event, $i_reading, $i_value, $i_unit);};
-
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - Failed to insert new dataset into database: $@");
- close(FH);
- $dbh->rollback;
- $dbh->disconnect;
- return "$name|''|''|$err|''";
- } else {
- $irowdone++
- }
-
- } else {
- my $c = !$i_timestamp?"field \"timestamp\" is empty":!$i_device?"field \"device\" is empty":"field \"reading\" is empty";
- $err = encode_base64("format error in in row $irowcount of $infile - cause: $c","");
- Log3 ($name, 2, "DbRep $name -> ERROR - Import of datasets NOT done. Formaterror in row $irowcount of $infile - cause: $c");
- close(FH);
- $dbh->rollback;
- $dbh->disconnect;
- return "$name|''|''|$err|''";
- }
- }
-
- $dbh->commit;
- $dbh->disconnect;
- close(FH);
-
- # SQL-Laufzeit ermitteln
- my $rt = tv_interval($st);
-
- # Background-Laufzeit ermitteln
- my $brt = tv_interval($bst);
-
- $rt = $rt.",".$brt;
-
- return "$name|$irowdone|$rt|$err|$infile";
-}
-
-####################################################################################################
-# Auswertungsroutine der nichtblockierenden DB-Funktion impfile
-####################################################################################################
-sub impfile_PushDone($) {
- my ($string) = @_;
- my @a = split("\\|",$string);
- my $hash = $defs{$a[0]};
- my $irowdone = $a[1];
- my $bt = $a[2];
- my ($rt,$brt) = split(",", $bt);
- my $err = $a[3]?decode_base64($a[3]):undef;
- my $name = $hash->{NAME};
- my $infile = $a[4];
- my $erread;
-
- # Befehl nach Procedure ausführen
- $erread = DbRep_afterproc($hash, "import");
-
- if ($err) {
- ReadingsSingleUpdateValue ($hash, "errortext", $err, 1);
- ReadingsSingleUpdateValue ($hash, "state", "error", 1);
- delete($hash->{HELPER}{RUNNING_PID});
- return;
- }
-
- # only for this block because of warnings if details of readings are not set
- no warnings 'uninitialized';
-
- my $import_string = " -- ROWS IMPORTED FROM FILE -- ";
-
- my $state = $erread?$erread:"done";
- readingsBeginUpdate($hash);
- ReadingsBulkUpdateValue ($hash, $import_string, $irowdone);
- ReadingsBulkUpdateTimeState($hash,$brt,$rt,$state);
- readingsEndUpdate($hash, 1);
-
- Log3 ($name, 3, "DbRep $name - Number of imported datasets to $hash->{DATABASE} from file $infile: $irowdone");
-
- delete($hash->{HELPER}{RUNNING_PID});
-
-return;
-}
-
-####################################################################################################
-# nichtblockierende DB-Abfrage sqlCmd - generischer SQL-Befehl - name | opt | sqlcommand
-####################################################################################################
-# set logdbrep sqlCmd select count(*) from history
-# set logdbrep sqlCmd select DEVICE,count(*) from history group by DEVICE HAVING count(*) > 10000
-sub sqlCmd_DoParse($) {
- my ($string) = @_;
- my ($name, $opt, $runtime_string_first, $runtime_string_next, $cmd) = split("\\|", $string);
- my $hash = $defs{$name};
- my $dbloghash = $hash->{dbloghash};
- my $dbconn = $dbloghash->{dbconn};
- my $dbuser = $dbloghash->{dbuser};
- my $dblogname = $dbloghash->{NAME};
- my $dbpassword = $attr{"sec$dblogname"}{secret};
- my $utf8 = defined($hash->{UTF8})?$hash->{UTF8}:0;
- my $srs = AttrVal($name, "sqlResultFieldSep", "|");
- my $err;
-
- # Background-Startzeit
- my $bst = [gettimeofday];
-
- my $dbh;
- eval {$dbh = DBI->connect("dbi:$dbconn", $dbuser, $dbpassword, { PrintError => 0, RaiseError => 1, AutoCommit => 1, AutoInactiveDestroy => 1, mysql_enable_utf8 => $utf8 });};
-
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- return "$name|''|$opt|$cmd|''|''|$err";
- }
-
- # only for this block because of warnings if details of readings are not set
- no warnings 'uninitialized';
-
- my $sql = ($cmd =~ m/\;$/)?$cmd:$cmd.";";
- # Allow inplace replacement of keywords for timings (use time attribute syntax)
- $sql =~ s/§timestamp_begin§/'$runtime_string_first'/g;
- $sql =~ s/§timestamp_end§/'$runtime_string_next'/g;
-
-# Debug "SQL :".$sql.":";
-
- Log3($name, 4, "DbRep $name - SQL execute: $sql");
-
- # SQL-Startzeit
- my $st = [gettimeofday];
-
- my ($sth,$r);
-
- eval {$sth = $dbh->prepare($sql);
- $r = $sth->execute();
- };
-
- if ($@) {
- # error bei sql-execute
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - ERROR - $@");
- $dbh->disconnect;
- return "$name|''|$opt|$sql|''|''|$err";
- }
-
- my @rows;
- my $nrows = 0;
- if($sql =~ m/^\s*(select|pragma|show)/is) {
- while (my @line = $sth->fetchrow_array()) {
- Log3 ($name, 4, "DbRep $name - SQL result: @line");
- my $row = join("$srs", @line);
-
- # join Delimiter "§" escapen
- $row =~ s/§/|°escaped°|/g;
-
- push(@rows, $row);
- # Anzahl der Datensätze
- $nrows++;
- }
- } else {
- $nrows = $sth->rows;
- eval {$dbh->commit() if(!$dbh->{AutoCommit});};
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - ERROR - $@");
- $dbh->disconnect;
- return "$name|''|$opt|$sql|''|''|$err";
- }
-
- push(@rows, $r);
- my $com = (split(" ",$sql, 2))[0];
- Log3 ($name, 3, "DbRep $name - Number of entries processed in db $hash->{DATABASE}: $nrows by $com");
- }
-
- $sth->finish;
-
- # SQL-Laufzeit ermitteln
- my $rt = tv_interval($st);
-
- $dbh->disconnect;
-
- # Daten müssen als Einzeiler zurückgegeben werden
- my $rowstring = join("§", @rows);
- $rowstring = encode_base64($rowstring,"");
-
- # Background-Laufzeit ermitteln
- my $brt = tv_interval($bst);
-
- $rt = $rt.",".$brt;
-
- return "$name|$rowstring|$opt|$sql|$nrows|$rt|$err";
-}
-
-####################################################################################################
-# Auswertungsroutine der nichtblockierenden DB-Abfrage sqlCmd
-####################################################################################################
-sub sqlCmd_ParseDone($) {
- my ($string) = @_;
- my @a = split("\\|",$string);
- my $hash = $defs{$a[0]};
- my $name = $hash->{NAME};
- my $rowstring = decode_base64($a[1]);
- my $opt = $a[2];
- my $cmd = $a[3];
- my $nrows = $a[4];
- my $bt = $a[5];
- my ($rt,$brt) = split(",", $bt);
- my $err = $a[6]?decode_base64($a[6]):undef;
- my $srf = AttrVal($name, "sqlResultFormat", "separated");
- my $srs = AttrVal($name, "sqlResultFieldSep", "|");
-
- if ($err) {
- ReadingsSingleUpdateValue ($hash, "errortext", $err, 1);
- ReadingsSingleUpdateValue ($hash, "state", "error", 1);
- delete($hash->{HELPER}{RUNNING_PID});
- return;
- }
-
- Log3 ($name, 5, "DbRep $name - SQL result decoded: $rowstring") if($rowstring);
-
- no warnings 'uninitialized';
-
- # Readingaufbereitung
- readingsBeginUpdate($hash);
-
- ReadingsBulkUpdateValue ($hash, "sqlCmd", $cmd);
- ReadingsBulkUpdateValue ($hash, "sqlResultNumRows", $nrows);
-
- # Drop-Down Liste bisherige sqlCmd-Befehle füllen und in Key-File sichern
- # my $hl = $hash->{HELPER}{SQLHIST};
- my @sqlhist = split(",",$hash->{HELPER}{SQLHIST});
- $cmd =~ s/\s/ /g;
- $cmd =~ s/,//g;
- my $hlc = AttrVal($name, "sqlCmdHistoryLength", 0); # Anzahl der Einträge in Drop-Down Liste
- if(!@sqlhist || (@sqlhist && !($cmd ~~ @sqlhist))) {
- unshift @sqlhist,$cmd;
- pop @sqlhist if(@sqlhist > $hlc);
- my $hl = join(",",@sqlhist);
- $hash->{HELPER}{SQLHIST} = $hl;
- DbRep_setCmdFile($name."_sqlCmdList",$hl,$hash);
- }
-
- if ($srf eq "sline") {
- $rowstring =~ s/§/]|[/g;
- $rowstring =~ s/\|°escaped°\|/§/g;
- ReadingsBulkUpdateValue ($hash, "SqlResult", $rowstring);
-
- } elsif ($srf eq "table") {
- my $res = "";
- my @rows = split( /§/, $rowstring );
- my $row;
- foreach $row ( @rows ) {
- $row =~ s/\|°escaped°\|/§/g;
- $row =~ s/$srs/\|/g if($srs !~ /\|/);
- $row =~ s/\|/<\/td>/g;
- $res .= " ".$row."
";
-
- ReadingsBulkUpdateValue ($hash,"SqlResult", $row);
-
- } elsif ($srf eq "mline") {
- my $res = "";
- my @rows = split( /§/, $rowstring );
- my $row;
- foreach $row ( @rows ) {
- $row =~ s/\|°escaped°\|/§/g;
- $res .= $row."";
- $res .= "ID ";
- $res .= "USER ";
- $res .= "HOST ";
- $res .= "DB ";
- $res .= "CMD ";
- $res .= "TIME_Sec ";
- $res .= "STATE ";
- $res .= "INFO ";
- $res .= "PROGRESS /g;
- $res .= " ".$row."
";
- push(@row_array, "ProcessList ".$tab);
-
- } else {
- while (my @line = $sth->fetchrow_array()) {
- Log3 ($name, 4, "DbRep $name - SQL result: @line");
- my $row = join("§", @line);
- $row =~ s/ /_/g;
- @line = split("§", $row);
- push(@row_array, $line[0]." ".$line[1]);
- }
- }
- }
- $sth->finish;
- }
- } else {
- $param =~ s/,/\|/g;
- $param =~ tr/%//d;
- # Log3 ($name, 5, "DbRep $name - showDbInfo: $param");
-
- if($dbmodel eq 'SQLITE') {
- my $sf = $dbh->sqlite_db_filename();
- if ($@) {
- # error bei sql-execute
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- $dbh->disconnect;
- return "$name|''|''|''|$err";
- } else {
- # kein error bei sql-execute
- my $key = "SQLITE_DB_FILENAME";
- push(@row_array, $key." ".$sf) if($key =~ m/($param)/i);
- }
- my @a = split(' ',qx(du -m $hash->{DATABASE})) if ($^O =~ m/linux/i || $^O =~ m/unix/i);
- my $key = "SQLITE_FILE_SIZE_MB";
- push(@row_array, $key." ".$a[0]) if($key =~ m/($param)/i);
- }
-
- my $info;
- while( my ($key,$value) = each(%GetInfoType) ) {
- eval { $info = $dbh->get_info($GetInfoType{"$key"}) };
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- $dbh->disconnect;
- return "$name|''|''|''|$err";
- } else {
- if($utf8) {
- $info = Encode::encode_utf8($info) if($info);
- }
- push(@row_array, $key." ".$info) if($key =~ m/($param)/i);
- }
- }
- }
-
- # SQL-Laufzeit ermitteln
- my $rt = tv_interval($st);
-
- $dbh->disconnect;
-
- my $rowlist = join('§', @row_array);
- Log3 ($name, 5, "DbRep $name -> row_array: \n@row_array");
-
- # Daten müssen als Einzeiler zurückgegeben werden
- $rowlist = encode_base64($rowlist,"");
-
- # Background-Laufzeit ermitteln
- my $brt = tv_interval($bst);
-
- $rt = $rt.",".$brt;
-
- return "$name|$rowlist|$rt|$opt|0";
-}
-
-####################################################################################################
-# Auswertungsroutine der nichtblockierenden DB-Abfrage get db Metadaten
-####################################################################################################
-sub dbmeta_ParseDone($) {
- my ($string) = @_;
- my @a = split("\\|",$string);
- my $hash = $defs{$a[0]};
- my $name = $hash->{NAME};
- my $rowlist = decode_base64($a[1]);
- my $bt = $a[2];
- my $opt = $a[3];
- my ($rt,$brt) = split(",", $bt);
- my $err = $a[4]?decode_base64($a[4]):undef;
-
- if ($err) {
- ReadingsSingleUpdateValue ($hash, "errortext", $err, 1);
- ReadingsSingleUpdateValue ($hash, "state", "error", 1);
- delete($hash->{HELPER}{RUNNING_PID});
- return;
- }
-
- # only for this block because of warnings if details of readings are not set
- no warnings 'uninitialized';
-
- # Readingaufbereitung
- readingsBeginUpdate($hash);
-
- my @row_array = split("§", $rowlist);
- Log3 ($name, 5, "DbRep $name - SQL result decoded: \n@row_array") if(@row_array);
-
- my $pre = "";
- $pre = "VAR_" if($opt eq "dbvars");
- $pre = "STAT_" if($opt eq "dbstatus");
- $pre = "INFO_" if($opt eq "tableinfo");
-
- foreach my $row (@row_array) {
- my @a = split(" ", $row, 2);
- my $k = $a[0];
- my $v = $a[1];
- ReadingsBulkUpdateValue ($hash, $pre.$k, $v);
- }
-
- ReadingsBulkUpdateTimeState($hash,$brt,$rt,"done");
- readingsEndUpdate($hash, 1);
-
- # InternalTimer(time+0.5, "browser_refresh", $hash, 0);
-
- delete($hash->{HELPER}{RUNNING_PID});
-
-return;
-}
-
-####################################################################################################
-# optimize Tables alle Datenbanken
-####################################################################################################
-sub DbRep_optimizeTables($) {
- my ($name) = @_;
- my $hash = $defs{$name};
- my $dbloghash = $hash->{dbloghash};
- my $dbconn = $dbloghash->{dbconn};
- my $dbuser = $dbloghash->{dbuser};
- my $dblogname = $dbloghash->{NAME};
- my $dbmodel = $dbloghash->{MODEL};
- my $dbpassword = $attr{"sec$dblogname"}{secret};
- my $dbname = $hash->{DATABASE};
- my $value = 0;
- my ($dbh,$sth,$query,$err,$r,$db_MB_start,$db_MB_end);
- my (%db_tables,@tablenames);
-
- # Background-Startzeit
- my $bst = [gettimeofday];
-
- # Verbindung mit DB
- eval {$dbh = DBI->connect("dbi:$dbconn", $dbuser, $dbpassword, { PrintError => 0, RaiseError => 1, AutoInactiveDestroy => 1 });};
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- return "$name|''|$err|''|''";
- }
-
- # SQL-Startzeit
- my $st = [gettimeofday];
-
- if ($dbmodel =~ /MYSQL/) {
- # Eigenschaften der vorhandenen Tabellen ermitteln (SHOW TABLE STATUS -> Rows sind nicht exakt !!)
- $query = "SHOW TABLE STATUS FROM `$dbname`";
-
- Log3 ($name, 5, "DbRep $name - current query: $query ");
- Log3 ($name, 3, "DbRep $name - Searching for tables inside database $dbname....");
-
- eval { $sth = $dbh->prepare($query);
- $sth->execute;
- };
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - Error executing: '".$query."' ! MySQL-Error: ".$@);
- $sth->finish;
- $dbh->disconnect;
- return "$name|''|$err|''|''";
- }
-
- while ( $value = $sth->fetchrow_hashref()) {
- # verbose 5 logging
- Log3 ($name, 5, "DbRep $name - ......... Table definition found: .........");
- foreach my $tk (sort(keys(%$value))) {
- Log3 ($name, 5, "DbRep $name - $tk: $value->{$tk}") if(defined($value->{$tk}) && $tk ne "Rows");
- }
- Log3 ($name, 5, "DbRep $name - ......... Table definition END ............");
-
- # check for old MySQL3-Syntax Type=xxx
- if (defined $value->{Type}) {
- # port old index type to index engine, so we can use the index Engine in the rest of the script
- $value->{Engine} = $value->{Type};
- }
- $db_tables{$value->{Name}} = $value;
-
- }
-
- @tablenames = sort(keys(%db_tables));
-
- if (@tablenames < 1) {
- $err = "There are no tables inside database $dbname ! It doesn't make sense to backup an empty database. Skipping this one.";
- Log3 ($name, 2, "DbRep $name - $err");
- $err = encode_base64($@,"");
- $sth->finish;
- $dbh->disconnect;
- return "$name|''|$err|''|''";
- }
-
- # Tabellen optimieren
- $hash->{HELPER}{DBTABLES} = \%db_tables;
- ($err,$db_MB_start,$db_MB_end) = DbRep_mysqlOptimizeTables($hash,$dbh,@tablenames);
- if ($err) {
- $err = encode_base64($err,"");
- return "$name|''|$err|''|''";
- }
- }
-
- if ($dbmodel =~ /SQLITE/) {
- # Anfangsgröße ermitteln
- $db_MB_start = (split(' ',qx(du -m $hash->{DATABASE})))[0] if ($^O =~ m/linux/i || $^O =~ m/unix/i);
- Log3 ($name, 3, "DbRep $name - Size of database $dbname before optimize (MB): $db_MB_start");
- $query ="VACUUM";
- Log3 ($name, 5, "DbRep $name - current query: $query ");
-
- Log3 ($name, 3, "DbRep $name - VACUUM database $dbname....");
- eval {$sth = $dbh->prepare($query);
- $r = $sth->execute();
- };
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - Error executing: '".$query."' ! SQLite-Error: ".$@);
- $sth->finish;
- $dbh->disconnect;
- return "$name|''|$err|''|''";
- }
-
- # Endgröße ermitteln
- $db_MB_end = (split(' ',qx(du -m $hash->{DATABASE})))[0] if ($^O =~ m/linux/i || $^O =~ m/unix/i);
- Log3 ($name, 3, "DbRep $name - Size of database $dbname after optimize (MB): $db_MB_end");
- }
-
- if ($dbmodel =~ /POSTGRESQL/) {
- # Anfangsgröße ermitteln
- $query = "SELECT pg_size_pretty(pg_database_size('$dbname'))";
- Log3 ($name, 5, "DbRep $name - current query: $query ");
- eval { $sth = $dbh->prepare($query);
- $sth->execute;
- };
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - Error executing: '".$query."' ! PostgreSQL-Error: ".$@);
- $sth->finish;
- $dbh->disconnect;
- return "$name|''|$err|''|''";
- }
-
- $value = $sth->fetchrow();
- $value =~ tr/MB//d;
- $db_MB_start = sprintf("%.2f",$value);
- Log3 ($name, 3, "DbRep $name - Size of database $dbname before optimize (MB): $db_MB_start");
-
- Log3 ($name, 3, "DbRep $name - VACUUM database $dbname....");
-
- $query = "vacuum history";
-
- Log3 ($name, 5, "DbRep $name - current query: $query ");
-
- eval {$sth = $dbh->prepare($query);
- $sth->execute();
- };
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - Error executing: '".$query."' ! PostgreSQL-Error: ".$@);
- $sth->finish;
- $dbh->disconnect;
- return "$name|''|$err|''|''";
- }
-
- # Endgröße ermitteln
- $query = "SELECT pg_size_pretty(pg_database_size('$dbname'))";
- Log3 ($name, 5, "DbRep $name - current query: $query ");
- eval { $sth = $dbh->prepare($query);
- $sth->execute;
- };
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - Error executing: '".$query."' ! PostgreSQL-Error: ".$@);
- $sth->finish;
- $dbh->disconnect;
- return "$name|''|$err|''|''";
- }
-
- $value = $sth->fetchrow();
- $value =~ tr/MB//d;
- $db_MB_end = sprintf("%.2f",$value);
- Log3 ($name, 3, "DbRep $name - Size of database $dbname after optimize (MB): $db_MB_end");
- }
-
- $sth->finish;
- $dbh->disconnect;
-
- # SQL-Laufzeit ermitteln
- my $rt = tv_interval($st);
-
- # Background-Laufzeit ermitteln
- my $brt = tv_interval($bst);
-
- $rt = $rt.",".$brt;
-
- Log3 ($name, 3, "DbRep $name - Optimize tables of database $dbname finished, total time used: ".sprintf("%.0f",$brt)." sec.");
-
-return "$name|$rt|''|$db_MB_start|$db_MB_end";
-}
-
-####################################################################################################
-# Auswertungsroutine optimize tables
-####################################################################################################
-sub DbRep_OptimizeDone($) {
- my ($string) = @_;
- my @a = split("\\|",$string);
- my $hash = $defs{$a[0]};
- my $bt = $a[1];
- my ($rt,$brt) = split(",", $bt);
- my $err = $a[2]?decode_base64($a[2]):undef;
- my $db_MB_start = $a[3];
- my $db_MB_end = $a[4];
- my $name = $hash->{NAME};
- my $erread;
-
- delete($hash->{HELPER}{RUNNING_OPTIMIZE});
-
- if ($err) {
- ReadingsSingleUpdateValue ($hash, "errortext", $err, 1);
- ReadingsSingleUpdateValue ($hash, "state", "error", 1);
- return;
- }
-
- # only for this block because of warnings if details of readings are not set
- no warnings 'uninitialized';
-
- readingsBeginUpdate($hash);
- ReadingsBulkUpdateValue($hash, "SizeDbBegin_MB", $db_MB_start);
- ReadingsBulkUpdateValue($hash, "SizeDbEnd_MB", $db_MB_end);
- readingsEndUpdate($hash, 1);
-
- # Befehl nach Procedure ausführen
- $erread = DbRep_afterproc($hash, "optimize");
-
- my $state = $erread?$erread:"optimize tables finished";
- readingsBeginUpdate($hash);
- ReadingsBulkUpdateTimeState($hash,$brt,undef,$state);
- readingsEndUpdate($hash, 1);
-
- Log3 ($name, 3, "DbRep $name - Optimize tables finished successfully. ");
-
-return;
-}
-
-####################################################################################################
-# nicht blockierende Dump-Routine für MySQL (clientSide)
-####################################################################################################
-sub mysql_DoDumpClientSide($) {
- my ($name) = @_;
- my $hash = $defs{$name};
- my $dbloghash = $hash->{dbloghash};
- my $dbconn = $dbloghash->{dbconn};
- my $dbuser = $dbloghash->{dbuser};
- my $dblogname = $dbloghash->{NAME};
- my $dbpassword = $attr{"sec$dblogname"}{secret};
- my $dbname = $hash->{DATABASE};
- my $dump_path_def = $attr{global}{modpath}."/log/";
- my $dump_path = AttrVal($name, "dumpDirLocal", $dump_path_def);
- $dump_path = $dump_path."/" unless($dump_path =~ m/\/$/);
- my $optimize_tables_beforedump = AttrVal($name, "optimizeTablesBeforeDump", 0);
- my $memory_limit = AttrVal($name, "dumpMemlimit", 100000);
- my $my_comment = AttrVal($name, "dumpComment", "");
- my $dumpspeed = AttrVal($name, "dumpSpeed", 10000);
- my $ebd = AttrVal($name, "executeBeforeProc", undef);
- my $ead = AttrVal($name, "executeAfterProc", undef);
- my $mysql_commentstring = "-- ";
- my $character_set = "utf8";
- my $repver = $hash->{VERSION};
- my $sql_text = '';
- my $sql_file = '';
- my $dbpraefix = "";
- my ($dbh,$sth,$tablename,$sql_create,$rct,$insert,$first_insert,$backupfile,$drc,$drh,$e,
- $sql_daten,$inhalt,$filesize,$totalrecords,$status_start,$status_end,$err,$db_MB_start,$db_MB_end);
- my (@ar,@tablerecords,@tablenames,@tables,@ergebnis);
- my (%db_tables);
-
- # Background-Startzeit
- my $bst = [gettimeofday];
-
- Log3 ($name, 3, "DbRep $name - Starting dump of database '$dbname'");
-
- ##################### Beginn Dump ########################
- ##############################################################
-
- undef(%db_tables);
-
- # Startzeit ermitteln
- my ($Sekunden, $Minuten, $Stunden, $Monatstag, $Monat, $Jahr, $Wochentag, $Jahrestag, $Sommerzeit) = localtime(time);
- $Jahr += 1900;
- $Monat += 1;
- $Jahrestag += 1;
- my $CTIME_String = strftime "%Y-%m-%d %T",localtime(time);
- my $time_stamp = $Jahr."_".sprintf("%02d",$Monat)."_".sprintf("%02d",$Monatstag)."_".sprintf("%02d",$Stunden)."_".sprintf("%02d",$Minuten);
- my $starttime = sprintf("%02d",$Monatstag).".".sprintf("%02d",$Monat).".".$Jahr." ".sprintf("%02d",$Stunden).":".sprintf("%02d",$Minuten);
-
- my $fieldlist = "";
-
- # Verbindung mit DB
- eval {$dbh = DBI->connect("dbi:$dbconn", $dbuser, $dbpassword, { PrintError => 0, RaiseError => 1, AutoInactiveDestroy => 1 });};
- if ($@) {
- $e = $@;
- $err = encode_base64($e,"");
- Log3 ($name, 2, "DbRep $name - $e");
- return "$name|''|$err|''|''|''|''|''|''|''";
- }
-
- # SQL-Startzeit
- my $st = [gettimeofday];
-
- ##################### Mysql-Version ermitteln ########################
- eval { $sth = $dbh->prepare("SELECT VERSION()");
- $sth->execute;
- };
- if ($@) {
- $e = $@;
- $err = encode_base64($e,"");
- Log3 ($name, 2, "DbRep $name - $e");
- $dbh->disconnect;
- return "$name|''|$err|''|''|''|''|''|''|''";
- }
-
- my @mysql_version = $sth->fetchrow;
- my @v = split(/\./,$mysql_version[0]);
-
- if($v[0] >= 5 || ($v[0] >= 4 && $v[1] >= 1) ) {
- # mysql Version >= 4.1
- $sth = $dbh->prepare("SET NAMES '".$character_set."'");
- $sth->execute;
- # get standard encoding of MySQl-Server
- $sth = $dbh->prepare("SHOW VARIABLES LIKE 'character_set_connection'");
- $sth->execute;
- @ar = $sth->fetchrow;
- $character_set = $ar[1];
- } else {
- # mysql Version < 4.1 -> no SET NAMES available
- # get standard encoding of MySQl-Server
- $sth = $dbh->prepare("SHOW VARIABLES LIKE 'character_set'");
- $sth->execute;
- @ar = $sth->fetchrow;
- if (defined($ar[1])) { $character_set=$ar[1]; }
- }
- Log3 ($name, 3, "DbRep $name - Characterset of collection and backup file set to $character_set. ");
-
-
- # Eigenschaften der vorhandenen Tabellen ermitteln (SHOW TABLE STATUS -> Rows sind nicht exakt !!)
- undef(@tables);
- undef(@tablerecords);
- my %db_tables_views;
- my $t = 0;
- my $r = 0;
- my $st_e = "\n";
- my $value = 0;
- my $engine = '';
- my $query ="SHOW TABLE STATUS FROM `$dbname`";
-
- Log3 ($name, 5, "DbRep $name - current query: $query ");
-
- if ($dbpraefix ne "") {
- $query.=" LIKE '$dbpraefix%'";
- Log3 ($name, 3, "DbRep $name - Searching for tables inside database $dbname with prefix $dbpraefix....");
- } else {
- Log3 ($name, 3, "DbRep $name - Searching for tables inside database $dbname....");
- }
-
- eval { $sth = $dbh->prepare($query);
- $sth->execute;
- };
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - Error executing: '".$query."' ! MySQL-Error: ".$@);
- $dbh->disconnect;
- return "$name|''|$err|''|''|''|''|''|''|''";
- }
-
- while ( $value = $sth->fetchrow_hashref()) {
- $value->{skip_data} = 0; #defaut -> backup data of table
-
- # verbose 5 logging
- Log3 ($name, 5, "DbRep $name - ......... Table definition found: .........");
- foreach my $tk (sort(keys(%$value))) {
- Log3 ($name, 5, "DbRep $name - $tk: $value->{$tk}") if(defined($value->{$tk}) && $tk ne "Rows");
- }
- Log3 ($name, 5, "DbRep $name - ......... Table definition END ............");
-
- # decide if we need to skip the data while dumping (VIEWs and MEMORY)
- # check for old MySQL3-Syntax Type=xxx
-
- if (defined $value->{Type}) {
- # port old index type to index engine, so we can use the index Engine in the rest of the script
- $value->{Engine} = $value->{Type};
- $engine = uc($value->{Type});
-
- if ($engine eq "MEMORY") {
- $value->{skip_data} = 1;
- }
- }
-
- # check for > MySQL3 Engine = xxx
- if (defined $value->{Engine}) {
- $engine = uc($value->{Engine});
-
- if ($engine eq "MEMORY") {
- $value->{skip_data} = 1;
- }
- }
-
- # check for Views - if it is a view the comment starts with "VIEW"
- if (defined $value->{Comment} && uc(substr($value->{Comment},0,4)) eq 'VIEW') {
- $value->{skip_data} = 1;
- $value->{Engine} = 'VIEW';
- $value->{Update_time} = '';
- $db_tables_views{$value->{Name}} = $value;
- } else {
- $db_tables{$value->{Name}} = $value;
- }
-
- # cast indexes to int, cause they are used for builing the statusline
- $value->{Rows} += 0;
- $value->{Data_length} += 0;
- $value->{Index_length} += 0;
- }
- $sth->finish;
-
- @tablenames = sort(keys(%db_tables));
-
- # add VIEW at the end as they need all tables to be created before
- @tablenames = (@tablenames,sort(keys(%db_tables_views)));
- %db_tables = (%db_tables,%db_tables_views);
- $tablename = '';
-
- if (@tablenames < 1) {
- $err = "There are no tables inside database $dbname ! It doesn't make sense to backup an empty database. Skipping this one.";
- Log3 ($name, 2, "DbRep $name - $err");
- $err = encode_base64($@,"");
- $dbh->disconnect;
- return "$name|''|$err|''|''|''|''|''|''|''";
- }
-
- if($optimize_tables_beforedump) {
- # Tabellen optimieren vor dem Dump
- $hash->{HELPER}{DBTABLES} = \%db_tables;
- ($err,$db_MB_start,$db_MB_end) = DbRep_mysqlOptimizeTables($hash,$dbh,@tablenames);
- if ($err) {
- $err = encode_base64($err,"");
- return "$name|''|$err|''|''|''|''|''|''|''";
- }
- }
-
- # Tabelleneigenschaften für SQL-File ermitteln
- $st_e .= "-- TABLE-INFO\n";
-
- foreach $tablename (@tablenames) {
- my $dump_table = 1;
-
- if ($dbpraefix ne "") {
- if (substr($tablename,0,length($dbpraefix)) ne $dbpraefix) {
- # exclude table from backup because it doesn't fit to praefix
- $dump_table = 0;
- }
- }
-
- if ($dump_table == 1) {
- # how many rows
- $sql_create = "SELECT count(*) FROM `$tablename`";
- eval { $sth = $dbh->prepare($sql_create);
- $sth->execute;
- };
- if ($@) {
- $e = $@;
- $err = "Fatal error sending Query '".$sql_create."' ! MySQL-Error: ".$e;
- Log3 ($name, 2, "DbRep $name - $err");
- $err = encode_base64($e,"");
- $dbh->disconnect;
- return "$name|''|$err|''|''|''|''|''|''|''";
- }
- $db_tables{$tablename}{Rows} = $sth->fetchrow;
- $sth->finish;
-
- $r += $db_tables{$tablename}{Rows};
- push(@tables,$db_tables{$tablename}{Name}); # add tablename to backuped tables
- $t++;
-
- if (!defined $db_tables{$tablename}{Update_time}) {
- $db_tables{$tablename}{Update_time} = 0;
- }
-
- $st_e .= $mysql_commentstring."TABLE: $db_tables{$tablename}{Name} | Rows: $db_tables{$tablename}{Rows} | Length: ".($db_tables{$tablename}{Data_length}+$db_tables{$tablename}{Index_length})." | Engine: $db_tables{$tablename}{Engine}\n";
- if($db_tables{$tablename}{Name} eq "current") {
- $drc = $db_tables{$tablename}{Rows};
- }
- if($db_tables{$tablename}{Name} eq "history") {
- $drh = $db_tables{$tablename}{Rows};
- }
- }
- }
- $st_e .= "-- EOF TABLE-INFO";
-
- Log3 ($name, 3, "DbRep $name - Found ".(@tables)." tables with $r records.");
-
- # AUFBAU der Statuszeile in SQL-File:
- # -- Status | tabellenzahl | datensaetze | Datenbankname | Kommentar | MySQLVersion | Charset | EXTINFO
- #
- $status_start = $mysql_commentstring."Status | Tables: $t | Rows: $r ";
- $status_end = "| DB: $dbname | Comment: $my_comment | MySQL-Version: $mysql_version[0] ";
- $status_end .= "| Charset: $character_set $st_e\n".
- $mysql_commentstring."Dump created on $CTIME_String by DbRep-Version $repver\n".$mysql_commentstring;
-
- $sql_text = $status_start.$status_end;
-
- # neues SQL-Ausgabefile anlegen
- ($sql_text,$first_insert,$sql_file,$backupfile,$err) = DbRep_NewDumpFilename($sql_text,$dump_path,$dbname,$time_stamp,$character_set);
- if ($err) {
- Log3 ($name, 2, "DbRep $name - $err");
- $err = encode_base64($err,"");
- return "$name|''|$err|''|''|''|''|''|''|''";
- } else {
- Log3 ($name, 5, "DbRep $name - New dumpfile $sql_file has been created.");
- }
-
- ##################### jede einzelne Tabelle dumpen ########################
-
- $totalrecords = 0;
-
- foreach $tablename (@tables) {
- # first get CREATE TABLE Statement
- if($dbpraefix eq "" || ($dbpraefix ne "" && substr($tablename,0,length($dbpraefix)) eq $dbpraefix)) {
- Log3 ($name, 3, "DbRep $name - Dumping table $tablename (Type ".$db_tables{$tablename}{Engine}."):");
-
- $a = "\n\n$mysql_commentstring\n$mysql_commentstring"."Table structure for table `$tablename`\n$mysql_commentstring\n";
-
- if ($db_tables{$tablename}{Engine} ne 'VIEW' ) {
- $a .= "DROP TABLE IF EXISTS `$tablename`;\n";
- } else {
- $a .= "DROP VIEW IF EXISTS `$tablename`;\n";
- }
-
- $sql_text .= $a;
- $sql_create = "SHOW CREATE TABLE `$tablename`";
-
- Log3 ($name, 5, "DbRep $name - current query: $sql_create ");
-
- eval { $sth = $dbh->prepare($sql_create);
- $sth->execute;
- };
- if ($@) {
- $e = $@;
- $err = "Fatal error sending Query '".$sql_create."' ! MySQL-Error: ".$e;
- Log3 ($name, 2, "DbRep $name - $err");
- $err = encode_base64($e,"");
- $dbh->disconnect;
- return "$name|''|$err|''|''|''|''|''|''|''";
- }
-
- @ergebnis = $sth->fetchrow;
- $sth->finish;
- $a = $ergebnis[1].";\n";
-
- if (length($a) < 10) {
- $err = "Fatal error! Couldn't read CREATE-Statement of table `$tablename`! This backup might be incomplete! Check your database for errors. MySQL-Error: ".$DBI::errstr;
- Log3 ($name, 2, "DbRep $name - $err");
- } else {
- $sql_text .= $a;
- # verbose 5 logging
- Log3 ($name, 5, "DbRep $name - Create-SQL found:\n$a");
- }
-
- if ($db_tables{$tablename}{skip_data} == 0) {
- $sql_text .= "\n$mysql_commentstring\n$mysql_commentstring"."Dumping data for table `$tablename`\n$mysql_commentstring\n";
- $sql_text .= "/*!40000 ALTER TABLE `$tablename` DISABLE KEYS */;";
-
- DbRep_WriteToDumpFile($sql_text,$sql_file);
- $sql_text = "";
-
- # build fieldlist
- $fieldlist = "(";
- $sql_create = "SHOW FIELDS FROM `$tablename`";
- Log3 ($name, 5, "DbRep $name - current query: $sql_create ");
-
- eval { $sth = $dbh->prepare($sql_create);
- $sth->execute;
- };
- if ($@) {
- $e = $@;
- $err = "Fatal error sending Query '".$sql_create."' ! MySQL-Error: ".$e;
- Log3 ($name, 2, "DbRep $name - $err");
- $err = encode_base64($e,"");
- $dbh->disconnect;
- return "$name|''|$err|''|''|''|''|''|''|''";
- }
-
- while (@ar = $sth->fetchrow) {
- $fieldlist .= "`".$ar[0]."`,";
- }
- $sth->finish;
-
- # verbose 5 logging
- Log3 ($name, 5, "DbRep $name - Fieldlist found: $fieldlist");
-
- # remove trailing ',' and add ')'
- $fieldlist = substr($fieldlist,0,length($fieldlist)-1).")";
-
- # how many rows
- $rct = $db_tables{$tablename}{Rows};
- Log3 ($name, 5, "DbRep $name - Number entries of table $tablename: $rct");
-
- # create insert Statements
- for (my $ttt = 0; $ttt < $rct; $ttt += $dumpspeed) {
- # default beginning for INSERT-String
- $insert = "INSERT INTO `$tablename` $fieldlist VALUES (";
- $first_insert = 0;
-
- # get rows (parts)
- $sql_daten = "SELECT * FROM `$tablename` LIMIT ".$ttt.",".$dumpspeed.";";
-
- eval { $sth = $dbh->prepare($sql_daten);
- $sth->execute;
- };
- if ($@) {
- $e = $@;
- $err = "Fatal error sending Query '".$sql_daten."' ! MySQL-Error: ".$e;
- Log3 ($name, 2, "DbRep $name - $err");
- $err = encode_base64($e,"");
- $dbh->disconnect;
- return "$name|''|$err|''|''|''|''|''|''|''";
- }
-
- while ( @ar = $sth->fetchrow) {
- #Start the insert
- if($first_insert == 0) {
- $a = "\n$insert";
- } else {
- $a = "\n(";
- }
-
- # quote all values
- foreach $inhalt(@ar) { $a .= $dbh->quote($inhalt).","; }
-
- # remove trailing ',' and add end-sql
- $a = substr($a,0, length($a)-1).");";
- $sql_text .= $a;
-
- if($memory_limit > 0 && length($sql_text) > $memory_limit) {
- ($filesize,$err) = DbRep_WriteToDumpFile($sql_text,$sql_file);
- # Log3 ($name, 5, "DbRep $name - Memory limit '$memory_limit' exceeded. Wrote to '$sql_file'. Filesize: '".DbRep_byteOutput($filesize)."'");
- $sql_text = "";
- }
- }
- $sth->finish;
- }
- $sql_text .= "\n/*!40000 ALTER TABLE `$tablename` ENABLE KEYS */;\n";
- }
-
- # write sql commands to file
- ($filesize,$err) = DbRep_WriteToDumpFile($sql_text,$sql_file);
- $sql_text = "";
-
- if ($db_tables{$tablename}{skip_data} == 0) {
- Log3 ($name, 3, "DbRep $name - $rct records inserted (size of backupfile: ".DbRep_byteOutput($filesize).")") if($filesize);
- $totalrecords += $rct;
- } else {
- Log3 ($name, 3, "DbRep $name - Dumping structure of $tablename (Type ".$db_tables{$tablename}{Engine}." ) (size of backupfile: ".DbRep_byteOutput($filesize).")");
- }
-
- }
- }
-
- # end
- DbRep_WriteToDumpFile("\nSET FOREIGN_KEY_CHECKS=1;\n",$sql_file);
- ($filesize,$err) = DbRep_WriteToDumpFile($mysql_commentstring."EOB\n",$sql_file);
-
- # Datenbankverbindung schliessen
- $sth->finish() if (defined $sth);
- $dbh->disconnect();
-
- # SQL-Laufzeit ermitteln
- my $rt = tv_interval($st);
-
- # Dumpfile komprimieren wenn dumpCompress=1
- my $compress = AttrVal($name,"dumpCompress",0);
- if($compress) {
- # $err nicht auswerten -> wenn compress fehlerhaft wird unkomprimiertes dumpfile verwendet
- ($err,$backupfile) = DbRep_dumpCompress($hash,$backupfile);
-
- my $fref = stat("$dump_path$backupfile");
- if ($fref =~ /ARRAY/) {
- $filesize = (@{stat("$dump_path$backupfile")})[7];
- } else {
- $filesize = (stat("$dump_path$backupfile"))[7];
- }
- }
-
- # Dumpfile per FTP senden und versionieren
- my ($ftperr,$ftpmsg,@ftpfd) = DbRep_sendftp($hash,$backupfile);
- my $ftp = $ftperr?encode_base64($ftperr,""):$ftpmsg?encode_base64($ftpmsg,""):0;
- my $ffd = join(", ", @ftpfd);
- $ffd = $ffd?encode_base64($ffd,""):0;
-
- # alte Dumpfiles löschen
- my @fd = DbRep_deldumpfiles($hash,$backupfile);
- my $bfd = join(", ", @fd );
- $bfd = $bfd?encode_base64($bfd,""):0;
-
- # Background-Laufzeit ermitteln
- my $brt = tv_interval($bst);
-
- $rt = $rt.",".$brt;
-
- my $fsize = '';
- if($filesize) {
- $fsize = DbRep_byteOutput($filesize);
- $fsize = encode_base64($fsize,"");
- }
-
- Log3 ($name, 3, "DbRep $name - Finished backup of database $dbname, total time used: ".sprintf("%.0f",$brt)." sec.");
-
-return "$name|$rt|''|$dump_path$backupfile|$drc|$drh|$fsize|$ftp|$bfd|$ffd";
-}
-
-####################################################################################################
-# nicht blockierende Dump-Routine für MySQL (serverSide)
-####################################################################################################
-sub mysql_DoDumpServerSide($) {
- my ($name) = @_;
- my $hash = $defs{$name};
- my $dbloghash = $hash->{dbloghash};
- my $dbconn = $dbloghash->{dbconn};
- my $dbuser = $dbloghash->{dbuser};
- my $dblogname = $dbloghash->{NAME};
- my $dbpassword = $attr{"sec$dblogname"}{secret};
- my $dbname = $hash->{DATABASE};
- my $optimize_tables_beforedump = AttrVal($name, "optimizeTablesBeforeDump", 0);
- my $dump_path_rem = AttrVal($name, "dumpDirRemote", "./");
- $dump_path_rem = $dump_path_rem."/" unless($dump_path_rem =~ m/\/$/);
- my $ebd = AttrVal($name, "executeBeforeProc", undef);
- my $ead = AttrVal($name, "executeAfterProc", undef);
- my $table = "history";
- my ($dbh,$sth,$err,$db_MB_start,$db_MB_end,$drh);
- my (%db_tables,@tablenames);
-
- # Background-Startzeit
- my $bst = [gettimeofday];
-
- # Verbindung mit DB
- eval {$dbh = DBI->connect("dbi:$dbconn", $dbuser, $dbpassword, { PrintError => 0, RaiseError => 1, AutoInactiveDestroy => 1 });};
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- return "$name|''|$err|''|''|''|''|''|''|''";
- }
-
- # Eigenschaften der vorhandenen Tabellen ermitteln (SHOW TABLE STATUS -> Rows sind nicht exakt !!)
- my $value = 0;
- my $query ="SHOW TABLE STATUS FROM `$dbname`";
-
- Log3 ($name, 5, "DbRep $name - current query: $query ");
-
- Log3 ($name, 3, "DbRep $name - Searching for tables inside database $dbname....");
-
- eval { $sth = $dbh->prepare($query);
- $sth->execute;
- };
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - Error executing: '".$query."' ! MySQL-Error: ".$@);
- $dbh->disconnect;
- return "$name|''|$err|''|''|''|''|''|''|''";
- }
-
- while ( $value = $sth->fetchrow_hashref()) {
- # verbose 5 logging
- Log3 ($name, 5, "DbRep $name - ......... Table definition found: .........");
- foreach my $tk (sort(keys(%$value))) {
- Log3 ($name, 5, "DbRep $name - $tk: $value->{$tk}") if(defined($value->{$tk}) && $tk ne "Rows");
- }
- Log3 ($name, 5, "DbRep $name - ......... Table definition END ............");
-
- # check for old MySQL3-Syntax Type=xxx
- if (defined $value->{Type}) {
- # port old index type to index engine, so we can use the index Engine in the rest of the script
- $value->{Engine} = $value->{Type};
- }
- $db_tables{$value->{Name}} = $value;
-
- }
- $sth->finish;
-
- @tablenames = sort(keys(%db_tables));
-
- if (@tablenames < 1) {
- $err = "There are no tables inside database $dbname ! It doesn't make sense to backup an empty database. Skipping this one.";
- Log3 ($name, 2, "DbRep $name - $err");
- $err = encode_base64($@,"");
- $dbh->disconnect;
- return "$name|''|$err|''|''|''|''|''|''|''";
- }
-
- if($optimize_tables_beforedump) {
- # Tabellen optimieren vor dem Dump
- $hash->{HELPER}{DBTABLES} = \%db_tables;
- ($err,$db_MB_start,$db_MB_end) = DbRep_mysqlOptimizeTables($hash,$dbh,@tablenames);
- if ($err) {
- $err = encode_base64($err,"");
- return "$name|''|$err|''|''|''|''|''|''|''";
- }
- }
-
- Log3 ($name, 3, "DbRep $name - Starting dump of database '$dbname', table '$table'");
-
- # Startzeit ermitteln
- my ($Sekunden, $Minuten, $Stunden, $Monatstag, $Monat, $Jahr, $Wochentag, $Jahrestag, $Sommerzeit) = localtime(time);
- $Jahr += 1900;
- $Monat += 1;
- $Jahrestag += 1;
- my $time_stamp = $Jahr."_".sprintf("%02d",$Monat)."_".sprintf("%02d",$Monatstag)."_".sprintf("%02d",$Stunden)."_".sprintf("%02d",$Minuten);
-
- my $bfile = $dbname."_".$table."_".$time_stamp.".csv";
- Log3 ($name, 5, "DbRep $name - Use Outfile: $dump_path_rem$bfile");
-
- # SQL-Startzeit
- my $st = [gettimeofday];
-
- my $sql = "SELECT * FROM history INTO OUTFILE '$dump_path_rem$bfile' FIELDS TERMINATED BY ',' ENCLOSED BY '\"' LINES TERMINATED BY '\n'; ";
-
- eval {$sth = $dbh->prepare($sql);
- $drh = $sth->execute();
- };
-
- if ($@) {
- # error bei sql-execute
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- $dbh->disconnect;
- return "$name|''|$err|''|''|''|''|''|''|''";
- }
-
- $sth->finish;
- $dbh->disconnect;
-
- # SQL-Laufzeit ermitteln
- my $rt = tv_interval($st);
-
- # Dumpfile komprimieren wenn dumpCompress=1
- my $compress = AttrVal($name,"dumpCompress",0);
- if($compress) {
- # $err nicht auswerten -> wenn compress fehlerhaft wird unkomprimiertes dumpfile verwendet
- ($err,$bfile) = DbRep_dumpCompress($hash,$bfile);
- }
-
- # Größe Dumpfile ermitteln ("dumpDirRemote" muß auf "dumpDirLocal" gemountet sein)
- my $dump_path_def = $attr{global}{modpath}."/log/";
- my $dump_path_loc = AttrVal($name,"dumpDirLocal", $dump_path_def);
- $dump_path_loc = $dump_path_loc."/" unless($dump_path_loc =~ m/\/$/);
-
- my $filesize;
- my $fref = stat($dump_path_loc.$bfile);
- if ($fref =~ /ARRAY/) {
- $filesize = (@{stat($dump_path_loc.$bfile)})[7];
- } else {
- $filesize = (stat($dump_path_loc.$bfile))[7];
- }
-
- Log3 ($name, 3, "DbRep $name - Number of exported datasets: $drh");
- Log3 ($name, 3, "DbRep $name - Size of backupfile: ".DbRep_byteOutput($filesize)) if($filesize);
-
- # Dumpfile per FTP senden und versionieren
- my ($ftperr,$ftpmsg,@ftpfd) = DbRep_sendftp($hash,$bfile);
- my $ftp = $ftperr?encode_base64($ftperr,""):$ftpmsg?encode_base64($ftpmsg,""):0;
- my $ffd = join(", ", @ftpfd);
- $ffd = $ffd?encode_base64($ffd,""):0;
-
- # alte Dumpfiles löschen
- my @fd = DbRep_deldumpfiles($hash,$bfile);
- my $bfd = join(", ", @fd );
- $bfd = $bfd?encode_base64($bfd,""):0;
-
- # Background-Laufzeit ermitteln
- my $brt = tv_interval($bst);
-
- my $fsize = '';
- if($filesize) {
- $fsize = DbRep_byteOutput($filesize);
- $fsize = encode_base64($fsize,"");
- }
-
- $rt = $rt.",".$brt;
-
- Log3 ($name, 3, "DbRep $name - Finished backup of database $dbname - total time used: ".sprintf("%.0f",$brt)." seconds");
-
-return "$name|$rt|''|$dump_path_rem$bfile|n.a.|$drh|$fsize|$ftp|$bfd|$ffd";
-}
-
-####################################################################################################
-# Dump-Routine SQLite
-####################################################################################################
-sub DbRep_sqliteDoDump($) {
- my ($name) = @_;
- my $hash = $defs{$name};
- my $dbloghash = $hash->{dbloghash};
- my $dbname = $hash->{DATABASE};
- my $dbconn = $dbloghash->{dbconn};
- my $dbuser = $dbloghash->{dbuser};
- my $dblogname = $dbloghash->{NAME};
- my $dbpassword = $attr{"sec$dblogname"}{secret};
- my $dump_path_def = $attr{global}{modpath}."/log/";
- my $dump_path = AttrVal($name, "dumpDirLocal", $dump_path_def);
- $dump_path = $dump_path."/" unless($dump_path =~ m/\/$/);
- my $optimize_tables_beforedump = AttrVal($name, "optimizeTablesBeforeDump", 0);
- my $ebd = AttrVal($name, "executeBeforeProc", undef);
- my $ead = AttrVal($name, "executeAfterProc", undef);
- my ($dbh,$err,$db_MB,$r,$query,$sth);
-
- # Background-Startzeit
- my $bst = [gettimeofday];
-
- # Verbindung mit DB
- eval {$dbh = DBI->connect("dbi:$dbconn", $dbuser, $dbpassword, { PrintError => 0, RaiseError => 1, AutoInactiveDestroy => 1 });};
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- return "$name|''|$err|''|''|''|''|''|''|''";
- }
-
- if($optimize_tables_beforedump) {
- # Vacuum vor Dump
- # Anfangsgröße ermitteln
- $db_MB = (split(' ',qx(du -m $dbname)))[0] if ($^O =~ m/linux/i || $^O =~ m/unix/i);
- Log3 ($name, 3, "DbRep $name - Size of database $dbname before optimize (MB): $db_MB");
- $query ="VACUUM";
- Log3 ($name, 5, "DbRep $name - current query: $query ");
-
- Log3 ($name, 3, "DbRep $name - VACUUM database $dbname....");
- eval {$sth = $dbh->prepare($query);
- $r = $sth->execute();
- };
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - Error executing: '".$query."' ! SQLite-Error: ".$@);
- $sth->finish;
- $dbh->disconnect;
- return "$name|''|$err|''|''|''|''|''|''|''";
- }
-
- # Endgröße ermitteln
- $db_MB = (split(' ',qx(du -m $dbname)))[0] if ($^O =~ m/linux/i || $^O =~ m/unix/i);
- Log3 ($name, 3, "DbRep $name - Size of database $dbname after optimize (MB): $db_MB");
- }
-
- $dbname = (split /[\/]/, $dbname)[-1];
-
- Log3 ($name, 3, "DbRep $name - Starting dump of database '$dbname'");
-
- # Startzeit ermitteln
- my ($Sekunden, $Minuten, $Stunden, $Monatstag, $Monat, $Jahr, $Wochentag, $Jahrestag, $Sommerzeit) = localtime(time);
- $Jahr += 1900;
- $Monat += 1;
- $Jahrestag += 1;
- my $time_stamp = $Jahr."_".sprintf("%02d",$Monat)."_".sprintf("%02d",$Monatstag)."_".sprintf("%02d",$Stunden)."_".sprintf("%02d",$Minuten);
-
- $dbname = (split /\./, $dbname)[0];
- my $bfile = $dbname."_".$time_stamp.".sqlitebkp";
- Log3 ($name, 5, "DbRep $name - Use Outfile: $dump_path$bfile");
-
- # SQL-Startzeit
- my $st = [gettimeofday];
-
- eval { $dbh->sqlite_backup_to_file($dump_path.$bfile); };
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- $dbh->disconnect;
- return "$name|''|$err|''|''|''|''|''|''|''";
- }
-
- $dbh->disconnect;
-
- # SQL-Laufzeit ermitteln
- my $rt = tv_interval($st);
-
- # Dumpfile komprimieren
- my $compress = AttrVal($name,"dumpCompress",0);
- if($compress) {
- # $err nicht auswerten -> wenn compress fehlerhaft wird unkomprimiertes dumpfile verwendet
- ($err,$bfile) = DbRep_dumpCompress($hash,$bfile);
- }
-
- # Größe Dumpfile ermitteln
- my @a = split(' ',qx(du $dump_path$bfile)) if ($^O =~ m/linux/i || $^O =~ m/unix/i);
-
- my $filesize = ($a[0])?($a[0]*1024):"n.a.";
- my $fsize = DbRep_byteOutput($filesize);
- Log3 ($name, 3, "DbRep $name - Size of backupfile: ".$fsize);
-
- # Dumpfile per FTP senden und versionieren
- my ($ftperr,$ftpmsg,@ftpfd) = DbRep_sendftp($hash,$bfile);
- my $ftp = $ftperr?encode_base64($ftperr,""):$ftpmsg?encode_base64($ftpmsg,""):0;
- my $ffd = join(", ", @ftpfd);
- $ffd = $ffd?encode_base64($ffd,""):0;
-
- # alte Dumpfiles löschen
- my @fd = DbRep_deldumpfiles($hash,$bfile);
- my $bfd = join(", ", @fd );
- $bfd = $bfd?encode_base64($bfd,""):0;
-
- # Background-Laufzeit ermitteln
- my $brt = tv_interval($bst);
-
- $fsize = encode_base64($fsize,"");
-
- $rt = $rt.",".$brt;
-
- Log3 ($name, 3, "DbRep $name - Finished backup of database $dbname - total time used: ".sprintf("%.0f",$brt)." seconds");
-
-return "$name|$rt|''|$dump_path$bfile|n.a.|n.a.|$fsize|$ftp|$bfd|$ffd";
-}
-
-####################################################################################################
-# Auswertungsroutine der nicht blockierenden DB-Funktion Dump
-####################################################################################################
-sub DbRep_DumpDone($) {
- my ($string) = @_;
- my @a = split("\\|",$string);
- my $hash = $defs{$a[0]};
- my $bt = $a[1];
- my ($rt,$brt) = split(",", $bt);
- my $err = $a[2]?decode_base64($a[2]):undef;
- my $bfile = $a[3];
- my $drc = $a[4];
- my $drh = $a[5];
- my $fs = $a[6]?decode_base64($a[6]):undef;
- my $ftp = $a[7]?decode_base64($a[7]):undef;
- my $bfd = $a[8]?decode_base64($a[8]):undef;
- my $ffd = $a[9]?decode_base64($a[9]):undef;
- my $name = $hash->{NAME};
- my $erread;
-
- delete($hash->{HELPER}{RUNNING_BACKUP_CLIENT});
- delete($hash->{HELPER}{RUNNING_BCKPREST_SERVER});
-
- if ($err) {
- ReadingsSingleUpdateValue ($hash, "errortext", $err, 1);
- ReadingsSingleUpdateValue ($hash, "state", "error", 1);
- return;
- }
-
- # only for this block because of warnings if details of readings are not set
- no warnings 'uninitialized';
-
- readingsBeginUpdate($hash);
- ReadingsBulkUpdateValue($hash, "DumpFileCreated", $bfile);
- ReadingsBulkUpdateValue($hash, "DumpFileCreatedSize", $fs);
- ReadingsBulkUpdateValue($hash, "DumpFilesDeleted", $bfd);
- ReadingsBulkUpdateValue($hash, "DumpRowsCurrent", $drc);
- ReadingsBulkUpdateValue($hash, "DumpRowsHistory", $drh);
- ReadingsBulkUpdateValue($hash, "FTP_Message", $ftp) if($ftp);
- ReadingsBulkUpdateValue($hash, "FTP_DumpFilesDeleted", $ffd) if($ffd);
- ReadingsBulkUpdateValue($hash, "background_processing_time", sprintf("%.4f",$brt));
- readingsEndUpdate($hash, 1);
-
- # Befehl nach Procedure ausführen
- $erread = DbRep_afterproc($hash, "dump");
-
- my $state = $erread?$erread:"Database backup finished";
- readingsBeginUpdate($hash);
- ReadingsBulkUpdateTimeState($hash,undef,undef,$state);
- readingsEndUpdate($hash, 1);
-
- Log3 ($name, 3, "DbRep $name - Database dump finished successfully. ");
-
-return;
-}
-
-####################################################################################################
-# Dump-Routine SQLite
-####################################################################################################
-sub DbRep_sqliteRepair($) {
- my ($name) = @_;
- my $hash = $defs{$name};
- my $dbloghash = $hash->{dbloghash};
- my $db = $hash->{DATABASE};
- my $dbname = (split /[\/]/, $db)[-1];
- my $dbpath = (split /$dbname/, $db)[0];
- my $dblogname = $dbloghash->{NAME};
- my $sqlfile = $dbpath."dump_all.sql";
- my ($c,$clog,$ret,$err);
-
- # Background-Startzeit
- my $bst = [gettimeofday];
-
- $c = "echo \".mode insert\n.output $sqlfile\n.dump\n.exit\" | sqlite3 $db; ";
- $clog = $c;
- $clog =~ s/\n/ /g;
- Log3 ($name, 4, "DbRep $name - Systemcall: $clog");
- $ret = system qq($c);
- if($ret) {
- $err = "Error in step \"dump corrupt database\" - see logfile";
- $err = encode_base64($err,"");
- return "$name|''|$err";
- }
-
- $c = "mv $db $db.corrupt";
- $clog = $c;
- $clog =~ s/\n/ /g;
- Log3 ($name, 4, "DbRep $name - Systemcall: $clog");
- $ret = system qq($c);
- if($ret) {
- $err = "Error in step \"move atabase to corrupt-db\" - see logfile";
- $err = encode_base64($err,"");
- return "$name|''|$err";
- }
-
- $c = "echo \".read $sqlfile\n.exit\" | sqlite3 $db;";
- $clog = $c;
- $clog =~ s/\n/ /g;
- Log3 ($name, 4, "DbRep $name - Systemcall: $clog");
- $ret = system qq($c);
- if($ret) {
- $err = "Error in step \"read dump to new database\" - see logfile";
- $err = encode_base64($err,"");
- return "$name|''|$err";
- }
-
- $c = "rm $sqlfile";
- $clog = $c;
- $clog =~ s/\n/ /g;
- Log3 ($name, 4, "DbRep $name - Systemcall: $clog");
- $ret = system qq($c);
- if($ret) {
- $err = "Error in step \"delete $sqlfile\" - see logfile";
- $err = encode_base64($err,"");
- return "$name|''|$err";
- }
-
- # Background-Laufzeit ermitteln
- my $brt = tv_interval($bst);
-
-return "$name|$brt|0";
-}
-
-####################################################################################################
-# Auswertungsroutine der nicht blockierenden DB-Funktion Dump
-####################################################################################################
-sub DbRep_RepairDone($) {
- my ($string) = @_;
- my @a = split("\\|",$string);
- my $hash = $defs{$a[0]};
- my $brt = $a[1];
- my $err = $a[2]?decode_base64($a[2]):undef;
- my $dbloghash = $hash->{dbloghash};
- my $name = $hash->{NAME};
- my $erread;
-
- delete($hash->{HELPER}{RUNNING_REPAIR});
-
- # Datenbankverbindung in DbLog wieder öffenen
- my $dbl = $dbloghash->{NAME};
- CommandSet(undef,"$dbl reopen");
-
- if ($err) {
- ReadingsSingleUpdateValue ($hash, "errortext", $err, 1);
- ReadingsSingleUpdateValue ($hash, "state", "error", 1);
- return;
- }
-
- # only for this block because of warnings if details of readings are not set
- no warnings 'uninitialized';
-
- readingsBeginUpdate($hash);
- ReadingsBulkUpdateValue($hash, "background_processing_time", sprintf("%.4f",$brt));
- readingsEndUpdate($hash, 1);
-
- # Befehl nach Procedure ausführen
- $erread = DbRep_afterproc($hash, "repair");
-
- my $state = $erread?$erread:"Repair finished $hash->{DATABASE}";
- readingsBeginUpdate($hash);
- ReadingsBulkUpdateTimeState($hash,undef,undef,$state);
- readingsEndUpdate($hash, 1);
-
- Log3 ($name, 3, "DbRep $name - Database repair $hash->{DATABASE} finished. - total time used: ".sprintf("%.0f",$brt)." seconds.");
-
-return;
-}
-
-####################################################################################################
-# Restore SQLite
-####################################################################################################
-sub DbRep_sqliteRestore ($) {
- my ($string) = @_;
- my ($name,$bfile) = split("\\|", $string);
- my $hash = $defs{$name};
- my $dbloghash = $hash->{dbloghash};
- my $dbconn = $dbloghash->{dbconn};
- my $dbuser = $dbloghash->{dbuser};
- my $dblogname = $dbloghash->{NAME};
- my $dbpassword = $attr{"sec$dblogname"}{secret};
- my $dump_path_def = $attr{global}{modpath}."/log/";
- my $dump_path = AttrVal($name, "dumpDirLocal", $dump_path_def);
- $dump_path = $dump_path."/" unless($dump_path =~ m/\/$/);
- my $ebd = AttrVal($name, "executeBeforeProc", undef);
- my $ead = AttrVal($name, "executeAfterProc", undef);
- my ($dbh,$err,$dbname);
-
- # Background-Startzeit
- my $bst = [gettimeofday];
-
- # Verbindung mit DB
- eval {$dbh = DBI->connect("dbi:$dbconn", $dbuser, $dbpassword, { PrintError => 0, RaiseError => 1, AutoInactiveDestroy => 1 });};
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- return "$name|''|$err|''|''";
- }
-
- eval { $dbname = $dbh->sqlite_db_filename(); };
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- $dbh->disconnect;
- return "$name|''|$err|''|''";
- }
-
- $dbname = (split /[\/]/, $dbname)[-1];
-
- # Dumpfile dekomprimieren wenn gzip
- if($bfile =~ m/.*.gzip$/) {
- ($err,$bfile) = DbRep_dumpUnCompress($hash,$bfile);
- if ($err) {
- $err = encode_base64($err,"");
- $dbh->disconnect;
- return "$name|''|$err|''|''";
- }
- }
-
- Log3 ($name, 3, "DbRep $name - Starting restore of database '$dbname'");
-
- # SQL-Startzeit
- my $st = [gettimeofday];
-
- eval { $dbh->sqlite_backup_from_file($dump_path.$bfile); };
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- $dbh->disconnect;
- return "$name|''|$err|''|''";
- }
-
- $dbh->disconnect;
-
- # SQL-Laufzeit ermitteln
- my $rt = tv_interval($st);
-
- # Background-Laufzeit ermitteln
- my $brt = tv_interval($bst);
-
- $rt = $rt.",".$brt;
-
- Log3 ($name, 3, "DbRep $name - Restore of $dump_path$bfile into '$dbname' finished - total time used: ".sprintf("%.0f",$brt)." seconds.");
-
-return "$name|$rt|''|$dump_path$bfile|n.a.";
-}
-
-####################################################################################################
-# Restore MySQL (serverSide)
-####################################################################################################
-sub mysql_RestoreServerSide($) {
- my ($string) = @_;
- my ($name, $bfile) = split("\\|", $string);
- my $hash = $defs{$name};
- my $dbloghash = $hash->{dbloghash};
- my $dbconn = $dbloghash->{dbconn};
- my $dbuser = $dbloghash->{dbuser};
- my $dblogname = $dbloghash->{NAME};
- my $dbpassword = $attr{"sec$dblogname"}{secret};
- my $dbname = $hash->{DATABASE};
- my $dump_path_rem = AttrVal($name, "dumpDirRemote", "./");
- $dump_path_rem = $dump_path_rem."/" unless($dump_path_rem =~ m/\/$/);
- my $table = "history";
- my ($dbh,$sth,$err,$drh);
-
- # Background-Startzeit
- my $bst = [gettimeofday];
-
- # Verbindung mit DB
- eval {$dbh = DBI->connect("dbi:$dbconn", $dbuser, $dbpassword, { PrintError => 0, RaiseError => 1, AutoInactiveDestroy => 1 });};
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- return "$name|''|$err|''|''";
- }
-
- # Dumpfile dekomprimieren wenn gzip
- if($bfile =~ m/.*.gzip$/) {
- ($err,$bfile) = DbRep_dumpUnCompress($hash,$bfile);
- if ($err) {
- $err = encode_base64($err,"");
- $dbh->disconnect;
- return "$name|''|$err|''|''";
- }
- }
-
- Log3 ($name, 3, "DbRep $name - Starting restore of database '$dbname', table '$table'.");
-
- # SQL-Startzeit
- my $st = [gettimeofday];
-
- my $sql = "LOAD DATA CONCURRENT INFILE '$dump_path_rem$bfile' IGNORE INTO TABLE $table FIELDS TERMINATED BY ',' ENCLOSED BY '\"' LINES TERMINATED BY '\n'; ";
-
- eval {$sth = $dbh->prepare($sql);
- $drh = $sth->execute();
- };
-
- if ($@) {
- # error bei sql-execute
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- $dbh->disconnect;
- return "$name|''|$err|''|''";
- }
-
- $sth->finish;
- $dbh->disconnect;
-
- # SQL-Laufzeit ermitteln
- my $rt = tv_interval($st);
-
- # Background-Laufzeit ermitteln
- my $brt = tv_interval($bst);
-
- $rt = $rt.",".$brt;
-
- Log3 ($name, 3, "DbRep $name - Restore of $dump_path_rem$bfile into '$dbname', '$table' finished - total time used: ".sprintf("%.0f",$brt)." seconds.");
-
-return "$name|$rt|''|$dump_path_rem$bfile|n.a.";
-}
-
-####################################################################################################
-# Restore MySQL (ClientSide)
-####################################################################################################
-sub mysql_RestoreClientSide($) {
- my ($string) = @_;
- my ($name, $bfile) = split("\\|", $string);
- my $hash = $defs{$name};
- my $dbloghash = $hash->{dbloghash};
- my $dbconn = $dbloghash->{dbconn};
- my $dbuser = $dbloghash->{dbuser};
- my $dblogname = $dbloghash->{NAME};
- my $dbpassword = $attr{"sec$dblogname"}{secret};
- my $dbname = $hash->{DATABASE};
- my $i_max = AttrVal($name, "dumpMemlimit", 100000); # max. Anzahl der Blockinserts
- my $dump_path_def = $attr{global}{modpath}."/log/";
- my $dump_path = AttrVal($name, "dumpDirLocal", $dump_path_def);
- $dump_path = $dump_path."/" if($dump_path !~ /.*\/$/);
- my ($dbh,$err,$v1,$v2,$e);
-
- # Background-Startzeit
- my $bst = [gettimeofday];
-
- # Verbindung mit DB
- eval {$dbh = DBI->connect("dbi:$dbconn", $dbuser, $dbpassword, { PrintError => 0, RaiseError => 1, AutoCommit => 1 });};
- if ($@) {
- $e = $@;
- $err = encode_base64($e,"");
- Log3 ($name, 1, "DbRep $name - $e");
- return "$name|''|$err|''|''";
- }
-
- # maximal mögliche Packetgröße ermitteln (in Bits) -> Umrechnen in max. Zeichen
- my @row_ary;
- my $sql = "show variables like 'max_allowed_packet'";
- eval {@row_ary = $dbh->selectrow_array($sql);};
- my $max_packets = $row_ary[1]; # Bits
- $i_max = ($max_packets/8)-500; # Characters mit Sicherheitszuschlag
-
- # Dumpfile dekomprimieren wenn gzip
- if($bfile =~ m/.*.gzip$/) {
- ($err,$bfile) = DbRep_dumpUnCompress($hash,$bfile);
- if ($err) {
- $err = encode_base64($err,"");
- $dbh->disconnect;
- return "$name|''|$err|''|''";
- }
- }
-
- if(!open(FH, "<$dump_path$bfile")) {
- $err = encode_base64("could not open ".$dump_path.$bfile.": ".$!,"");
- return "$name|''|''|$err|''";
- }
-
- Log3 ($name, 3, "DbRep $name - Restore of database '$dbname' started. Sourcefile: $dump_path$bfile");
- Log3 ($name, 3, "DbRep $name - Max packet lenght of insert statement: $i_max");
-
- # SQL-Startzeit
- my $st = [gettimeofday];
-
- my $nc = 0; # Insert Zähler current
- my $nh = 0; # Insert Zähler history
- my $n = 0; # Insert Zähler
- my $i = 0; # Array Zähler
- my $tmp = '';
- my $line = '';
- my $base_query = '';
- my $query = '';
-
- while() {
- $tmp = $_;
- chomp($tmp);
- if(!$tmp || substr($tmp,0,2) eq "--") {
- next;
- }
- $line .= $tmp;
-
- if(substr($line,-1) eq ";") {
- if($line !~ /^INSERT INTO.*$/) {
- eval {$dbh->do($line);
- };
- if ($@) {
- $e = $@;
- $err = encode_base64($e,"");
- Log3 ($name, 1, "DbRep $name - last query: $line");
- Log3 ($name, 1, "DbRep $name - $e");
- close(FH);
- $dbh->disconnect;
- return "$name|''|$err|''|''";
- }
- $line = '';
- next;
- }
-
- if(!$base_query) {
- $line =~ /INSERT INTO (.*) VALUES \((.*)\);/;
- $v1 = $1;
- $v2 = $2;
- $base_query = qq{INSERT INTO $v1 VALUES };
- $query = $base_query;
- $nc++ if($base_query =~ /INSERT INTO `current`.*/);
- $nh++ if($base_query =~ /INSERT INTO `history`.*/);
- $query .= "," if($i);
- $query .= "(".$v2.")";
- $i++;
- } else {
- $line =~ /INSERT INTO (.*) VALUES \((.*)\);/;
- $v1 = $1;
- $v2 = $2;
- my $ln = qq{INSERT INTO $v1 VALUES };
- if($base_query eq $ln) {
- $nc++ if($base_query =~ /INSERT INTO `current`.*/);
- $nh++ if($base_query =~ /INSERT INTO `history`.*/);
- $query .= "," if($i);
- $query .= "(".$v2.")";
- $i++;
- } else {
- $query = $query.";";
- eval {$dbh->do($query);
- };
- if ($@) {
- $e = $@;
- $err = encode_base64($e,"");
- Log3 ($name, 1, "DbRep $name - last query: $query");
- Log3 ($name, 1, "DbRep $name - $e");
- close(FH);
- $dbh->disconnect;
- return "$name|''|$err|''|''";
- }
- $i = 0;
- $line =~ /INSERT INTO (.*) VALUES \((.*)\);/;
- $v1 = $1;
- $v2 = $2;
- $base_query = qq{INSERT INTO $v1 VALUES };
- $query = $base_query;
- $query .= "(".$v2.")";
- $nc++ if($base_query =~ /INSERT INTO `current`.*/);
- $nh++ if($base_query =~ /INSERT INTO `history`.*/);
- $i++;
- }
- }
-
- if(length($query) >= $i_max) {
- $query = $query.";";
- eval {$dbh->do($query);
- };
- if ($@) {
- $e = $@;
- $err = encode_base64($e,"");
- Log3 ($name, 1, "DbRep $name - last query: $query");
- Log3 ($name, 1, "DbRep $name - $e");
- close(FH);
- $dbh->disconnect;
- return "$name|''|$err|''|''";
- }
- $i = 0;
- $query = '';
- $base_query = '';
- }
- $line = '';
- }
- }
-
- eval { $dbh->do($query) if($i);
- };
- if ($@) {
- $e = $@;
- $err = encode_base64($e,"");
- Log3 ($name, 1, "DbRep $name - last query: $query");
- Log3 ($name, 1, "DbRep $name - $e");
- close(FH);
- $dbh->disconnect;
- return "$name|''|$err|''|''";
- }
- $dbh->disconnect;
- close(FH);
-
- # SQL-Laufzeit ermitteln
- my $rt = tv_interval($st);
-
- # Background-Laufzeit ermitteln
- my $brt = tv_interval($bst);
-
- $rt = $rt.",".$brt;
-
- Log3 ($name, 3, "DbRep $name - Restore of '$dbname' finished - inserted history: $nh, inserted curent: $nc, time used: ".sprintf("%.0f",$brt)." seconds.");
-
-return "$name|$rt|''|$dump_path$bfile|$nh|$nc";
-}
-
-####################################################################################################
-# Auswertungsroutine Restore
-####################################################################################################
-sub DbRep_restoreDone($) {
- my ($string) = @_;
- my @a = split("\\|",$string);
- my $hash = $defs{$a[0]};
- my $bt = $a[1];
- my ($rt,$brt) = split(",", $bt);
- my $err = $a[2]?decode_base64($a[2]):undef;
- my $bfile = $a[3];
- my $drh = $a[4];
- my $drc = $a[5];
- my $name = $hash->{NAME};
- my $erread;
-
- delete($hash->{HELPER}{RUNNING_RESTORE});
-
- if ($err) {
- ReadingsSingleUpdateValue ($hash, "errortext", $err, 1);
- ReadingsSingleUpdateValue ($hash, "state", "error", 1);
- return;
- }
-
- readingsBeginUpdate($hash);
- ReadingsBulkUpdateValue($hash, "RestoreRowsHistory", $drh) if($drh);
- ReadingsBulkUpdateValue($hash, "RestoreRowsCurrent", $drc) if($drc);
- readingsEndUpdate($hash, 1);
-
- # Befehl nach Procedure ausführen
- $erread = DbRep_afterproc($hash, "restore");
-
- my $state = $erread?$erread:"Restore of $bfile finished";
- readingsBeginUpdate($hash);
- ReadingsBulkUpdateTimeState($hash,$brt,undef,$state);
- readingsEndUpdate($hash, 1);
-
- Log3 ($name, 3, "DbRep $name - Database restore finished successfully. ");
-
-return;
-}
-
-####################################################################################################
-# Übertragung Datensätze in weitere DB
-####################################################################################################
-sub DbRep_syncStandby($) {
- my ($string) = @_;
- my ($name,$device,$reading,$runtime_string_first,$runtime_string_next,$ts,$stbyname) = split("\\§", $string);
- my $hash = $defs{$name};
- my $table = "history";
- my $utf8 = defined($hash->{UTF8})?$hash->{UTF8}:0;
- my ($dbh,$dbhstby,$err,$sql,$irows,$irowdone);
- # Quell-DB
- my $dbloghash = $hash->{dbloghash};
- my $dbconn = $dbloghash->{dbconn};
- my $dbuser = $dbloghash->{dbuser};
- my $dblogname = $dbloghash->{NAME};
- my $dbpassword = $attr{"sec$dblogname"}{secret};
- # Standby-DB
- my $stbyhash = $defs{$stbyname};
- my $stbyconn = $stbyhash->{dbconn};
- my $stbyuser = $stbyhash->{dbuser};
- my $stbypasswd = $attr{"sec$stbyname"}{secret};
- my $stbyutf8 = defined($stbyhash->{UTF8})?$stbyhash->{UTF8}:0;
-
- # Background-Startzeit
- my $bst = [gettimeofday];
-
- # Verbindung zur Quell-DB
- eval {$dbh = DBI->connect("dbi:$dbconn", $dbuser, $dbpassword, { PrintError => 0, RaiseError => 1, AutoCommit => 1, mysql_enable_utf8 => $utf8 });};
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- return "$name|''|''|$err";
- }
-
- # Verbindung zur Standby-DB
- eval {$dbhstby = DBI->connect("dbi:$stbyconn", $stbyuser, $stbypasswd, { PrintError => 0, RaiseError => 1, AutoCommit => 1, mysql_enable_utf8 => $stbyutf8 });};
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- return "$name|''|''|$err";
- }
-
- # ist Zeiteingrenzung und/oder Aggregation gesetzt ? (wenn ja -> "?" in SQL sonst undef)
- my ($IsTimeSet,$IsAggrSet) = DbRep_checktimeaggr($hash);
- Log3 ($name, 5, "DbRep $name - IsTimeSet: $IsTimeSet, IsAggrSet: $IsAggrSet");
-
- # SQL-Startzeit
- my $st = [gettimeofday];
-
- my ($sth,$old,$new);
- eval { $dbh->begin_work() if($dbh->{AutoCommit}); }; # Transaktion wenn gewünscht und autocommit ein
- if ($@) {
- Log3($name, 2, "DbRep $name -> Error start transaction - $@");
- }
-
- # Timestampstring to Array
- my @ts = split("\\|", $ts);
- Log3 ($name, 5, "DbRep $name - Timestamp-Array: \n@ts");
-
- # DB-Abfrage zeilenweise für jeden Array-Eintrag
- $irows = 0;
- $irowdone = 0;
- my $selspec = "TIMESTAMP,DEVICE,TYPE,EVENT,READING,VALUE,UNIT";
- my $addon = '';
- foreach my $row (@ts) {
- my @a = split("#", $row);
- my $runtime_string = $a[0];
- my $runtime_string_first = $a[1];
- my $runtime_string_next = $a[2];
-
- if ($IsTimeSet || $IsAggrSet) {
- $sql = DbRep_createSelectSql($hash,"history",$selspec,$device,$reading,"'$runtime_string_first'","'$runtime_string_next'",$addon);
- } else {
- $sql = DbRep_createSelectSql($hash,"history",$selspec,$device,$reading,undef,undef,$addon);
- }
- Log3 ($name, 4, "DbRep $name - SQL execute: $sql");
-
- eval{ $sth = $dbh->prepare($sql);
- $sth->execute();
- };
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - $@");
- $dbh->disconnect;
- return "$name|''|''|$err";
- }
-
- no warnings 'uninitialized';
- # DATE _ESC_ TIME _ESC_ DEVICE _ESC_ TYPE _ESC_ EVENT _ESC_ READING _ESC_ VALUE _ESC_ UNIT
- my @row_array = map { ($_->[0] =~ s/ /_ESC_/r)."_ESC_".$_->[1]."_ESC_".$_->[2]."_ESC_".$_->[3]."_ESC_".$_->[4]."_ESC_".$_->[5]."_ESC_".$_->[6] } @{$sth->fetchall_arrayref()};
- use warnings;
-
- (undef,$irowdone,$err) = DbRep_WriteToDB($name,$dbhstby,$stbyhash,"0",@row_array) if(@row_array);
- if ($err) {
- Log3 ($name, 2, "DbRep $name - $err");
- $err = encode_base64($err,"");
- $dbh->disconnect;
- $dbhstby->disconnect();
- return "$name|''|''|$err";
- }
- $irows += $irowdone;
- }
-
- $dbh->disconnect();
- $dbhstby->disconnect();
-
- # SQL-Laufzeit ermitteln
- my $rt = tv_interval($st);
-
- # Background-Laufzeit ermitteln
- my $brt = tv_interval($bst);
-
- $rt = $rt.",".$brt;
-
- return "$name|$irows|$rt|0";
-}
-
-####################################################################################################
-# Auswertungsroutine Übertragung Datensätze in weitere DB
-####################################################################################################
-sub DbRep_syncStandbyDone($) {
- my ($string) = @_;
- my @a = split("\\|",$string);
- my $hash = $defs{$a[0]};
- my $name = $hash->{NAME};
- my $irows = $a[1];
- my $bt = $a[2];
- my ($rt,$brt) = split(",", $bt);
- my $err = $a[3]?decode_base64($a[3]):undef;
-
- if ($err) {
- ReadingsSingleUpdateValue ($hash, "errortext", $err, 1);
- ReadingsSingleUpdateValue ($hash, "state", "error", 1);
- delete($hash->{HELPER}{RUNNING_PID});
- Log3 ($name, 4, "DbRep $name -> BlockingCall change_Done finished");
- return;
- }
-
- # only for this block because of warnings if details of readings are not set
- no warnings 'uninitialized';
-
- readingsBeginUpdate($hash);
- ReadingsBulkUpdateValue ($hash, "number_lines_inserted_Standby", $irows);
- ReadingsBulkUpdateTimeState($hash,$brt,$rt,"done");
- readingsEndUpdate($hash, 1);
-
- # Befehl nach Procedure ausführen
- my $erread = DbRep_afterproc($hash, "syncStandby");
-
- delete($hash->{HELPER}{RUNNING_PID});
-
-return;
-}
-
-####################################################################################################
-# reduceLog - Historische Werte ausduennen non-blocking > Forum #41089
-#
-# $ots - reduce Logs älter als: Attribut "timeOlderThan" oder "timestamp_begin"
-# $nts - reduce Logs neuer als: Attribut "timeDiffToNow" oder "timestamp_end"
-####################################################################################################
-sub DbRep_reduceLog($) {
- my ($string) = @_;
- my ($name,$nts,$ots) = split("\\|", $string);
- my $hash = $defs{$name};
- my $dbloghash = $hash->{dbloghash};
- my $dbconn = $dbloghash->{dbconn};
- my $dbuser = $dbloghash->{dbuser};
- my $dblogname = $dbloghash->{NAME};
- my $dbmodel = $dbloghash->{MODEL};
- my $dbpassword = $attr{"sec$dblogname"}{secret};
- my @a = @{$hash->{HELPER}{REDUCELOG}};
- my $utf8 = defined($hash->{UTF8})?$hash->{UTF8}:0;
- delete $hash->{HELPER}{REDUCELOG};
- my ($ret,$row,$filter,$exclude,$c,$day,$hour,$lastHour,$updDate,$updHour,$average,$processingDay,$lastUpdH,%hourlyKnown,%averageHash,@excludeRegex,@dayRows,@averageUpd,@averageUpdD);
- my ($startTime,$currentHour,$currentDay,$deletedCount,$updateCount,$sum,$rowCount,$excludeCount) = (time(),99,0,0,0,0,0,0);
- my ($dbh,$err,$brt);
-
- Log3 ($name, 5, "DbRep $name -> Start DbLog_reduceLog");
-
- eval {$dbh = DBI->connect("dbi:$dbconn", $dbuser, $dbpassword, { PrintError => 0, RaiseError => 1, AutoInactiveDestroy => 1, mysql_enable_utf8 => $utf8 });};
-
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - DbRep_reduceLog - $@");
- return "$name|''|$err|''";
- }
-
- if ($a[-1] =~ /^EXCLUDE=(.+:.+)+/i) {
- ($filter) = $a[-1] =~ /^EXCLUDE=(.+)/i;
- @excludeRegex = split(',',$filter);
- } elsif ($a[-1] =~ /^INCLUDE=.+:.+$/i) {
- $filter = 1;
- }
- if (defined($a[2])) {
- $average = ($a[2] =~ /average=day/i) ? "AVERAGE=DAY" : ($a[2] =~ /average/i) ? "AVERAGE=HOUR" : 0;
- }
-
- Log3 ($name, 3, "DbRep $name - reduce data older than: $ots, newer than: $nts");
- Log3 ($name, 3, "DbRep $name - reduceLog requested with options: "
- .(($average) ? "$average" : '')
- .(($average && $filter) ? ", " : '').(($filter) ? uc((split('=',$a[-1]))[0]).'='.(split('=',$a[-1]))[1] : ''));
-
- if ($ots) {
- my ($sth_del, $sth_upd, $sth_delD, $sth_updD, $sth_get);
- eval { $sth_del = $dbh->prepare_cached("DELETE FROM history WHERE (DEVICE=?) AND (READING=?) AND (TIMESTAMP=?) AND (VALUE=?)");
- $sth_upd = $dbh->prepare_cached("UPDATE history SET TIMESTAMP=?, EVENT=?, VALUE=? WHERE (DEVICE=?) AND (READING=?) AND (TIMESTAMP=?) AND (VALUE=?)");
- $sth_delD = $dbh->prepare_cached("DELETE FROM history WHERE (DEVICE=?) AND (READING=?) AND (TIMESTAMP=?)");
- $sth_updD = $dbh->prepare_cached("UPDATE history SET TIMESTAMP=?, EVENT=?, VALUE=? WHERE (DEVICE=?) AND (READING=?) AND (TIMESTAMP=?)");
- $sth_get = $dbh->prepare("SELECT TIMESTAMP,DEVICE,'',READING,VALUE FROM history WHERE "
- .($a[-1] =~ /^INCLUDE=(.+):(.+)$/i ? "DEVICE like '$1' AND READING like '$2' AND " : '')
- ."TIMESTAMP < '$ots'".($nts?" AND TIMESTAMP >= '$nts' ":" ")."ORDER BY TIMESTAMP ASC"); # '' was EVENT, no longer in use
- };
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - DbRep_reduceLog - $@");
- return "$name|''|$err|''";
- }
-
- eval { $sth_get->execute(); };
- if ($@) {
- $err = encode_base64($@,"");
- Log3 ($name, 2, "DbRep $name - DbRep_reduceLog - $@");
- return "$name|''|$err|''";
- }
-
- do {
- $row = $sth_get->fetchrow_arrayref || ['0000-00-00 00:00:00','D','','R','V']; # || execute last-day dummy
- $ret = 1;
- ($day,$hour) = $row->[0] =~ /-(\d{2})\s(\d{2}):/;
- $rowCount++ if($day != 00);
- if ($day != $currentDay) {
- if ($currentDay) { # false on first executed day
- if (scalar @dayRows) {
- ($lastHour) = $dayRows[-1]->[0] =~ /(.*\d+\s\d{2}):/;
- $c = 0;
- for my $delRow (@dayRows) {
- $c++ if($day != 00 || $delRow->[0] !~ /$lastHour/);
- }
- if($c) {
- $deletedCount += $c;
- Log3 ($name, 3, "DbRep $name - reduceLog deleting $c records of day: $processingDay");
- $dbh->{RaiseError} = 1;
- $dbh->{PrintError} = 0;
- eval {$dbh->begin_work() if($dbh->{AutoCommit});};
- if ($@) {
- Log3 ($name, 2, "DbRep $name - DbRep_reduceLog - $@");
- }
- eval {
- my $i = 0;
- my $k = 1;
- my $th = ($#dayRows <= 2000)?100:($#dayRows <= 30000)?1000:10000;
- for my $delRow (@dayRows) {
- if($day != 00 || $delRow->[0] !~ /$lastHour/) {
- Log3 ($name, 4, "DbRep $name - DELETE FROM history WHERE (DEVICE=$delRow->[1]) AND (READING=$delRow->[3]) AND (TIMESTAMP=$delRow->[0]) AND (VALUE=$delRow->[4])");
- $sth_del->execute(($delRow->[1], $delRow->[3], $delRow->[0], $delRow->[4]));
- $i++;
- if($i == $th) {
- my $prog = $k * $i;
- Log3 ($name, 3, "DbRep $name - reduceLog deletion progress of day: $processingDay is: $prog");
- $i = 0;
- $k++;
- }
- }
- }
- };
- if ($@) {
- $err = $@;
- Log3 ($name, 2, "DbRep $name - reduceLog ! FAILED ! for day $processingDay: $err");
- eval {$dbh->rollback() if(!$dbh->{AutoCommit});};
- if ($@) {
- Log3 ($name, 2, "DbRep $name - DbRep_reduceLog - $@");
- }
- $ret = 0;
- } else {
- eval {$dbh->commit() if(!$dbh->{AutoCommit});};
- if ($@) {
- Log3 ($name, 2, "DbRep $name - DbRep_reduceLog - $@");
- }
- }
- $dbh->{RaiseError} = 0;
- $dbh->{PrintError} = 1;
- }
- @dayRows = ();
- }
-
- if ($ret && defined($a[3]) && $a[3] =~ /average/i) {
- $dbh->{RaiseError} = 1;
- $dbh->{PrintError} = 0;
- eval {$dbh->begin_work() if($dbh->{AutoCommit});};
- if ($@) {
- Log3 ($name, 2, "DbRep $name - DbRep_reduceLog - $@");
- }
- eval {
- push(@averageUpd, {%hourlyKnown}) if($day != 00);
-
- $c = 0;
- for my $hourHash (@averageUpd) { # Only count for logging...
- for my $hourKey (keys %$hourHash) {
- $c++ if ($hourHash->{$hourKey}->[0] && scalar(@{$hourHash->{$hourKey}->[4]}) > 1);
- }
- }
- $updateCount += $c;
- Log3 ($name, 3, "DbRep $name - reduceLog (hourly-average) updating $c records of day: $processingDay") if($c); # else only push to @averageUpdD
-
- my $i = 0;
- my $k = 1;
- my $th = ($c <= 2000)?100:($c <= 30000)?1000:10000;
- for my $hourHash (@averageUpd) {
- for my $hourKey (keys %$hourHash) {
- if ($hourHash->{$hourKey}->[0]) { # true if reading is a number
- ($updDate,$updHour) = $hourHash->{$hourKey}->[0] =~ /(.*\d+)\s(\d{2}):/;
- if (scalar(@{$hourHash->{$hourKey}->[4]}) > 1) { # true if reading has multiple records this hour
- for (@{$hourHash->{$hourKey}->[4]}) { $sum += $_; }
- $average = sprintf('%.3f', $sum/scalar(@{$hourHash->{$hourKey}->[4]}) );
- $sum = 0;
- Log3 ($name, 4, "DbRep $name - UPDATE history SET TIMESTAMP=$updDate $updHour:30:00, EVENT='rl_av_h', VALUE=$average WHERE DEVICE=$hourHash->{$hourKey}->[1] AND READING=$hourHash->{$hourKey}->[3] AND TIMESTAMP=$hourHash->{$hourKey}->[0] AND VALUE=$hourHash->{$hourKey}->[4]->[0]");
- $sth_upd->execute(("$updDate $updHour:30:00", 'rl_av_h', $average, $hourHash->{$hourKey}->[1], $hourHash->{$hourKey}->[3], $hourHash->{$hourKey}->[0], $hourHash->{$hourKey}->[4]->[0]));
-
- $i++;
- if($i == $th) {
- my $prog = $k * $i;
- Log3 ($name, 3, "DbRep $name - reduceLog (hourly-average) updating progress of day: $processingDay is: $prog");
- $i = 0;
- $k++;
- }
- push(@averageUpdD, ["$updDate $updHour:30:00", 'rl_av_h', $average, $hourHash->{$hourKey}->[1], $hourHash->{$hourKey}->[3], $updDate]) if (defined($a[3]) && $a[3] =~ /average=day/i);
- } else {
- push(@averageUpdD, [$hourHash->{$hourKey}->[0], $hourHash->{$hourKey}->[2], $hourHash->{$hourKey}->[4]->[0], $hourHash->{$hourKey}->[1], $hourHash->{$hourKey}->[3], $updDate]) if (defined($a[3]) && $a[3] =~ /average=day/i);
- }
- }
- }
- }
- };
- if ($@) {
- $err = $@;
- Log3 ($name, 2, "DbRep $name - reduceLog average=hour ! FAILED ! for day $processingDay: $err");
- eval {$dbh->rollback() if(!$dbh->{AutoCommit});};
- if ($@) {
- Log3 ($name, 2, "DbRep $name - DbRep_reduceLog - $@");
- }
- @averageUpdD = ();
- } else {
- eval {$dbh->commit() if(!$dbh->{AutoCommit});};
- if ($@) {
- Log3 ($name, 2, "DbRep $name - DbRep_reduceLog - $@");
- }
- }
- $dbh->{RaiseError} = 0;
- $dbh->{PrintError} = 1;
- @averageUpd = ();
- }
-
- if (defined($a[3]) && $a[3] =~ /average=day/i && scalar(@averageUpdD) && $day != 00) {
- $dbh->{RaiseError} = 1;
- $dbh->{PrintError} = 0;
- eval {$dbh->begin_work() if($dbh->{AutoCommit});};
- if ($@) {
- Log3 ($name, 2, "DbRep $name - DbRep_reduceLog - $@");
- }
- eval {
- for (@averageUpdD) {
- push(@{$averageHash{$_->[3].$_->[4]}->{tedr}}, [$_->[0], $_->[1], $_->[3], $_->[4]]);
- $averageHash{$_->[3].$_->[4]}->{sum} += $_->[2];
- $averageHash{$_->[3].$_->[4]}->{date} = $_->[5];
- }
-
- $c = 0;
- for (keys %averageHash) {
- if(scalar @{$averageHash{$_}->{tedr}} == 1) {
- delete $averageHash{$_};
- } else {
- $c += (scalar(@{$averageHash{$_}->{tedr}}) - 1);
- }
- }
- $deletedCount += $c;
- $updateCount += keys(%averageHash);
-
- my ($id,$iu) = 0;
- my ($kd,$ku) = 1;
- my $thd = ($c <= 2000)?100:($c <= 30000)?1000:10000;
- my $thu = ((keys %averageHash) <= 2000)?100:((keys %averageHash) <= 30000)?1000:10000;
- Log3 ($name, 3, "DbRep $name - reduceLog (daily-average) updating ".(keys %averageHash).", deleting $c records of day: $processingDay") if(keys %averageHash);
- for my $reading (keys %averageHash) {
- $average = sprintf('%.3f', $averageHash{$reading}->{sum}/scalar(@{$averageHash{$reading}->{tedr}}));
- $lastUpdH = pop @{$averageHash{$reading}->{tedr}};
- for (@{$averageHash{$reading}->{tedr}}) {
- Log3 ($name, 5, "DbRep $name - DELETE FROM history WHERE DEVICE='$_->[2]' AND READING='$_->[3]' AND TIMESTAMP='$_->[0]'");
- $sth_delD->execute(($_->[2], $_->[3], $_->[0]));
-
- $id++;
- if($id == $thd) {
- my $prog = $kd * $id;
- Log3 ($name, 3, "DbRep $name - reduceLog (daily-average) deleting progress of day: $processingDay is: $prog");
- $id = 0;
- $kd++;
- }
- }
- Log3 ($name, 4, "DbRep $name - UPDATE history SET TIMESTAMP=$averageHash{$reading}->{date} 12:00:00, EVENT='rl_av_d', VALUE=$average WHERE (DEVICE=$lastUpdH->[2]) AND (READING=$lastUpdH->[3]) AND (TIMESTAMP=$lastUpdH->[0])");
- $sth_updD->execute(($averageHash{$reading}->{date}." 12:00:00", 'rl_av_d', $average, $lastUpdH->[2], $lastUpdH->[3], $lastUpdH->[0]));
-
- $iu++;
- if($iu == $thu) {
- my $prog = $ku * $id;
- Log3 ($name, 3, "DbRep $name - reduceLog (daily-average) updating progress of day: $processingDay is: $prog");
- $iu = 0;
- $ku++;
- }
- }
- };
- if ($@) {
- Log3 ($name, 3, "DbRep $name - reduceLog average=day ! FAILED ! for day $processingDay");
- eval {$dbh->rollback() if(!$dbh->{AutoCommit});};
- if ($@) {
- Log3 ($name, 2, "DbRep $name - DbRep_reduceLog - $@");
- }
- } else {
- eval {$dbh->commit() if(!$dbh->{AutoCommit});};
- if ($@) {
- Log3 ($name, 2, "DbRep $name - DbRep_reduceLog - $@");
- }
- }
- $dbh->{RaiseError} = 0;
- $dbh->{PrintError} = 1;
- }
- %averageHash = ();
- %hourlyKnown = ();
- @averageUpd = ();
- @averageUpdD = ();
- $currentHour = 99;
- }
- $currentDay = $day;
- }
-
- if ($hour != $currentHour) { # forget records from last hour, but remember these for average
- if (defined($a[3]) && $a[3] =~ /average/i && keys(%hourlyKnown)) {
- push(@averageUpd, {%hourlyKnown});
- }
- %hourlyKnown = ();
- $currentHour = $hour;
- }
- if (defined $hourlyKnown{$row->[1].$row->[3]}) { # remember first readings for device per h, other can be deleted
- push(@dayRows, [@$row]);
- if (defined($a[3]) && $a[3] =~ /average/i && defined($row->[4]) && $row->[4] =~ /^-?(?:\d+(?:\.\d*)?|\.\d+)$/ && $hourlyKnown{$row->[1].$row->[3]}->[0]) {
- if ($hourlyKnown{$row->[1].$row->[3]}->[0]) {
- push(@{$hourlyKnown{$row->[1].$row->[3]}->[4]}, $row->[4]);
- }
- }
- } else {
- $exclude = 0;
- for (@excludeRegex) {
- $exclude = 1 if("$row->[1]:$row->[3]" =~ /^$_$/);
- }
- if ($exclude) {
- $excludeCount++ if($day != 00);
- } else {
- $hourlyKnown{$row->[1].$row->[3]} = (defined($row->[4]) && $row->[4] =~ /^-?(?:\d+(?:\.\d*)?|\.\d+)$/) ? [$row->[0],$row->[1],$row->[2],$row->[3],[$row->[4]]] : [0];
- }
- }
- $processingDay = (split(' ',$row->[0]))[0];
-
- } while( $day != 00 );
-
- $brt = sprintf('%.2f',time() - $startTime);
- my $result = "Rows processed: $rowCount, deleted: $deletedCount"
- .((defined($a[3]) && $a[3] =~ /average/i)? ", updated: $updateCount" : '')
- .(($excludeCount)? ", excluded: $excludeCount" : '');
- Log3 ($name, 3, "DbRep $name - reduceLog finished. $result");
- $ret = $result;
- $ret = "reduceLog finished. $result";
- } else {
- $err = "reduceLog needs at least one of attributes \"timeOlderThan\", \"timeDiffToNow\", \"timestamp_begin\" or \"timestamp_end\" to be set";
- Log3 ($name, 2, "DbRep $name - ERROR - $err");
- $err = encode_base64($err,"");
- return "$name|''|$err|''";
- }
-
- $dbh->disconnect();
- $ret = encode_base64($ret,"");
- Log3 ($name, 5, "DbRep $name -> DbRep_reduceLogNbl finished");
-
-return "$name|$ret|0|$brt";
-}
-
-####################################################################################################
-# reduceLog non-blocking Rückkehrfunktion
-####################################################################################################
-sub DbRep_reduceLogDone($) {
- my ($string) = @_;
- my @a = split("\\|",$string);
- my $name = $a[0];
- my $hash = $defs{$name};
- my $ret = decode_base64($a[1]);
- my $err = decode_base64($a[2]) if ($a[2]);
- my $brt = $a[3];
- my $dbloghash = $hash->{dbloghash};
- my $erread;
-
- delete $hash->{HELPER}{RUNNING_REDUCELOG};
-
- if ($err) {
- ReadingsSingleUpdateValue ($hash, "errortext", $err, 1);
- ReadingsSingleUpdateValue ($hash, "state", "error", 1);
- return;
- }
-
- # only for this block because of warnings if details of readings are not set
- no warnings 'uninitialized';
-
- readingsBeginUpdate($hash);
- ReadingsBulkUpdateValue($hash, "background_processing_time", sprintf("%.4f",$brt));
- ReadingsBulkUpdateValue($hash, "reduceLogState", $ret);
- readingsEndUpdate($hash, 1);
-
- # Befehl nach Procedure ausführen
- $erread = DbRep_afterproc($hash, "reduceLog");
-
- my $state = $erread?$erread:"reduceLog of $hash->{DATABASE} finished";
- readingsBeginUpdate($hash);
- ReadingsBulkUpdateTimeState($hash,undef,undef,$state);
- readingsEndUpdate($hash, 1);
-
- use warnings;
-
-return;
-}
-
-####################################################################################################
-# Abbruchroutine Timeout reduceLog
-####################################################################################################
-sub DbRep_reduceLogAborted(@) {
- my ($hash,$cause) = @_;
- my $name = $hash->{NAME};
- my $dbh = $hash->{DBH};
- my $erread;
-
- $cause = $cause?$cause:"Timeout: process terminated";
- Log3 ($name, 1, "DbRep $name - BlockingCall $hash->{HELPER}{RUNNING_REDUCELOG}{fn} pid:$hash->{HELPER}{RUNNING_REDUCELOG}{pid} $cause") if($hash->{HELPER}{RUNNING_REDUCELOG});
-
- # Befehl nach Procedure ausführen
- no warnings 'uninitialized';
- $erread = DbRep_afterproc($hash, "reduceLog");
- $erread = ", ".(split("but", $erread))[1] if($erread);
-
- my $state = $cause.$erread;
- $dbh->disconnect() if(defined($dbh));
- ReadingsSingleUpdateValue ($hash, "state", $state, 1);
-
- Log3 ($name, 2, "DbRep $name - Database reduceLog aborted due to \"$cause\" ");
-
- delete($hash->{HELPER}{RUNNING_REDUCELOG});
-
-return;
-}
-
-####################################################################################################
-# Abbruchroutine Timeout Restore
-####################################################################################################
-sub DbRep_restoreAborted(@) {
- my ($hash,$cause) = @_;
- my $name = $hash->{NAME};
- my $dbh = $hash->{DBH};
- my $erread;
-
- $cause = $cause?$cause:"Timeout: process terminated";
- Log3 ($name, 1, "DbRep $name - BlockingCall $hash->{HELPER}{RUNNING_RESTORE}{fn} pid:$hash->{HELPER}{RUNNING_RESTORE}{pid} $cause") if($hash->{HELPER}{RUNNING_RESTORE});
-
- # Befehl nach Procedure ausführen
- no warnings 'uninitialized';
- $erread = DbRep_afterproc($hash, "restore");
- $erread = ", ".(split("but", $erread))[1] if($erread);
-
- my $state = $cause.$erread;
- $dbh->disconnect() if(defined($dbh));
- ReadingsSingleUpdateValue ($hash, "state", $state, 1);
-
- Log3 ($name, 2, "DbRep $name - Database restore aborted due to \"$cause\" ");
-
- delete($hash->{HELPER}{RUNNING_RESTORE});
-
-return;
-}
-
-####################################################################################################
-# Abbruchroutine Timeout DB-Abfrage
-####################################################################################################
-sub DbRep_ParseAborted(@) {
- my ($hash,$cause) = @_;
- my $name = $hash->{NAME};
- my $dbh = $hash->{DBH};
- my $erread;
-
- $cause = $cause?$cause:"Timeout: process terminated";
- Log3 ($name, 1, "DbRep $name -> BlockingCall $hash->{HELPER}{RUNNING_PID}{fn} pid:$hash->{HELPER}{RUNNING_PID}{pid} $cause");
-
- # Befehl nach Procedure ausführen
- no warnings 'uninitialized';
- $erread = DbRep_afterproc($hash, "command");
- $erread = ", ".(split("but", $erread))[1] if($erread);
-
- $dbh->disconnect() if(defined($dbh));
- ReadingsSingleUpdateValue ($hash,"state",$cause, 1);
-
- delete($hash->{HELPER}{RUNNING_PID});
-return;
-}
-
-####################################################################################################
-# Abbruchroutine Timeout DB-Dump
-####################################################################################################
-sub DbRep_DumpAborted(@) {
- my ($hash,$cause) = @_;
- my $name = $hash->{NAME};
- my $dbh = $hash->{DBH};
- my ($erread);
-
- $cause = $cause?$cause:"Timeout: process terminated";
- Log3 ($name, 1, "DbRep $name - BlockingCall $hash->{HELPER}{RUNNING_BACKUP_CLIENT}{fn} pid:$hash->{HELPER}{RUNNING_BACKUP_CLIENT}{pid} $cause") if($hash->{HELPER}{RUNNING_BACKUP_CLIENT});
- Log3 ($name, 1, "DbRep $name - BlockingCall $hash->{HELPER}{RUNNING_BCKPREST_SERVER}{fn} pid:$hash->{HELPER}{RUNNING_BCKPREST_SERVER}{pid} $cause") if($hash->{HELPER}{RUNNING_BCKPREST_SERVER});
-
- # Befehl nach Procedure ausführen
- no warnings 'uninitialized';
- $erread = DbRep_afterproc($hash, "dump");
- $erread = ", ".(split("but", $erread))[1] if($erread);
-
- my $state = $cause.$erread;
- $dbh->disconnect() if(defined($dbh));
- ReadingsSingleUpdateValue ($hash, "state", $state, 1);
-
- Log3 ($name, 2, "DbRep $name - Database dump aborted due to \"$cause\" ");
-
- delete($hash->{HELPER}{RUNNING_BACKUP_CLIENT});
- delete($hash->{HELPER}{RUNNING_BCKPREST_SERVER});
-return;
-}
-
-####################################################################################################
-# Abbruchroutine Timeout DB-Abfrage
-####################################################################################################
-sub DbRep_OptimizeAborted(@) {
- my ($hash,$cause) = @_;
- my $name = $hash->{NAME};
- my $dbh = $hash->{DBH};
- my ($erread);
-
- $cause = $cause?$cause:"Timeout: process terminated";
- Log3 ($name, 1, "DbRep $name -> BlockingCall $hash->{HELPER}{RUNNING_OPTIMIZE}}{fn} pid:$hash->{HELPER}{RUNNING_OPTIMIZE}{pid} $cause");
-
- # Befehl nach Procedure ausführen
- no warnings 'uninitialized';
- $erread = DbRep_afterproc($hash, "optimize");
- $erread = ", ".(split("but", $erread))[1] if($erread);
-
- my $state = $cause.$erread;
- $dbh->disconnect() if(defined($dbh));
- ReadingsSingleUpdateValue ($hash, "state", $state, 1);
-
- Log3 ($name, 2, "DbRep $name - Database optimize aborted due to \"$cause\" ");
-
- delete($hash->{HELPER}{RUNNING_OPTIMIZE});
-return;
-}
-
-####################################################################################################
-# Abbruchroutine Repair SQlite
-####################################################################################################
-sub DbRep_RepairAborted(@) {
- my ($hash,$cause) = @_;
- my $name = $hash->{NAME};
- my $dbh = $hash->{DBH};
- my $dbloghash = $hash->{dbloghash};
- my $erread;
-
- $cause = $cause?$cause:"Timeout: process terminated";
- Log3 ($name, 1, "DbRep $name -> BlockingCall $hash->{HELPER}{RUNNING_REPAIR}{fn} pid:$hash->{HELPER}{RUNNING_REPAIR}{pid} $cause");
-
- # Datenbankverbindung in DbLog wieder öffenen
- my $dbl = $dbloghash->{NAME};
- CommandSet(undef,"$dbl reopen");
-
- # Befehl nach Procedure ausführen
- no warnings 'uninitialized';
- $erread = DbRep_afterproc($hash, "repair");
- $erread = ", ".(split("but", $erread))[1] if($erread);
-
- $dbh->disconnect() if(defined($dbh));
- ReadingsSingleUpdateValue ($hash,"state",$cause, 1);
-
- delete($hash->{HELPER}{RUNNING_REPAIR});
-return;
-}
-
-####################################################################################################
-# SQL-Statement zusammenstellen für DB-Abfrage
-####################################################################################################
-sub DbRep_createSelectSql($$$$$$$$) {
- my ($hash,$table,$selspec,$device,$reading,$tf,$tn,$addon) = @_;
- my $name = $hash->{NAME};
- my $dbmodel = $hash->{dbloghash}{MODEL};
- my ($sql,$devs,$danz,$ranz);
- my $tnfull = 0;
-
- ($devs,$danz,$reading,$ranz) = DbRep_specsForSql($hash,$device,$reading);
-
- if($tn && $tn =~ /(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})/) {
- $tnfull = 1;
- }
-
- $sql = "SELECT $selspec FROM $table where ";
- $sql .= "DEVICE LIKE '$devs' AND " if($danz <= 1 && $devs !~ m(^%$) && $devs =~ m(\%));
- $sql .= "DEVICE = '$devs' AND " if($danz <= 1 && $devs !~ m(\%));
- $sql .= "DEVICE IN ($devs) AND " if($danz > 1);
- $sql .= "READING LIKE '$reading' AND " if($ranz <= 1 && $reading !~ m(^%$) && $reading =~ m(\%));
- $sql .= "READING = '$reading' AND " if($ranz <= 1 && $reading !~ m(\%));
- $sql .= "READING IN ($reading) AND " if($ranz > 1);
- if (($tf && $tn)) {
- $sql .= "TIMESTAMP >= $tf AND TIMESTAMP ".($tnfull?"<=":"<")." $tn ";
- } else {
- if ($dbmodel eq "POSTGRESQL") {
- $sql .= "true ";
- } else {
- $sql .= "1 ";
- }
- }
- $sql .= "$addon;";
-
-return $sql;
-}
-
-####################################################################################################
-# SQL-Statement zusammenstellen für DB-Updates
-####################################################################################################
-sub DbRep_createUpdateSql($$$$$$$$) {
- my ($hash,$table,$selspec,$device,$reading,$tf,$tn,$addon) = @_;
- my $name = $hash->{NAME};
- my $dbmodel = $hash->{dbloghash}{MODEL};
- my ($sql,$devs,$danz,$ranz);
- my $tnfull = 0;
-
- ($devs,$danz,$reading,$ranz) = DbRep_specsForSql($hash,$device,$reading);
-
- if($tn =~ /(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})/) {
- $tnfull = 1;
- }
-
- $sql = "UPDATE $table SET $selspec AND ";
- $sql .= "DEVICE LIKE '$devs' AND " if($danz <= 1 && $devs !~ m(^%$) && $devs =~ m(\%));
- $sql .= "DEVICE = '$devs' AND " if($danz <= 1 && $devs !~ m(\%));
- $sql .= "DEVICE IN ($devs) AND " if($danz > 1);
- $sql .= "READING LIKE '$reading' AND " if($ranz <= 1 && $reading !~ m(^%$) && $reading =~ m(\%));
- $sql .= "READING = '$reading' AND " if($ranz <= 1 && $reading !~ m(\%));
- $sql .= "READING IN ($reading) AND " if($ranz > 1);
- if (($tf && $tn)) {
- $sql .= "TIMESTAMP >= $tf AND TIMESTAMP ".($tnfull?"<=":"<")." $tn ";
- } else {
- if ($dbmodel eq "POSTGRESQL") {
- $sql .= "true ";
- } else {
- $sql .= "1 ";
- }
- }
- $sql .= "$addon;";
-
-return $sql;
-}
-
-####################################################################################################
-# SQL-Statement zusammenstellen für Löschvorgänge
-####################################################################################################
-sub DbRep_createDeleteSql($$$$$$$) {
- my ($hash,$table,$device,$reading,$tf,$tn,$addon) = @_;
- my $name = $hash->{NAME};
- my $dbmodel = $hash->{dbloghash}{MODEL};
- my ($sql,$devs,$danz,$ranz);
- my $tnfull = 0;
-
- if($table eq "current") {
- $sql = "delete FROM $table; ";
- return $sql;
- }
-
- ($devs,$danz,$reading,$ranz) = DbRep_specsForSql($hash,$device,$reading);
-
- if($tn =~ /(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})/) {
- $tnfull = 1;
- }
-
- $sql = "delete FROM $table where ";
- $sql .= "DEVICE LIKE '$devs' AND " if($danz <= 1 && $devs !~ m(^%$) && $devs =~ m(\%));
- $sql .= "DEVICE = '$devs' AND " if($danz <= 1 && $devs !~ m(\%));
- $sql .= "DEVICE IN ($devs) AND " if($danz > 1);
- $sql .= "READING LIKE '$reading' AND " if($ranz <= 1 && $reading !~ m(^%$) && $reading =~ m(\%));
- $sql .= "READING = '$reading' AND " if($ranz <= 1 && $reading !~ m(\%));
- $sql .= "READING IN ($reading) AND " if($ranz > 1);
- if ($tf && $tn) {
- $sql .= "TIMESTAMP >= '$tf' AND TIMESTAMP ".($tnfull?"<=":"<")." '$tn' $addon;";
- } else {
- if ($dbmodel eq "POSTGRESQL") {
- $sql .= "true;";
- } else {
- $sql .= "1;";
- }
- }
-
-return $sql;
-}
-
-####################################################################################################
-# Ableiten von Device, Reading-Spezifikationen
-####################################################################################################
-sub DbRep_specsForSql($$$) {
- my ($hash,$device,$reading) = @_;
- my $name = $hash->{NAME};
-
- my @dvspcs = devspec2array($device);
- my $devs = join(",",@dvspcs);
- $devs =~ s/'/''/g; # escape ' with ''
- my $danz = $#dvspcs+1;
- if ($danz > 1) {
- $devs =~ s/,/','/g;
- $devs = "'".$devs."'";
- }
- Log3 $name, 5, "DbRep $name - Device specifications use for select: $devs";
-
- $reading =~ s/'/''/g; # escape ' with ''
- my @reads = split(",",$reading);
- my $ranz = $#reads+1;
- if ($ranz > 1) {
- $reading =~ s/,/','/g;
- $reading = "'".$reading."'";
- }
- Log3 $name, 5, "DbRep $name - Reading specification use for select: $reading";
-
-return ($devs,$danz,$reading,$ranz);
-}
-
-####################################################################################################
-# Check ob Zeitgrenzen bzw. Aggregation gesetzt sind, evtl. übertseuern (je nach Funktion)
-# Return "1" wenn Bedingung erfüllt, sonst "0"
-####################################################################################################
-sub DbRep_checktimeaggr ($) {
- my ($hash) = @_;
- my $name = $hash->{NAME};
- my $IsTimeSet = 0;
- my $IsAggrSet = 0;
- my $aggregation = AttrVal($name,"aggregation","no");
-
- if ( AttrVal($name,"timestamp_begin",undef) || AttrVal($name,"timestamp_end",undef) ||
- AttrVal($name,"timeDiffToNow",undef) || AttrVal($name,"timeOlderThan",undef) || AttrVal($name,"timeYearPeriod",undef) ) {
- $IsTimeSet = 1;
- }
-
- if ($aggregation ne "no") {
- $IsAggrSet = 1;
- }
- if($hash->{LASTCMD} =~ /delSeqDoublets/) {
- $aggregation = ($aggregation eq "no")?"day":$aggregation; # wenn Aggregation "no", für delSeqDoublets immer "day" setzen
- $IsAggrSet = 1;
- }
- if($hash->{LASTCMD} =~ /averageValue/ && AttrVal($name,"averageCalcForm","avgArithmeticMean") eq "avgDailyMeanGWS") {
- $aggregation = "day"; # für Tagesmittelwertberechnung des deutschen Wetterdienstes immer "day"
- $IsAggrSet = 1;
- }
- if($hash->{LASTCMD} =~ /delEntries|fetchrows|deviceRename|readingRename|tableCurrentFillup|reduceLog/) {
- $IsAggrSet = 0;
- $aggregation = "no";
- }
- if($hash->{LASTCMD} =~ /deviceRename|readingRename/) {
- $IsTimeSet = 0;
- }
- if($hash->{LASTCMD} =~ /changeValue/) {
- if($hash->{HELPER}{COMPLEX}) {
- $IsAggrSet = 1;
- $aggregation = "day";
- } else {
- $IsAggrSet = 0;
- $aggregation = "no";
- }
- }
- if($hash->{LASTCMD} =~ /syncStandby/ ) {
- if($aggregation !~ /day|hour|week/) {
- $aggregation = "day";
- $IsAggrSet = 1;
- }
- }
-
-return ($IsTimeSet,$IsAggrSet,$aggregation);
-}
-
-####################################################################################################
-# ReadingsSingleUpdate für Reading, Value, Event
-####################################################################################################
-sub ReadingsSingleUpdateValue ($$$$) {
- my ($hash,$reading,$val,$ev) = @_;
- my $name = $hash->{NAME};
-
- readingsSingleUpdate($hash, $reading, $val, $ev);
- DbRep_userexit($name, $reading, $val);
-
-return;
-}
-
-####################################################################################################
-# Readingsbulkupdate für Reading, Value
-# readingsBeginUpdate und readingsEndUpdate muss vor/nach Funktionsaufruf gesetzt werden
-####################################################################################################
-sub ReadingsBulkUpdateValue ($$$) {
- my ($hash,$reading,$val) = @_;
- my $name = $hash->{NAME};
-
- readingsBulkUpdate($hash, $reading, $val);
- DbRep_userexit($name, $reading, $val);
-
-return;
-}
-
-####################################################################################################
-# Readingsbulkupdate für processing_time, state
-# readingsBeginUpdate und readingsEndUpdate muss vor/nach Funktionsaufruf gesetzt werden
-####################################################################################################
-sub ReadingsBulkUpdateTimeState ($$$$) {
- my ($hash,$brt,$rt,$sval) = @_;
- my $name = $hash->{NAME};
-
- if(AttrVal($name, "showproctime", undef)) {
- readingsBulkUpdate($hash, "background_processing_time", sprintf("%.4f",$brt)) if(defined($brt));
- DbRep_userexit($name, "background_processing_time", sprintf("%.4f",$brt)) if(defined($brt));
- readingsBulkUpdate($hash, "sql_processing_time", sprintf("%.4f",$rt)) if(defined($rt));
- DbRep_userexit($name, "sql_processing_time", sprintf("%.4f",$rt)) if(defined($rt));
- }
-
- readingsBulkUpdate($hash, "state", $sval);
- DbRep_userexit($name, "state", $sval);
-
-return;
-}
-
-####################################################################################################
-# Anzeige von laufenden Blocking Prozessen
-####################################################################################################
-sub DbRep_getblockinginfo($@) {
- my ($hash) = @_;
- my $name = $hash->{NAME};
-
- my @rows;
- our %BC_hash;
- my $len = 99;
- foreach my $h (values %BC_hash) {
- next if($h->{terminated} || !$h->{pid});
- my @allk = keys%{$h};
- foreach my $k (@allk) {
- Log3 ($name, 5, "DbRep $name -> $k : ".$h->{$k});
- }
- my $fn = (ref($h->{fn}) ? ref($h->{fn}) : $h->{fn});
- my $arg = (ref($h->{arg}) ? ref($h->{arg}) : $h->{arg});
- my $arg1 = substr($arg,0,$len);
- $arg1 = $arg1."..." if(length($arg) > $len+1);
- my $to = ($h->{timeout} ? $h->{timeout} : "N/A");
- my $conn = ($h->{telnet} ? $h->{telnet} : "N/A");
- push @rows, "$h->{pid}|ESCAPED|$fn|ESCAPED|$arg1|ESCAPED|$to|ESCAPED|$conn";
- }
-
- # Readingaufbereitung
- readingsBeginUpdate($hash);
-
- if(!@rows) {
- ReadingsBulkUpdateTimeState($hash,undef,undef,"done - No BlockingCall processes running");
- readingsEndUpdate($hash, 1);
- return;
- }
-
- my $res = "";
- $res .= "PID ";
- $res .= "FUNCTION ";
- $res .= "ARGUMENTS ";
- $res .= "TIMEOUT ";
- $res .= "CONNECTEDVIA /g;
- $res .= " ".$row."
";
-
- ReadingsBulkUpdateValue ($hash,"BlockingInfo",$tab);
- ReadingsBulkUpdateValue ($hash,"Blocking_Count",$#rows+1);
-
- ReadingsBulkUpdateTimeState($hash,undef,undef,"done");
- readingsEndUpdate($hash, 1);
-
-return;
-}
-
-####################################################################################################
-# relative Zeitangaben als Sekunden normieren
-#
-# liefert die Attribute timeOlderThan, timeDiffToNow als Sekunden normiert zurück
-####################################################################################################
-sub DbRep_normRelTime($) {
- my ($hash) = @_;
- my $name = $hash->{NAME};
- my $tdtn = AttrVal($name, "timeDiffToNow", undef);
- my $toth = AttrVal($name, "timeOlderThan", undef);
-
- if($tdtn && $tdtn =~ /^\s*[ydhms]:(([\d]+.[\d]+)|[\d]+)\s*/) {
- my ($y,$d,$h,$m,$s);
- if($tdtn =~ /.*y:(([\d]+.[\d]+)|[\d]+).*/) {
- $y = $tdtn;
- $y =~ s/.*y:(([\d]+.[\d]+)|[\d]+).*/$1/e;
- }
- if($tdtn =~ /.*d:(([\d]+.[\d]+)|[\d]+).*/) {
- $d = $tdtn;
- $d =~ s/.*d:(([\d]+.[\d]+)|[\d]+).*/$1/e;
- }
- if($tdtn =~ /.*h:(([\d]+.[\d]+)|[\d]+).*/) {
- $h = $tdtn;
- $h =~ s/.*h:(([\d]+.[\d]+)|[\d]+).*/$1/e;
- }
- if($tdtn =~ /.*m:(([\d]+.[\d]+)|[\d]+).*/) {
- $m = $tdtn;
- $m =~ s/.*m:(([\d]+.[\d]+)|[\d]+).*/$1/e;
- }
- if($tdtn =~ /.*s:(([\d]+.[\d]+)|[\d]+).*/) {
- $s = $tdtn;
- $s =~ s/.*s:(([\d]+.[\d]+)|[\d]+).*/$1/e ;
- }
-
- no warnings 'uninitialized';
- Log3($name, 4, "DbRep $name - timeDiffToNow - year: $y, day: $d, hour: $h, min: $m, sec: $s ");
- use warnings;
- $y = $y?($y*365*86400):0;
- $d = $d?($d*86400):0;
- $h = $h?($h*3600):0;
- $m = $m?($m*60):0;
- $s = $s?$s:0;
-
- $tdtn = $y + $d + $h + $m + $s + 1; # one security second for correct create TimeArray
- $tdtn = DbRep_corrRelTime($name,$tdtn,1);
- }
-
- if($toth && $toth =~ /^\s*[ydhms]:(([\d]+.[\d]+)|[\d]+)\s*/) {
- my ($y,$d,$h,$m,$s);
- if($toth =~ /.*y:(([\d]+.[\d]+)|[\d]+).*/) {
- $y = $toth;
- $y =~ s/.*y:(([\d]+.[\d]+)|[\d]+).*/$1/e;
- }
- if($toth =~ /.*d:(([\d]+.[\d]+)|[\d]+).*/) {
- $d = $toth;
- $d =~ s/.*d:(([\d]+.[\d]+)|[\d]+).*/$1/e;
- }
- if($toth =~ /.*h:(([\d]+.[\d]+)|[\d]+).*/) {
- $h = $toth;
- $h =~ s/.*h:(([\d]+.[\d]+)|[\d]+).*/$1/e;
- }
- if($toth =~ /.*m:(([\d]+.[\d]+)|[\d]+).*/) {
- $m = $toth;
- $m =~ s/.*m:(([\d]+.[\d]+)|[\d]+).*/$1/e;
- }
- if($toth =~ /.*s:(([\d]+.[\d]+)|[\d]+).*/) {
- $s = $toth;
- $s =~ s/.*s:(([\d]+.[\d]+)|[\d]+).*/$1/e ;
- }
-
- no warnings 'uninitialized';
- Log3($name, 4, "DbRep $name - timeOlderThan - year: $y, day: $d, hour: $h, min: $m, sec: $s ");
- use warnings;
- $y = $y?($y*365*86400):0;
- $d = $d?($d*86400):0;
- $h = $h?($h*3600):0;
- $m = $m?($m*60):0;
- $s = $s?$s:0;
-
- $toth = $y + $d + $h + $m + $s + 1; # one security second for correct create TimeArray
- $toth = DbRep_corrRelTime($name,$toth,0);
- }
-return ($toth,$tdtn);
-}
-
-####################################################################################################
-# Korrektur Schaltjahr und Sommer/Winterzeit bei relativen Zeitangaben
-####################################################################################################
-sub DbRep_corrRelTime($$$) {
- my ($name,$tim,$tdtn) = @_;
- my $hash = $defs{$name};
-
- # year als Jahre seit 1900
- # $mon als 0..11
- my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst);
- my ($dsec,$dmin,$dhour,$dmday,$dmon,$dyear,$dwday,$dyday,$disdst);
- if($tdtn) {
- # timeDiffToNow
- ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime(time); # Startzeit Ableitung
- ($dsec,$dmin,$dhour,$dmday,$dmon,$dyear,$dwday,$dyday,$disdst) = localtime(time-$tim); # Analyse Zieltimestamp timeDiffToNow
- } else {
- # timeOlderThan
- ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime(time-$tim); # Startzeit Ableitung
- my $mints = $hash->{HELPER}{MINTS}?$hash->{HELPER}{MINTS}:"1970-01-01 01:00:00"; # Timestamp des 1. Datensatzes verwenden falls ermittelt
- my ($yyyy1, $mm1, $dd1, $hh1, $min1, $sec1) = ($mints =~ /(\d+)-(\d+)-(\d+) (\d+):(\d+):(\d+)/);
- my $tsend = timelocal($sec1, $min1, $hh1, $dd1, $mm1-1, $yyyy1-1900);
- ($dsec,$dmin,$dhour,$dmday,$dmon,$dyear,$dwday,$dyday,$disdst) = localtime($tsend); # Analyse Zieltimestamp timeOlderThan
- }
- $year += 1900;
- $dyear += 1900;
- my $k = $year - $dyear;
- my $mg = ((int($mon)+1)+(($year-$dyear-1)*12)+(11-int($dmon)+1)); # Gesamtzahl der Monate des Bewertungszeitraumes
- my $cly = 0; # Anzahl Schaltjahre innerhalb Beginn und Ende Auswertungszeitraum
- my $fly = 0; # erstes Schaltjahr nach Start
- my $lly = 0; # letzes Schaltjahr nach Start
- while ($dyear+$k >= $dyear) {
- my $ily = DbRep_IsLeapYear($name,$dyear+$k);
- $cly++ if($ily);
- $fly = $dyear+$k if($ily && !$fly);
- $lly = $dyear+$k if($ily);
- $k--;
- }
- # Log3($name, 4, "DbRep $name - countleapyear: $cly firstleapyear: $fly lastleapyear: $lly totalmonth: $mg isdaylight:$isdst destdaylight:$disdst");
- if( ($fly <= $year && $mon > 1) && ($lly > $dyear || ($lly = $dyear && $dmon < 1)) ) {
- $tim += $cly*86400;
- # Log3($name, 4, "DbRep $name - leap year correction 1");
- } else {
- $tim += ($cly-1)*86400 if($cly);
- # Log3($name, 4, "DbRep $name - leap year correction 2");
- }
-
- # Sommer/Winterzeitkorrektur
- $tim += ($disdst-$isdst)*3600 if($disdst != $isdst);
-
-return $tim;
-}
-
-####################################################################################################
-# liefert zurück ob übergebenes Jahr ein Schaltjahr ist ($ily = 1)
-#
-# Es gilt:
-# - Wenn ein Jahr durch 4 teilbar ist, ist es ein Schaltjahr, aber
-# - wenn es durch 100 teilbar ist, ist es kein schaltjahr, außer
-# - es ist durch 400 teilbar, dann ist es ein schaltjahr
-#
-####################################################################################################
-sub DbRep_IsLeapYear($$) {
- my ($name,$year) = @_;
- my $ily = 0;
- if ($year % 4 == 0 && $year % 100 != 0 || $year % 400 == 0) { # $year modulo 4 -> muß 0 sein
- $ily = 1;
- }
- Log3($name, 4, "DbRep $name - Year $year is leap year") if($ily);
-return $ily;
-}
-
-###############################################################################
-# Zeichencodierung für Fileexport filtern
-###############################################################################
-sub DbRep_charfilter($) {
- my ($txt) = @_;
-
- # nur erwünschte Zeichen, Filtern von Steuerzeichen
- $txt =~ tr/ A-Za-z0-9!"#$§%&'()*+,-.\/:;<=>?@[\\]^_`{|}~äöüÄÖÜ߀//cd;
-
-return($txt);
-}
-
-###################################################################################
-# Befehl vor Procedure ausführen
-###################################################################################
-sub DbRep_beforeproc ($$) {
- my ($hash, $txt) = @_;
- my $name = $hash->{NAME};
-
- # Befehl vor Procedure ausführen
- my $ebd = AttrVal($name, "executeBeforeProc", undef);
- if($ebd) {
- Log3 ($name, 3, "DbRep $name - execute command before $txt: '$ebd' ");
- my $err = AnalyzeCommandChain(undef, $ebd);
- if ($err) {
- Log3 ($name, 2, "DbRep $name - command message before $txt: \"$err\" ");
- my $erread = "Warning - message from command before $txt appeared";
- ReadingsSingleUpdateValue ($hash, "before".$txt."_message", $err, 1);
- ReadingsSingleUpdateValue ($hash, "state", $erread, 1);
- }
- }
-
-return;
-}
-
-###################################################################################
-# Befehl nach Procedure ausführen
-###################################################################################
-sub DbRep_afterproc ($$) {
- my ($hash, $txt) = @_;
- my $name = $hash->{NAME};
- my $erread;
-
- # Befehl nach Procedure ausführen
- no warnings 'uninitialized';
- my $ead = AttrVal($name, "executeAfterProc", undef);
- if($ead) {
- Log3 ($name, 4, "DbRep $name - execute command after $txt: '$ead' ");
- my $err = AnalyzeCommandChain(undef, $ead);
- if ($err) {
- Log3 ($name, 2, "DbRep $name - command message after $txt: \"$err\" ");
- ReadingsSingleUpdateValue ($hash, "after".$txt."_message", $err, 1);
- $erread = "Warning - $txt finished, but command message after $txt appeared";
- }
- }
-
-return $erread;
-}
-
-##############################################################################################
-# timestamp_begin, timestamp_end bei Einsatz datetime-Picker entsprechend
-# den Anforderungen formatieren
-##############################################################################################
-sub DbRep_formatpicker ($) {
- my ($str) = @_;
- if ($str =~ /^(\d{4})-(\d{2})-(\d{2})_(\d{2}):(\d{2})$/) {
- # Anpassung für datetime-Picker Widget
- $str =~ s/_/ /;
- $str = $str.":00";
- }
- if ($str =~ /^(\d{4})-(\d{2})-(\d{2})_(\d{2}):(\d{2}):(\d{2})$/) {
- # Anpassung für datetime-Picker Widget
- $str =~ s/_/ /;
- }
-return $str;
-}
-
-####################################################################################################
-# userexit - Funktion um userspezifische Programmaufrufe nach Aktualisierung eines Readings
-# zu ermöglichen, arbeitet OHNE Event abhängig vom Attr userExitFn
-#
-# Aufruf der mit $name,$reading,$value
-####################################################################################################
-sub DbRep_userexit ($$$) {
- my ($name,$reading,$value) = @_;
- my $hash = $defs{$name};
-
- return if(!$hash->{HELPER}{USEREXITFN});
-
- if(!defined($reading)) {$reading = "";}
- if(!defined($value)) {$value = "";}
- $value =~ s/\\/\\\\/g; # escapen of chars for evaluation
- $value =~ s/'/\\'/g;
-
- my $re = $hash->{HELPER}{UEFN_REGEXP}?$hash->{HELPER}{UEFN_REGEXP}:".*:.*";
-
- if("$reading:$value" =~ m/^$re$/ ) {
- my @res;
- my $cmd = $hash->{HELPER}{USEREXITFN}."('$name','$reading','$value')";
- $cmd = "{".$cmd."}";
- my $r = AnalyzeCommandChain(undef, $cmd);
- }
-return;
-}
-
-####################################################################################################
-# delete Readings before new operation
-####################################################################################################
-sub DbRep_delread($;$$) {
- # Readings löschen die nicht in der Ausnahmeliste (Attr readingPreventFromDel) stehen
- my ($hash,$shutdown) = @_;
- my $name = $hash->{NAME};
- my @allrds = keys%{$defs{$name}{READINGS}};
- if($shutdown) {
- my $do = 0;
- foreach my $key(@allrds) {
- # Highlighted Readings löschen und save statefile wegen Inkompatibilitär beim Restart
- if($key =~ /{HELPER}{RDPFDEL}) if($hash->{HELPER}{RDPFDEL});
- if(@rdpfdel) {
- foreach my $key(@allrds) {
- # Log3 ($name, 1, "DbRep $name - Reading Schlüssel: $key");
- my $dodel = 1;
- foreach my $rdpfdel(@rdpfdel) {
- if($key =~ /$rdpfdel/ || $key eq "state") {
- $dodel = 0;
- }
- }
- if($dodel) {
- delete($defs{$name}{READINGS}{$key});
- }
- }
- } else {
- foreach my $key(@allrds) {
- # Log3 ($name, 1, "DbRep $name - Reading Schlüssel: $key");
- delete($defs{$name}{READINGS}{$key}) if($key ne "state");
- }
- }
-return undef;
-}
-
-####################################################################################################
-# erstellen neues SQL-File für Dumproutine
-####################################################################################################
-sub DbRep_NewDumpFilename ($$$$$){
- my ($sql_text,$dump_path,$dbname,$time_stamp,$character_set) = @_;
- my $part = "";
- my $sql_file = $dump_path.$dbname."_".$time_stamp.$part.".sql";
- my $backupfile = $dbname."_".$time_stamp.$part.".sql";
-
- $sql_text .= "/*!40101 SET NAMES '".$character_set."' */;\n";
- $sql_text .= "SET FOREIGN_KEY_CHECKS=0;\n";
-
- my ($filesize,$err) = DbRep_WriteToDumpFile($sql_text,$sql_file);
- if($err) {
- return (undef,undef,undef,undef,$err);
- }
- chmod(0777,$sql_file);
- $sql_text = "";
- my $first_insert = 0;
-
-return ($sql_text,$first_insert,$sql_file,$backupfile,undef);
-}
-
-####################################################################################################
-# Schreiben DB-Dumps in SQL-File
-####################################################################################################
-sub DbRep_WriteToDumpFile ($$) {
- my ($inh,$sql_file) = @_;
- my $filesize;
- my $err = 0;
-
- if(length($inh) > 0) {
- unless(open(DATEI,">>$sql_file")) {
- $err = "Can't open file '$sql_file' for write access";
- return (undef,$err);
- }
- print DATEI $inh;
- close(DATEI);
-
- my $fref = stat($sql_file);
- if ($fref =~ /ARRAY/) {
- $filesize = (@{stat($sql_file)})[7];
- } else {
- $filesize = (stat($sql_file))[7];
- }
- }
-
-return ($filesize,undef);
-}
-
-####################################################################################################
-# Filesize (Byte) umwandeln in KB bzw. MB
-####################################################################################################
-sub DbRep_byteOutput ($) {
- my $bytes = shift;
-
- return if(!defined($bytes));
- return $bytes if(!looks_like_number($bytes));
- my $suffix = "Bytes";
- if ($bytes >= 1024) { $suffix = "KB"; $bytes = sprintf("%.2f",($bytes/1024));};
- if ($bytes >= 1024) { $suffix = "MB"; $bytes = sprintf("%.2f",($bytes/1024));};
- my $ret = sprintf "%.2f",$bytes;
- $ret.=' '.$suffix;
-
-return $ret;
-}
-
-####################################################################################################
-# Schreibroutine in DbRep Keyvalue-File
-####################################################################################################
-sub DbRep_setCmdFile($$$) {
- my ($key,$value,$hash) = @_;
- my $fName = $attr{global}{modpath}."/FHEM/FhemUtils/cacheDbRep";
-
- my $param = {
- FileName => $fName,
- ForceType => "file",
- };
- my ($err, @old) = FileRead($param);
-
- DbRep_createCmdFile($hash) if($err);
-
- my @new;
- my $fnd;
- foreach my $l (@old) {
- if($l =~ m/^$key:/) {
- $fnd = 1;
- push @new, "$key:$value" if(defined($value));
- } else {
- push @new, $l;
- }
- }
- push @new, "$key:$value" if(!$fnd && defined($value));
-
-return FileWrite($param, @new);
-}
-
-####################################################################################################
-# anlegen Keyvalue-File für DbRep wenn nicht vorhanden
-####################################################################################################
-sub DbRep_createCmdFile ($) {
- my ($hash) = @_;
- my $fName = $attr{global}{modpath}."/FHEM/FhemUtils/cacheDbRep";
-
- my $param = {
- FileName => $fName,
- ForceType => "file",
- };
- my @new;
- push(@new, "# This file is auto generated from 93_DbRep.",
- "# Please do not modify, move or delete it.",
- "");
-
-return FileWrite($param, @new);
-}
-
-####################################################################################################
-# Leseroutine aus DbRep Keyvalue-File
-####################################################################################################
-sub DbRep_getCmdFile($) {
- my ($key) = @_;
- my $fName = $attr{global}{modpath}."/FHEM/FhemUtils/cacheDbRep";
- my $param = {
- FileName => $fName,
- ForceType => "file",
- };
- my ($err, @l) = FileRead($param);
- return ($err, undef) if($err);
- for my $l (@l) {
- return (undef, $1) if($l =~ m/^$key:(.*)/);
- }
-
-return (undef, undef);
-}
-
-####################################################################################################
-# Tabellenoptimierung MySQL
-####################################################################################################
-sub DbRep_mysqlOptimizeTables ($$@) {
- my ($hash,$dbh,@tablenames) = @_;
- my $name = $hash->{NAME};
- my $dbname = $hash->{DATABASE};
- my $ret = 0;
- my $opttbl = 0;
- my $db_tables = $hash->{HELPER}{DBTABLES};
- my ($engine,$tablename,$query,$sth,$value,$db_MB_start,$db_MB_end);
-
- # Anfangsgröße ermitteln
- $query = "SELECT sum( data_length + index_length ) / 1024 / 1024 FROM information_schema.TABLES where table_schema='$dbname' ";
- Log3 ($name, 5, "DbRep $name - current query: $query ");
- eval { $sth = $dbh->prepare($query);
- $sth->execute;
- };
- if ($@) {
- Log3 ($name, 2, "DbRep $name - Error executing: '".$query."' ! MySQL-Error: ".$@);
- $sth->finish;
- $dbh->disconnect;
- return ($@,undef,undef);
- }
- $value = $sth->fetchrow();
-
- $db_MB_start = sprintf("%.2f",$value);
- Log3 ($name, 3, "DbRep $name - Size of database $dbname before optimize (MB): $db_MB_start");
-
- Log3($name, 3, "DbRep $name - Optimizing tables");
-
- foreach $tablename (@tablenames) {
- #optimize table if engine supports optimization
- $engine = '';
- $engine = uc($db_tables->{$tablename}{Engine}) if($db_tables->{$tablename}{Engine});
-
- if ($engine =~ /(MYISAM|BDB|INNODB|ARIA)/) {
- Log3($name, 3, "DbRep $name - Optimizing table `$tablename` ($engine). It will take a while.");
- my $sth_to = $dbh->prepare("OPTIMIZE TABLE `$tablename`");
- $ret = $sth_to->execute;
-
- if ($ret) {
- Log3($name, 3, "DbRep $name - Table ".($opttbl+1)." `$tablename` optimized successfully.");
- $opttbl++;
- } else {
- Log3($name, 2, "DbRep $name - Error while optimizing table $tablename. Continue with next table or backup.");
- }
- }
- }
-
- Log3($name, 3, "DbRep $name - $opttbl tables have been optimized.") if($opttbl > 0);
-
- # Endgröße ermitteln
- eval { $sth->execute; };
- if ($@) {
- Log3 ($name, 2, "DbRep $name - Error executing: '".$query."' ! MySQL-Error: ".$@);
- $sth->finish;
- $dbh->disconnect;
- return ($@,undef,undef);
- }
-
- $value = $sth->fetchrow();
- $db_MB_end = sprintf("%.2f",$value);
- Log3 ($name, 3, "DbRep $name - Size of database $dbname after optimize (MB): $db_MB_end");
-
- $sth->finish;
-
-return (undef,$db_MB_start,$db_MB_end);
-}
-
-####################################################################################################
-# Dump-Files im dumpDirLocal löschen bis auf die letzten "n"
-####################################################################################################
-sub DbRep_deldumpfiles ($$) {
- my ($hash,$bfile) = @_;
- my $name = $hash->{NAME};
- my $dbloghash = $hash->{dbloghash};
- my $dump_path_def = $attr{global}{modpath}."/log/";
- my $dump_path_loc = AttrVal($name,"dumpDirLocal", $dump_path_def);
- $dump_path_loc = $dump_path_loc."/" unless($dump_path_loc =~ m/\/$/);
- my $dfk = AttrVal($name,"dumpFilesKeep", 3);
- my $pfix = (split '\.', $bfile)[1];
- my $dbname = (split '_', $bfile)[0];
- my $file = $dbname."_.*".$pfix.".*"; # Files mit/ohne Endung "gzip" berücksichtigen
- my @fd;
-
- if(!opendir(DH, $dump_path_loc)) {
- push(@fd, "No files deleted - Can't open path '$dump_path_loc'");
- return @fd;
- }
- my @files = sort grep {/^$file$/} readdir(DH);
-
- my $fref = stat("$dump_path_loc/$bfile");
-
- if ($fref =~ /ARRAY/) {
- @files = sort { (@{stat("$dump_path_loc/$a")})[9] cmp (@{stat("$dump_path_loc/$b")})[9] } @files
- if(AttrVal("global", "archivesort", "alphanum") eq "timestamp");
- } else {
- @files = sort { (stat("$dump_path_loc/$a"))[9] cmp (stat("$dump_path_loc/$b"))[9] } @files
- if(AttrVal("global", "archivesort", "alphanum") eq "timestamp");
- }
-
- closedir(DH);
-
- Log3($name, 5, "DbRep $name - Dump files have been found in dumpDirLocal '$dump_path_loc': ".join(', ',@files) );
-
- my $max = int(@files)-$dfk;
-
- for(my $i = 0; $i < $max; $i++) {
- push(@fd, $files[$i]);
- Log3($name, 3, "DbRep $name - Deleting old dumpfile '$files[$i]' ");
- unlink("$dump_path_loc/$files[$i]");
- }
-
-return @fd;
-}
-
-####################################################################################################
-# Dumpfile komprimieren
-####################################################################################################
-sub DbRep_dumpCompress ($$) {
- my ($hash,$bfile) = @_;
- my $name = $hash->{NAME};
- my $dump_path_def = $attr{global}{modpath}."/log/";
- my $dump_path_loc = AttrVal($name,"dumpDirLocal", $dump_path_def);
- $dump_path_loc =~ s/(\/$|\\$)//;
- my $input = $dump_path_loc."/".$bfile;
- my $output = $dump_path_loc."/".$bfile.".gzip";
-
- Log3($name, 3, "DbRep $name - compress file $input");
-
- my $stat = gzip $input => $output ,BinModeIn => 1;
- if($GzipError) {
- Log3($name, 2, "DbRep $name - gzip of $input failed: $GzipError");
- return ($GzipError,$input);
- }
-
- Log3($name, 3, "DbRep $name - file compressed to output file: $output");
- unlink("$input");
- Log3($name, 3, "DbRep $name - input file deleted: $input");
-
-return (undef,$bfile.".gzip");
-}
-
-####################################################################################################
-# Dumpfile dekomprimieren
-####################################################################################################
-sub DbRep_dumpUnCompress ($$) {
- my ($hash,$bfile) = @_;
- my $name = $hash->{NAME};
- my $dump_path_def = $attr{global}{modpath}."/log/";
- my $dump_path_loc = AttrVal($name,"dumpDirLocal", $dump_path_def);
- $dump_path_loc =~ s/(\/$|\\$)//;
- my $input = $dump_path_loc."/".$bfile;
- my $outfile = $bfile;
- $outfile =~ s/\.gzip//;
- my $output = $dump_path_loc."/".$outfile;
-
- Log3($name, 3, "DbRep $name - uncompress file $input");
-
- my $stat = gunzip $input => $output ,BinModeOut => 1;
- if($GunzipError) {
- Log3($name, 2, "DbRep $name - gunzip of $input failed: $GunzipError");
- return ($GunzipError,$input);
- }
-
- Log3($name, 3, "DbRep $name - file uncompressed to output file: $output");
-
- # Größe dekomprimiertes File ermitteln
- my @a = split(' ',qx(du $output)) if ($^O =~ m/linux/i || $^O =~ m/unix/i);
-
- my $filesize = ($a[0])?($a[0]*1024):undef;
- my $fsize = DbRep_byteOutput($filesize);
- Log3 ($name, 3, "DbRep $name - Size of uncompressed file: ".$fsize);
-
-return (undef,$outfile);
-}
-
-####################################################################################################
-# erzeugtes Dump-File aus dumpDirLocal zum FTP-Server übertragen
-####################################################################################################
-sub DbRep_sendftp ($$) {
- my ($hash,$bfile) = @_;
- my $name = $hash->{NAME};
- my $dump_path_def = $attr{global}{modpath}."/log/";
- my $dump_path_loc = AttrVal($name,"dumpDirLocal", $dump_path_def);
- my $file = (split /[\/]/, $bfile)[-1];
- my $ftpto = AttrVal($name,"ftpTimeout",30);
- my $ftpUse = AttrVal($name,"ftpUse",0);
- my $ftpuseSSL = AttrVal($name,"ftpUseSSL",0);
- my $ftpDir = AttrVal($name,"ftpDir","/");
- my $ftpPort = AttrVal($name,"ftpPort",21);
- my $ftpServer = AttrVal($name,"ftpServer",undef);
- my $ftpUser = AttrVal($name,"ftpUser","anonymous");
- my $ftpPwd = AttrVal($name,"ftpPwd",undef);
- my $ftpPassive = AttrVal($name,"ftpPassive",0);
- my $ftpDebug = AttrVal($name,"ftpDebug",0);
- my $fdfk = AttrVal($name,"ftpDumpFilesKeep", 3);
- my $pfix = (split '\.', $bfile)[1];
- my $dbname = (split '_', $bfile)[0];
- my $ftpl = $dbname."_.*".$pfix.".*"; # Files mit/ohne Endung "gzip" berücksichtigen
- my ($ftperr,$ftpmsg,$ftp);
-
- # kein FTP verwenden oder möglich
- return ($ftperr,$ftpmsg) if((!$ftpUse && !$ftpuseSSL) || !$bfile);
-
- if(!$ftpServer) {
- $ftperr = "FTP-Error: FTP-Server isn't set.";
- Log3($name, 2, "DbRep $name - $ftperr");
- return ($ftperr,undef);
- }
-
- if(!opendir(DH, $dump_path_loc)) {
- $ftperr = "FTP-Error: Can't open path '$dump_path_loc'";
- Log3($name, 2, "DbRep $name - $ftperr");
- return ($ftperr,undef);
- }
-
- my $mod_ftpssl = 0;
- my $mod_ftp = 0;
- my $mod;
-
- if ($ftpuseSSL) {
- # FTP mit SSL soll genutzt werden
- $mod = "Net::FTPSSL => e.g. with 'sudo cpan -i Net::FTPSSL' ";
- eval { require Net::FTPSSL; };
- if(!$@){
- $mod_ftpssl = 1;
- import Net::FTPSSL;
- }
- } else {
- # nur FTP
- $mod = "Net::FTP";
- eval { require Net::FTP; };
- if(!$@){
- $mod_ftp = 1;
- import Net::FTP;
- }
- }
-
- if ($ftpuseSSL && $mod_ftpssl) {
- # use ftp-ssl
- my $enc = "E";
- eval { $ftp = Net::FTPSSL->new($ftpServer, Port => $ftpPort, Timeout => $ftpto, Debug => $ftpDebug, Encryption => $enc) }
- or $ftperr = "FTP-SSL-ERROR: Can't connect - $@";
- } elsif (!$ftpuseSSL && $mod_ftp) {
- # use plain ftp
- eval { $ftp = Net::FTP->new($ftpServer, Port => $ftpPort, Timeout => $ftpto, Debug => $ftpDebug, Passive => $ftpPassive) }
- or $ftperr = "FTP-Error: Can't connect - $@";
- } else {
- $ftperr = "FTP-Error: required module couldn't be loaded. You have to install it first: $mod.";
- }
- if ($ftperr) {
- Log3($name, 2, "DbRep $name - $ftperr");
- return ($ftperr,undef);
- }
-
- my $pwdstr = $ftpPwd?$ftpPwd:" ";
- $ftp->login($ftpUser, $ftpPwd) or $ftperr = "FTP-Error: Couldn't login with user '$ftpUser' and password '$pwdstr' ";
- if ($ftperr) {
- Log3($name, 2, "DbRep $name - $ftperr");
- return ($ftperr,undef);
- }
-
- $ftp->binary();
-
- # FTP Verzeichnis setzen
- $ftp->cwd($ftpDir) or $ftperr = "FTP-Error: Couldn't change directory to '$ftpDir' ";
- if ($ftperr) {
- Log3($name, 2, "DbRep $name - $ftperr");
- return ($ftperr,undef);
- }
-
- $dump_path_loc =~ s/(\/$|\\$)//;
- Log3($name, 3, "DbRep $name - FTP: transferring ".$dump_path_loc."/".$file);
-
- $ftpmsg = $ftp->put($dump_path_loc."/".$file);
- if (!$ftpmsg) {
- $ftperr = "FTP-Error: Couldn't transfer ".$file." to ".$ftpServer." into dir ".$ftpDir;
- Log3($name, 2, "DbRep $name - $ftperr");
- } else {
- $ftpmsg = "FTP: ".$file." transferred successfully to ".$ftpServer." into dir ".$ftpDir;
- Log3($name, 3, "DbRep $name - $ftpmsg");
- }
-
- # Versionsverwaltung FTP-Verzeichnis
- my (@ftl,@ftpfd);
- if($ftpuseSSL) {
- @ftl = sort grep {/^$ftpl$/} $ftp->nlst();
- } else {
- @ftl = sort grep {/^$ftpl$/} @{$ftp->ls()};
- }
- Log3($name, 5, "DbRep $name - FTP: filelist of \"$ftpDir\": @ftl");
- my $max = int(@ftl)-$fdfk;
- for(my $i = 0; $i < $max; $i++) {
- push(@ftpfd, $ftl[$i]);
- Log3($name, 3, "DbRep $name - FTP: deleting old dumpfile '$ftl[$i]' ");
- $ftp->delete($ftl[$i]);
- }
-
-return ($ftperr,$ftpmsg,@ftpfd);
-}
-
-####################################################################################################
-# Test auf Daylight saving time
-####################################################################################################
-sub DbRep_dsttest ($$$) {
- my ($hash,$runtime,$aggsec) = @_;
- my $name = $hash->{NAME};
- my $dstchange = 0;
-
- # der Wechsel der daylight saving time wird dadurch getestet, dass geprüft wird
- # ob im Vergleich der aktuellen zur nächsten Selektionsperiode von "$aggsec (day, week, month)"
- # ein Wechsel der daylight saving time vorliegt
-
- my $dst = (localtime($runtime))[8]; # ermitteln daylight saving aktuelle runtime
- my $time_str = localtime($runtime+$aggsec); # textual time representation
- my $dst_new = (localtime($runtime+$aggsec))[8]; # ermitteln daylight saving nächste runtime
-
- if ($dst != $dst_new) {
- $dstchange = 1;
- }
-
- Log3 ($name, 5, "DbRep $name - Daylight savings changed: $dstchange (on $time_str)");
-
-return $dstchange;
-}
-
-####################################################################################################
-# Counthash Untersuchung
-# Logausgabe der Anzahl verarbeiteter Datensätze pro Zeitraum / Aggregation
-# Rückgabe eines ncp-hash (no calc in period) mit den Perioden für die keine Differenz berechnet
-# werden konnte weil nur ein Datensatz in der Periode zur Verfügung stand
-####################################################################################################
-sub DbRep_calcount ($$) {
- my ($hash,$ch) = @_;
- my $name = $hash->{NAME};
- my %ncp = ();
-
- Log3 ($name, 4, "DbRep $name - count of values used for calc:");
- foreach my $key (sort(keys%{$ch})) {
- Log3 ($name, 4, "$key => ". $ch->{$key});
-
- if($ch->{$key} eq "1") {
- $ncp{"$key"} = " ||";
- }
- }
-return \%ncp;
-}
-
-####################################################################################################
-# Funktionsergebnisse in Datenbank schreiben
-####################################################################################################
-sub DbRep_OutputWriteToDB($$$$$) {
- my ($name,$device,$reading,$arrstr,$optxt) = @_;
- my $hash = $defs{$name};
- my $dbloghash = $hash->{dbloghash};
- my $dbconn = $dbloghash->{dbconn};
- my $dbuser = $dbloghash->{dbuser};
- my $dblogname = $dbloghash->{NAME};
- my $dbmodel = $hash->{dbloghash}{MODEL};
- my $DbLogType = AttrVal($hash->{dbloghash}{NAME}, "DbLogType", "History");
- my $supk = AttrVal($hash->{dbloghash}{NAME}, "noSupportPK", 0);
- my $dbpassword = $attr{"sec$dblogname"}{secret};
- my $utf8 = defined($hash->{UTF8})?$hash->{UTF8}:0;
- $device =~ s/[^A-Za-z\/\d_\.-]/\//g;
- $reading =~ s/[^A-Za-z\/\d_\.-]/\//g;
- my $type = "calculated";
- my $event = "calculated";
- my $unit = "";
- my $wrt = 0;
- my $irowdone = 0;
- my ($dbh,$sth_ih,$sth_uh,$sth_ic,$sth_uc,$err,$timestamp,$value,$date,$time,$rsf,$aggr,@row_array);
-
- if(!$hash->{dbloghash}{HELPER}{COLSET}) {
- $err = "No result of \"$hash->{LASTCMD}\" to database written. Cause: column width in \"$hash->{DEF}\" isn't set";
- return ($wrt,$irowdone,$err);
- }
-
- no warnings 'uninitialized';
- (undef,undef,$aggr) = DbRep_checktimeaggr($hash);
- $reading = $optxt."_".$aggr."_".AttrVal($name, "readingNameMap", $reading);
-
- $type = $defs{$device}{TYPE} if($defs{$device}); # $type vom Device ableiten
-
- if($optxt =~ /avg|sum/) {
- my @arr = split("\\|", $arrstr);
- foreach my $row (@arr) {
- my @a = split("#", $row);
- my $runtime_string = $a[0]; # Aggregations-Alias (nicht benötigt)
- $value = defined($a[1])?sprintf("%.4f",$a[1]):undef;
- $rsf = $a[2]; # Datum / Zeit für DB-Speicherung
- ($date,$time) = split("_",$rsf);
- $time =~ s/-/:/g if($time);
-
- if($time !~ /^(\d{2}):(\d{2}):(\d{2})$/) {
- if($aggr =~ /no|day|week|month/) {
- $time = "23:59:58";
- } elsif ($aggr =~ /hour/) {
- $time = "$time:59:58";
- }
- }
- if ($value) {
- # Daten auf maximale Länge beschneiden (DbLog-Funktion !)
- ($device,$type,$event,$reading,$value,$unit) = DbLog_cutCol($hash->{dbloghash},$device,$type,$event,$reading,$value,$unit);
- push(@row_array, "$date $time|$device|$type|$event|$reading|$value|$unit");
- }
- }
- }
-
- if($optxt =~ /min|max|diff/) {
- my %rh = split("§", $arrstr);
- foreach my $key (sort(keys(%rh))) {
- my @k = split("\\|",$rh{$key});
- $rsf = $k[2]; # Datum / Zeit für DB-Speicherung
- $value = defined($k[1])?sprintf("%.4f",$k[1]):undef;
- ($date,$time) = split("_",$rsf);
- $time =~ s/-/:/g if($time);
-
- if($time !~ /^(\d{2}):(\d{2}):(\d{2})$/) {
- if($aggr =~ /no|day|week|month/) {
- $time = "23:59:58";
- } elsif ($aggr =~ /hour/) {
- $time = "$time:59:58";
- }
- }
- if ($value) {
- # Daten auf maximale Länge beschneiden (DbLog-Funktion !)
- ($device,$type,$event,$reading,$value,$unit) = DbLog_cutCol($hash->{dbloghash},$device,$type,$event,$reading,$value,$unit);
- push(@row_array, "$date $time|$device|$type|$event|$reading|$value|$unit");
- }
- }
- }
-
- if (@row_array) {
- # Schreibzyklus aktivieren
- eval {$dbh = DBI->connect("dbi:$dbconn", $dbuser, $dbpassword, { PrintError => 0, RaiseError => 1, AutoCommit => 1, mysql_enable_utf8 => $utf8 });};
- if ($@) {
- $err = $@;
- Log3 ($name, 2, "DbRep $name - $@");
- return ($wrt,$irowdone,$err);
- }
-
- # check ob PK verwendet wird, @usepkx?Anzahl der Felder im PK:0 wenn kein PK, $pkx?Namen der Felder:none wenn kein PK
- my ($usepkh,$usepkc,$pkh,$pkc);
- if (!$supk) {
- ($usepkh,$usepkc,$pkh,$pkc) = DbRep_checkUsePK($hash,$dbloghash,$dbh);
- } else {
- Log3 $hash->{NAME}, 5, "DbRep $name -> Primary Key usage suppressed by attribute noSupportPK in DbLog \"$dblogname\"";
- }
-
- if (lc($DbLogType) =~ m(history)) {
- # insert history mit/ohne primary key
- if ($usepkh && $dbloghash->{MODEL} eq 'MYSQL') {
- eval { $sth_ih = $dbh->prepare_cached("INSERT IGNORE INTO history (TIMESTAMP, DEVICE, TYPE, EVENT, READING, VALUE, UNIT) VALUES (?,?,?,?,?,?,?)"); };
- } elsif ($usepkh && $dbloghash->{MODEL} eq 'SQLITE') {
- eval { $sth_ih = $dbh->prepare_cached("INSERT OR IGNORE INTO history (TIMESTAMP, DEVICE, TYPE, EVENT, READING, VALUE, UNIT) VALUES (?,?,?,?,?,?,?)"); };
- } elsif ($usepkh && $dbloghash->{MODEL} eq 'POSTGRESQL') {
- eval { $sth_ih = $dbh->prepare_cached("INSERT INTO history (TIMESTAMP, DEVICE, TYPE, EVENT, READING, VALUE, UNIT) VALUES (?,?,?,?,?,?,?) ON CONFLICT DO NOTHING"); };
- } else {
- eval { $sth_ih = $dbh->prepare_cached("INSERT INTO history (TIMESTAMP, DEVICE, TYPE, EVENT, READING, VALUE, UNIT) VALUES (?,?,?,?,?,?,?)"); };
- }
- if ($@) {
- $err = $@;
- Log3 ($name, 2, "DbRep $name - $@");
- return ($wrt,$irowdone,$err);
- }
- # update history mit/ohne primary key
- if ($usepkh && $hash->{MODEL} eq 'MYSQL') {
- $sth_uh = $dbh->prepare("REPLACE INTO history (TYPE, EVENT, VALUE, UNIT, TIMESTAMP, DEVICE, READING) VALUES (?,?,?,?,?,?,?)");
- } elsif ($usepkh && $hash->{MODEL} eq 'SQLITE') {
- $sth_uh = $dbh->prepare("INSERT OR REPLACE INTO history (TYPE, EVENT, VALUE, UNIT, TIMESTAMP, DEVICE, READING) VALUES (?,?,?,?,?,?,?)");
- } elsif ($usepkh && $hash->{MODEL} eq 'POSTGRESQL') {
- $sth_uh = $dbh->prepare("INSERT INTO history (TYPE, EVENT, VALUE, UNIT, TIMESTAMP, DEVICE, READING) VALUES (?,?,?,?,?,?,?) ON CONFLICT ($pkc)
- DO UPDATE SET TIMESTAMP=EXCLUDED.TIMESTAMP, DEVICE=EXCLUDED.DEVICE, TYPE=EXCLUDED.TYPE, EVENT=EXCLUDED.EVENT, READING=EXCLUDED.READING,
- VALUE=EXCLUDED.VALUE, UNIT=EXCLUDED.UNIT");
- } else {
- $sth_uh = $dbh->prepare("UPDATE history SET TYPE=?, EVENT=?, VALUE=?, UNIT=? WHERE (TIMESTAMP=?) AND (DEVICE=?) AND (READING=?)");
- }
- }
-
- if (lc($DbLogType) =~ m(current) ) {
- # insert current mit/ohne primary key
- if ($usepkc && $hash->{MODEL} eq 'MYSQL') {
- eval { $sth_ic = $dbh->prepare("INSERT IGNORE INTO current (TIMESTAMP, DEVICE, TYPE, EVENT, READING, VALUE, UNIT) VALUES (?,?,?,?,?,?,?)"); };
- } elsif ($usepkc && $hash->{MODEL} eq 'SQLITE') {
- eval { $sth_ic = $dbh->prepare("INSERT OR IGNORE INTO current (TIMESTAMP, DEVICE, TYPE, EVENT, READING, VALUE, UNIT) VALUES (?,?,?,?,?,?,?)"); };
- } elsif ($usepkc && $hash->{MODEL} eq 'POSTGRESQL') {
- eval { $sth_ic = $dbh->prepare("INSERT INTO current (TIMESTAMP, DEVICE, TYPE, EVENT, READING, VALUE, UNIT) VALUES (?,?,?,?,?,?,?) ON CONFLICT DO NOTHING"); };
- } else {
- # old behavior
- eval { $sth_ic = $dbh->prepare("INSERT INTO current (TIMESTAMP, DEVICE, TYPE, EVENT, READING, VALUE, UNIT) VALUES (?,?,?,?,?,?,?)"); };
- }
- if ($@) {
- $err = $@;
- Log3 ($name, 2, "DbRep $name - $@");
- return ($wrt,$irowdone,$err);
- }
- # update current mit/ohne primary key
- if ($usepkc && $hash->{MODEL} eq 'MYSQL') {
- $sth_uc = $dbh->prepare("REPLACE INTO current (TIMESTAMP, DEVICE, TYPE, EVENT, READING, VALUE, UNIT) VALUES (?,?,?,?,?,?,?)");
- } elsif ($usepkc && $hash->{MODEL} eq 'SQLITE') {
- $sth_uc = $dbh->prepare("INSERT OR REPLACE INTO current (TIMESTAMP, DEVICE, TYPE, EVENT, READING, VALUE, UNIT) VALUES (?,?,?,?,?,?,?)");
- } elsif ($usepkc && $hash->{MODEL} eq 'POSTGRESQL') {
- $sth_uc = $dbh->prepare("INSERT INTO current (TIMESTAMP, DEVICE, TYPE, EVENT, READING, VALUE, UNIT) VALUES (?,?,?,?,?,?,?) ON CONFLICT ($pkc)
- DO UPDATE SET TIMESTAMP=EXCLUDED.TIMESTAMP, DEVICE=EXCLUDED.DEVICE, TYPE=EXCLUDED.TYPE, EVENT=EXCLUDED.EVENT, READING=EXCLUDED.READING,
- VALUE=EXCLUDED.VALUE, UNIT=EXCLUDED.UNIT");
- } else {
- $sth_uc = $dbh->prepare("UPDATE current SET TIMESTAMP=?, TYPE=?, EVENT=?, VALUE=?, UNIT=? WHERE (DEVICE=?) AND (READING=?)");
- }
- }
-
- eval { $dbh->begin_work() if($dbh->{AutoCommit}); };
- if ($@) {
- Log3($name, 2, "DbRep $name -> Error start transaction for history - $@");
- }
-
- Log3 $hash->{NAME}, 4, "DbRep $name - data prepared to db write:";
-
- # SQL-Startzeit
- my $wst = [gettimeofday];
-
- my $ihs = 0;
- my $uhs = 0;
- foreach my $row (@row_array) {
- my @a = split("\\|",$row);
- $timestamp = $a[0];
- $device = $a[1];
- $type = $a[2];
- $event = $a[3];
- $reading = $a[4];
- $value = $a[5];
- $unit = $a[6];
- Log3 $hash->{NAME}, 4, "DbRep $name - $row";
-
- eval {
- # update oder insert history
- if (lc($DbLogType) =~ m(history) ) {
- my $rv_uh = $sth_uh->execute($type,$event,$value,$unit,$timestamp,$device,$reading);
- if ($rv_uh == 0) {
- $sth_ih->execute($timestamp,$device,$type,$event,$reading,$value,$unit);
- $ihs++;
- } else {
- $uhs++;
- }
- }
- # update oder insert current
- if (lc($DbLogType) =~ m(current) ) {
- my $rv_uc = $sth_uc->execute($timestamp,$type,$event,$value,$unit,$device,$reading);
- if ($rv_uc == 0) {
- $sth_ic->execute($timestamp,$device,$type,$event,$reading,$value,$unit);
- }
- }
- };
-
- if ($@) {
- $err = $@;
- Log3 ($name, 2, "DbRep $name - $@");
- $dbh->rollback;
- $dbh->disconnect;
- $ihs = 0;
- $uhs = 0;
- return ($wrt,0,$err);
- } else {
- $irowdone++;
- }
- }
-
- eval {$dbh->commit() if(!$dbh->{AutoCommit});};
- $dbh->disconnect;
-
- Log3 $hash->{NAME}, 3, "DbRep $name - number of lines updated in \"$dblogname\": $uhs";
- Log3 $hash->{NAME}, 3, "DbRep $name - number of lines inserted into \"$dblogname\": $ihs";
-
- # SQL-Laufzeit ermitteln
- $wrt = tv_interval($wst);
- }
-
-return ($wrt,$irowdone,$err);
-}
-
-####################################################################################################
-# Werte eines Array in DB schreiben
-# Übergabe-Array: $date_ESC_$time_ESC_$device_ESC_$type_ESC_$event_ESC_$reading_ESC_$value_ESC_$unit
-# $histupd = 1 wenn history update, $histupd = 0 nur history insert
-#
-####################################################################################################
-sub DbRep_WriteToDB($$$@) {
- my ($name,$dbh,$dbloghash,$histupd,@row_array) = @_;
- my $hash = $defs{$name};
- my $dblogname = $dbloghash->{NAME};
- my $DbLogType = AttrVal($dbloghash->{NAME}, "DbLogType", "History");
- my $supk = AttrVal($dbloghash->{NAME}, "noSupportPK", 0);
- my $wrt = 0;
- my $irowdone = 0;
- my ($sth_ih,$sth_uh,$sth_ic,$sth_uc,$err);
-
- # check ob PK verwendet wird, @usepkx?Anzahl der Felder im PK:0 wenn kein PK, $pkx?Namen der Felder:none wenn kein PK
- my ($usepkh,$usepkc,$pkh,$pkc);
- if (!$supk) {
- ($usepkh,$usepkc,$pkh,$pkc) = DbRep_checkUsePK($hash,$dbloghash,$dbh);
- } else {
- Log3 $hash->{NAME}, 5, "DbRep $name -> Primary Key usage suppressed by attribute noSupportPK in DbLog \"$dblogname\"";
- }
-
- if (lc($DbLogType) =~ m(history)) {
- # insert history mit/ohne primary key
- if ($usepkh && $dbloghash->{MODEL} eq 'MYSQL') {
- eval { $sth_ih = $dbh->prepare_cached("INSERT IGNORE INTO history (TIMESTAMP, DEVICE, TYPE, EVENT, READING, VALUE, UNIT) VALUES (?,?,?,?,?,?,?)"); };
- } elsif ($usepkh && $dbloghash->{MODEL} eq 'SQLITE') {
- eval { $sth_ih = $dbh->prepare_cached("INSERT OR IGNORE INTO history (TIMESTAMP, DEVICE, TYPE, EVENT, READING, VALUE, UNIT) VALUES (?,?,?,?,?,?,?)"); };
- } elsif ($usepkh && $dbloghash->{MODEL} eq 'POSTGRESQL') {
- eval { $sth_ih = $dbh->prepare_cached("INSERT INTO history (TIMESTAMP, DEVICE, TYPE, EVENT, READING, VALUE, UNIT) VALUES (?,?,?,?,?,?,?) ON CONFLICT DO NOTHING"); };
- } else {
- eval { $sth_ih = $dbh->prepare_cached("INSERT INTO history (TIMESTAMP, DEVICE, TYPE, EVENT, READING, VALUE, UNIT) VALUES (?,?,?,?,?,?,?)"); };
- }
- if ($@) {
- $err = $@;
- Log3 ($name, 2, "DbRep $name - $@");
- return ($wrt,$irowdone,$err);
- }
- # update history mit/ohne primary key
- if ($usepkh && $dbloghash->{MODEL} eq 'MYSQL') {
- $sth_uh = $dbh->prepare("REPLACE INTO history (TYPE, EVENT, VALUE, UNIT, TIMESTAMP, DEVICE, READING) VALUES (?,?,?,?,?,?,?)");
- } elsif ($usepkh && $dbloghash->{MODEL} eq 'SQLITE') {
- $sth_uh = $dbh->prepare("INSERT OR REPLACE INTO history (TYPE, EVENT, VALUE, UNIT, TIMESTAMP, DEVICE, READING) VALUES (?,?,?,?,?,?,?)");
- } elsif ($usepkh && $dbloghash->{MODEL} eq 'POSTGRESQL') {
- $sth_uh = $dbh->prepare("INSERT INTO history (TYPE, EVENT, VALUE, UNIT, TIMESTAMP, DEVICE, READING) VALUES (?,?,?,?,?,?,?) ON CONFLICT ($pkc)
- DO UPDATE SET TIMESTAMP=EXCLUDED.TIMESTAMP, DEVICE=EXCLUDED.DEVICE, TYPE=EXCLUDED.TYPE, EVENT=EXCLUDED.EVENT, READING=EXCLUDED.READING,
- VALUE=EXCLUDED.VALUE, UNIT=EXCLUDED.UNIT");
- } else {
- $sth_uh = $dbh->prepare("UPDATE history SET TYPE=?, EVENT=?, VALUE=?, UNIT=? WHERE (TIMESTAMP=?) AND (DEVICE=?) AND (READING=?)");
- }
- }
-
- if (lc($DbLogType) =~ m(current) ) {
- # insert current mit/ohne primary key
- if ($usepkc && $dbloghash->{MODEL} eq 'MYSQL') {
- eval { $sth_ic = $dbh->prepare("INSERT IGNORE INTO current (TIMESTAMP, DEVICE, TYPE, EVENT, READING, VALUE, UNIT) VALUES (?,?,?,?,?,?,?)"); };
- } elsif ($usepkc && $dbloghash->{MODEL} eq 'SQLITE') {
- eval { $sth_ic = $dbh->prepare("INSERT OR IGNORE INTO current (TIMESTAMP, DEVICE, TYPE, EVENT, READING, VALUE, UNIT) VALUES (?,?,?,?,?,?,?)"); };
- } elsif ($usepkc && $dbloghash->{MODEL} eq 'POSTGRESQL') {
- eval { $sth_ic = $dbh->prepare("INSERT INTO current (TIMESTAMP, DEVICE, TYPE, EVENT, READING, VALUE, UNIT) VALUES (?,?,?,?,?,?,?) ON CONFLICT DO NOTHING"); };
- } else {
- # old behavior
- eval { $sth_ic = $dbh->prepare("INSERT INTO current (TIMESTAMP, DEVICE, TYPE, EVENT, READING, VALUE, UNIT) VALUES (?,?,?,?,?,?,?)"); };
- }
- if ($@) {
- $err = $@;
- Log3 ($name, 2, "DbRep $name - $@");
- return ($wrt,$irowdone,$err);
- }
- # update current mit/ohne primary key
- if ($usepkc && $dbloghash->{MODEL} eq 'MYSQL') {
- $sth_uc = $dbh->prepare("REPLACE INTO current (TIMESTAMP, DEVICE, TYPE, EVENT, READING, VALUE, UNIT) VALUES (?,?,?,?,?,?,?)");
- } elsif ($usepkc && $dbloghash->{MODEL} eq 'SQLITE') {
- $sth_uc = $dbh->prepare("INSERT OR REPLACE INTO current (TIMESTAMP, DEVICE, TYPE, EVENT, READING, VALUE, UNIT) VALUES (?,?,?,?,?,?,?)");
- } elsif ($usepkc && $dbloghash->{MODEL} eq 'POSTGRESQL') {
- $sth_uc = $dbh->prepare("INSERT INTO current (TIMESTAMP, DEVICE, TYPE, EVENT, READING, VALUE, UNIT) VALUES (?,?,?,?,?,?,?) ON CONFLICT ($pkc)
- DO UPDATE SET TIMESTAMP=EXCLUDED.TIMESTAMP, DEVICE=EXCLUDED.DEVICE, TYPE=EXCLUDED.TYPE, EVENT=EXCLUDED.EVENT, READING=EXCLUDED.READING,
- VALUE=EXCLUDED.VALUE, UNIT=EXCLUDED.UNIT");
- } else {
- $sth_uc = $dbh->prepare("UPDATE current SET TIMESTAMP=?, TYPE=?, EVENT=?, VALUE=?, UNIT=? WHERE (DEVICE=?) AND (READING=?)");
- }
- }
-
- eval { $dbh->begin_work() if($dbh->{AutoCommit}); };
- if ($@) {
- Log3($name, 2, "DbRep $name -> Error start transaction for history - $@");
- }
-
- Log3 $hash->{NAME}, 5, "DbRep $name - data prepared to db write:";
-
- # SQL-Startzeit
- my $wst = [gettimeofday];
-
- my $ihs = 0;
- my $uhs = 0;
- foreach my $row (@row_array) {
- my ($date,$time,$device,$type,$event,$reading,$value,$unit) = ($row =~ /^(.*)_ESC_(.*)_ESC_(.*)_ESC_(.*)_ESC_(.*)_ESC_(.*)_ESC_(.*)_ESC_(.*)$/);
- Log3 $hash->{NAME}, 5, "DbRep $name - $row";
- my $timestamp = $date." ".$time;
-
- eval {
- # update oder insert history
- if (lc($DbLogType) =~ m(history) ) {
- my $rv_uh = 0;
- if($histupd) {
- $rv_uh = $sth_uh->execute($type,$event,$value,$unit,$timestamp,$device,$reading);
- }
- if ($rv_uh == 0) {
- $sth_ih->execute($timestamp,$device,$type,$event,$reading,$value,$unit);
- $ihs++;
- } else {
- $uhs++;
- }
- }
- # update oder insert current
- if (lc($DbLogType) =~ m(current) ) {
- my $rv_uc = $sth_uc->execute($timestamp,$type,$event,$value,$unit,$device,$reading);
- if ($rv_uc == 0) {
- $sth_ic->execute($timestamp,$device,$type,$event,$reading,$value,$unit);
- }
- }
- };
-
- if ($@) {
- $err = $@;
- Log3 ($name, 2, "DbRep $name - $@");
- $dbh->rollback;
- $ihs = 0;
- $uhs = 0;
- return ($wrt,0,$err);
- } else {
- $irowdone++;
- }
- }
-
- eval {$dbh->commit() if(!$dbh->{AutoCommit});};
-
- Log3 $hash->{NAME}, 3, "DbRep $name - number of lines updated in \"$dblogname\": $uhs" if($uhs);
- Log3 $hash->{NAME}, 3, "DbRep $name - number of lines inserted into \"$dblogname\": $ihs" if($ihs);
-
- # SQL-Laufzeit ermitteln
- $wrt = tv_interval($wst);
-
-return ($wrt,$irowdone,$err);
-}
-
-################################################################
-# check ob primary key genutzt wird
-################################################################
-sub DbRep_checkUsePK ($$$){
- my ($hash,$dbloghash,$dbh) = @_;
- my $name = $hash->{NAME};
- my $dbconn = $dbloghash->{dbconn};
- my $upkh = 0;
- my $upkc = 0;
- my (@pkh,@pkc);
-
- my $db = (split("=",(split(";",$dbconn))[0]))[1];
- eval {@pkh = $dbh->primary_key( undef, undef, 'history' );};
- eval {@pkc = $dbh->primary_key( undef, undef, 'current' );};
- my $pkh = (!@pkh || @pkh eq "")?"none":join(",",@pkh);
- my $pkc = (!@pkc || @pkc eq "")?"none":join(",",@pkc);
- $pkh =~ tr/"//d;
- $pkc =~ tr/"//d;
- $upkh = 1 if(@pkh && @pkh ne "none");
- $upkc = 1 if(@pkc && @pkc ne "none");
- Log3 $hash->{NAME}, 5, "DbRep $name -> Primary Key used in $db.history: $pkh";
- Log3 $hash->{NAME}, 5, "DbRep $name -> Primary Key used in $db.current: $pkc";
-
-return ($upkh,$upkc,$pkh,$pkc);
-}
-
-################################################################
-# extrahiert aus dem übergebenen Wert nur die Zahl
-################################################################
-sub DbRep_numval ($){
- my ($val) = @_;
- return undef if(!defined($val));
- $val = ($val =~ /(-?\d+(\.\d+)?)/ ? $1 : "");
-
-return $val;
-}
-
-####################################################################################################
-# blockierende DB-Abfrage
-# liefert Ergebnis sofort zurück, setzt keine Readings
-####################################################################################################
-sub DbRep_dbValue($$) {
- my ($name,$cmd) = @_;
- my $hash = $defs{$name};
- my $dbloghash = $hash->{dbloghash};
- my $dbconn = $dbloghash->{dbconn};
- my $dbuser = $dbloghash->{dbuser};
- my $dblogname = $dbloghash->{NAME};
- my $dbpassword = $attr{"sec$dblogname"}{secret};
- my $utf8 = defined($hash->{UTF8})?$hash->{UTF8}:0;
- my $srs = AttrVal($name, "sqlResultFieldSep", "|");
- my ($err,$ret,$dbh);
-
- readingsDelete($hash, "errortext");
- ReadingsSingleUpdateValue ($hash, "state", "running", 1);
-
- eval {$dbh = DBI->connect("dbi:$dbconn", $dbuser, $dbpassword, { PrintError => 0, RaiseError => 1, AutoCommit => 1, AutoInactiveDestroy => 1, mysql_enable_utf8 => $utf8 });};
-
- if ($@) {
- $err = $@;
- Log3 ($name, 2, "DbRep $name - $err");
- ReadingsSingleUpdateValue ($hash, "errortext", $err, 1);
- ReadingsSingleUpdateValue ($hash, "state", "error", 1);
- return ($err);
- }
-
- my $sql = ($cmd =~ m/\;$/)?$cmd:$cmd.";";
-
- # Ausgaben
- Log3 ($name, 4, "DbRep $name - -------- New selection --------- ");
- Log3 ($name, 4, "DbRep $name - Command: dbValue");
- Log3 ($name, 4, "DbRep $name - SQL execute: $sql");
-
- # SQL-Startzeit
- my $st = [gettimeofday];
-
- my ($sth,$r);
- eval {$sth = $dbh->prepare($sql);
- $r = $sth->execute();
- };
-
- if ($@) {
- $err = $@;
- Log3 ($name, 2, "DbRep $name - $err");
- $dbh->disconnect;
- ReadingsSingleUpdateValue ($hash, "errortext", $err, 1);
- ReadingsSingleUpdateValue ($hash, "state", "error", 1);
- return ($err);
- }
-
- my $nrows = 0;
- if($sql =~ m/^\s*(select|pragma|show)/is) {
- while (my @line = $sth->fetchrow_array()) {
- Log3 ($name, 4, "DbRep $name - SQL result: @line");
- $ret .= join("$srs", @line);
- $ret .= "\n";
- # Anzahl der Datensätze
- $nrows++;
- }
-
- } else {
- $nrows = $sth->rows;
- eval {$dbh->commit() if(!$dbh->{AutoCommit});};
- if ($@) {
- $err = $@;
- Log3 ($name, 2, "DbRep $name - $err");
- $dbh->disconnect;
- ReadingsSingleUpdateValue ($hash, "errortext", $err, 1);
- ReadingsSingleUpdateValue ($hash, "state", "error", 1);
- return ($err);
- }
- $ret = $nrows;
- }
-
- $sth->finish;
- $dbh->disconnect;
-
- # SQL-Laufzeit ermitteln
- my $rt = tv_interval($st);
-
- my $com = (split(" ",$sql, 2))[0];
- Log3 ($name, 4, "DbRep $name - Number of entries processed in db $hash->{DATABASE}: $nrows by $com");
-
- # Readingaufbereitung
- readingsBeginUpdate($hash);
- ReadingsBulkUpdateTimeState($hash,undef,$rt,"done");
- readingsEndUpdate($hash, 1);
-
-return ($ret);
-}
-
-####################################################################################################
-# blockierende DB-Abfrage
-# liefert den Wert eines Device:Readings des nächsmöglichen Logeintrags zum
-# angegebenen Zeitpunkt
-#
-# Aufruf: DbReadingsVal("","",","")
-####################################################################################################
-sub DbReadingsVal($$$$) {
- my ($name, $devread, $ts, $default) = @_;
- my $hash = $defs{$name};
- my $dbmodel = $defs{$hash->{HELPER}{DBLOGDEVICE}}{MODEL};
- my ($err,$ret,$sql);
-
- unless(defined($defs{$name})) {
- return ("DbRep-device \"$name\" doesn't exist.");
- }
- unless($defs{$name}{TYPE} eq "DbRep") {
- return ("\"$name\" is not a DbRep-device but of type \"".$defs{$name}{TYPE}."\"");
- }
- unless($ts =~ /^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})$/) {
- return ("timestamp has not a valid format. Use \"YYYY-MM-DD hh:mm:ss\" as timestamp.");
- }
- my ($dev,$reading) = split(":",$devread);
- unless($dev && $reading) {
- return ("device:reading must be specified !");
- }
-
- if($dbmodel eq "MYSQL") {
- $sql = "select value from (
- ( select *, TIMESTAMPDIFF(SECOND, '$ts', timestamp) as diff from history
- where device='$dev' and reading='$reading' and timestamp >= '$ts' order by timestamp asc limit 1
- )
- union
- ( select *, TIMESTAMPDIFF(SECOND, timestamp, '$ts') as diff from history
- where device='$dev' and reading='$reading' and timestamp < '$ts' order by timestamp desc limit 1
- )
- ) x order by diff limit 1;";
-
- } elsif ($dbmodel eq "SQLITE") {
- $sql = "select value from (
- select value, (julianday(timestamp) - julianday('$ts')) * 86400.0 as diff from history
- where device='MyWetter' and reading='temperature' and timestamp >= '$ts'
- union
- select value, (julianday('$ts') - julianday(timestamp)) * 86400.0 as diff from history
- where device='MyWetter' and reading='temperature' and timestamp < '$ts'
- )
- x order by diff limit 1;";
-
- } elsif ($dbmodel eq "POSTGRESQL") {
- $sql = "select value from (
- select value, EXTRACT(EPOCH FROM (timestamp - '$ts')) as diff from history
- where device='MyWetter' and reading='temperature' and timestamp >= '$ts'
- union
- select value, EXTRACT(EPOCH FROM ('$ts' - timestamp)) as diff from history
- where device='MyWetter' and reading='temperature' and timestamp < '$ts'
- )
- x order by diff limit 1;";
- } else {
- return ("DbReadingsVal is not implemented for $dbmodel");
- }
-
- $hash->{LASTCMD} = "dbValue $sql";
- $ret = DbRep_dbValue($name,$sql);
- $ret = $ret?$ret:$default;
-
-return $ret;
-}
-
-####################################################################################################
-# Browser Refresh nach DB-Abfrage
-####################################################################################################
-sub browser_refresh($) {
- my ($hash) = @_;
- RemoveInternalTimer($hash, "browser_refresh");
- {FW_directNotify("#FHEMWEB:WEB", "location.reload('true')", "")};
- # map { FW_directNotify("#FHEMWEB:$_", "location.reload(true)", "") } devspec2array("WEB.*");
-return;
-}
-
-####################################################################################################
-# Test-Sub zu Testzwecken
-####################################################################################################
-sub testexit ($) {
-my ($hash) = @_;
-my $name = $hash->{NAME};
-
- if ( !DbRep_Connect($hash) ) {
- Log3 ($name, 2, "DbRep $name - DB connect failed. Database down ? ");
- ReadingsSingleUpdateValue ($hash, "state", "disconnected", 1);
- return;
- } else {
- my $dbh = $hash->{DBH};
- Log3 ($name, 3, "DbRep $name - --------------- FILE INFO --------------");
- my $sqlfile = $dbh->sqlite_db_filename();
- Log3 ($name, 3, "DbRep $name - FILE : $sqlfile ");
-# # $dbh->table_info( $catalog, $schema, $table)
-# my $sth = $dbh->table_info('', '%', '%');
-# my $tables = $dbh->selectcol_arrayref($sth, {Columns => [3]});
-# my $table = join ', ', @$tables;
-# Log3 ($name, 3, "DbRep $name - SQL_TABLES : $table");
-
- Log3 ($name, 3, "DbRep $name - --------------- PRAGMA --------------");
- my @InfoTypes = ('sqlite_db_status');
-
-
- foreach my $row (@InfoTypes) {
- # my @linehash = $dbh->$row;
-
- my $array= $dbh->$row ;
- # push(@row_array, @array);
- while ((my $key, my $val) = each %{$array}) {
- Log3 ($name, 3, "DbRep $name - PRAGMA : $key : ".%{$val});
- }
-
- }
- # $sth->finish;
-
- $dbh->disconnect;
- }
-return;
-}
-
-
-1;
-
-=pod
-=item helper
-=item summary Reporting & Management content of DbLog-DB's. Content is depicted as readings
-=item summary_DE Reporting & Management von DbLog-DB Content. Darstellung als Readings
-=begin html
-
-DbRep
-
- attributes ).
- Selection of all datasets within adjustable time limits.
- Exposure of datasets of a Device/Reading-combination within adjustable time limits.
- Selection of datasets by usage of dynamically calclated time limits at execution time.
- Highlighting doublets when select and display datasets (fetchrows)
- Calculation of quantity of datasets of a Device/Reading-combination within adjustable time limits and several aggregations.
- The calculation of summary-, difference-, maximum-, minimum- and averageValues of numeric readings within adjustable time limits and several aggregations.
- write back results of summary-, difference-, maximum-, minimum- and average calculation into the database
- The deletion of datasets. The containment of deletion can be done by Device and/or Reading as well as fix or dynamically calculated time limits at execution time.
- export of datasets to file (CSV-format).
- import of datasets from file (CSV-Format).
- rename of device/readings in datasets
- change of reading values in the database (changeValue)
- automatic rename of device names in datasets and other DbRep-definitions after FHEM "rename" command (see DbRep-Agent )
- Execution of arbitrary user specific SQL-commands (non-blocking)
- Execution of arbitrary user specific SQL-commands (blocking) for usage in user own code (dbValue)
- creation of backups of the database in running state non-blocking (MySQL, SQLite)
- transfer dumpfiles to a FTP server after backup incl. version control
- restore of SQLite- and MySQL-Dumps non-blocking
- optimize the connected database (optimizeTables, vacuum)
- report of existing database processes (MySQL)
- purge content of current-table
- fill up the current-table with a (tunable) extract of the history-table
- delete consecutive datasets with different timestamp but same values (clearing up consecutive doublets)
- Repair of a corrupted SQLite database ("database disk image is malformed")
- transmission of datasets from source database into another (Standby) database (syncStandby)
- reduce the amount of datasets in database (reduceLog)
- Autorename the attribute "role" has to be assigned to a defined DbRep-device. The standard role after DbRep definition is "Client".
- Please read more in section DbRep-Agent about autorename function. UserExit function. With this interface the user can execute own program code dependent from free
- definable Reading/Value-combinations (Regex). The interface works without respectively independent from event
- generation.
- Further informations you can find as described at attribute "userExitFn".
- DbReadingsVal is provided.
- With this function you can, similar to the well known ReadingsVal, get a reading value from database.
- The function execution is carried out blocking.
- The command syntax is:
- DbReadingsVal("<name>","<device:reading>","<timestamp>","<default>") Examples:
-
- <name> : name of the DbRep-Device to request <device:reading> : device:reading whose value is to deliver <timestamp> : timestamp of reading whose value is to deliver (*) in the form "YYYY-MM-DD hh:mm:ss" <default> : default value if no reading value can be retrieved
-
- Modul 93_DbRep - Reporting and Management of database content (DbLog) .
- Preparations
- The module requires the usage of a DbLog instance and the credentials of the database definition will be used.
- CREATE INDEX Report_Idx ON `history` (TIMESTAMP, READING) USING BTREE;
-
-
-Definition
-
-
-
- define <name> DbRep <name of DbLog-instance>
-
-
-
-
-Set
-
-
- Currently following set-commands are included. They are used to trigger the evaluations and define the evaluation option option itself.
- The criteria of searching database content and determine aggregation is carried out by setting several attributes .
-
- averageValue [display | writeToDB]
- - calculates the average value of database column "VALUE" between period given by
- timestamp-attributes which are set.
- The reading to evaluate must be specified by attribute "reading".
- Example of building a new reading name from the original reading "totalpac":
- cancelDump - stops a running database dump. changeValue - changes the saved value of readings.
- If the selection is limited to particular device/reading-combinations by
- attribute "device" respectively "reading", it is considered as well
- as possibly defined time limits by time attributes (time.*).
- Syntax:
-<old string> : * a simple string with/without spaces, e.g. "OL 12"
- * a string with usage of SQL-wildcard, e.g. "%OL%"
-
-<new string> : * a simple string with/without spaces, e.g. "12 kWh"
- * Perl code embedded in "{}" with quotes, e.g. "{($VALUE,$UNIT) = split(" ",$VALUE)}".
- The perl expression the variables $VALUE and $UNIT are committed to. The variables are changable within
- the perl code. The returned value of VALUE and UNIT are saved into the database field
- VALUE respectively UNIT of the dataset.
-
-
- Examples:
-
-
- device : selection only of datasets which contain <device> reading : selection only of datasets which contain <reading> time.* : a number of attributes to limit selection by time executeBeforeProc : execute a FHEM command (or perl-routine) before start of changeValue executeAfterProc : execute a FHEM command (or perl-routine) after changeValue is finished
-
- Note:
-
- countEntries [history|current] - provides the number of table entries (default: history) between time period set
- by time.* -attributes if set.
- If time.* attributes not set, all entries of the table will be count.
- The attributes "device" and "reading" can be used to
- limit the evaluation.
-
-
- aggregation : aggregatiion/grouping of time intervals countEntriesDetail : detailed report the count of datasets (per reading) device : selection only of datasets which contain <device> reading : selection only of datasets which contain <reading> time.* : a number of attributes to limit selection by time
-
- delEntries - deletes all database entries or only the database entries specified by attributes Device and/or
- Reading and the entered time period between "timestamp_begin", "timestamp_end" (if set) or "timeDiffToNow/timeOlderThan".
- "timestamp_begin" is set -> deletes db entries from this timestamp until current date/time -> deletes db entries until this timestamp -> deletes db entries between these timestamps -> delete entries older than current time minus "timeOlderThan" -> delete db entries from current time minus "timeDiffToNow" until now attribute "allowDeletion" needs to be set to unlock the
- delete-function.
-
-
- allowDeletion : unlock the delete function device : selection only of datasets which contain <device> reading : selection only of datasets which contain <reading> time.* : a number of attributes to limit selection by time executeBeforeProc : execute a FHEM command (or perl-routine) before start of delEntries executeAfterProc : execute a FHEM command (or perl-routine) after delEntries is finished
-
- delSeqDoublets [adviceRemain | adviceDelete | delete] - show respectively delete identical sequentially datasets.
- Therefore Device,Reading and Value of the sequentially datasets are compared.
- Not deleted are the first und the last dataset of a aggregation period (e.g. hour,day,week and so on) as
- well as the datasets before or after a value change (database field VALUE). attributes to define the scope of aggregation,time period, device and reading are
- considered. If attribute aggregation is not set or set to "no", it will change to the default aggregation
- period "day". For datasets containing numerical values it is possible to determine a variance with attribute
- "seqDoubletsVariance". Up to this value consecutive numerical datasets are handled as identical and should be
- deleted.
-
-
-
- adviceRemain : simulates the remaining datasets in database after delete-operation (nothing will be deleted !) adviceDelete : simulates the datasets to delete in database (nothing will be deleted !) delete : deletes the consecutive doublets (see example)
-
- attribute "allowDeletion" needs to be set for
- execute the "delete" option. attribute "limit".
- The adjustment of "limit" has no impact to the "delSeqDoublets delete" function, but affects ONLY the
- display of the data. attributes "executeBeforeProc" and "executeAfterProc").
-
- Example - the remaining datasets after executing delete-option are are marked as bold :
- 2017-11-25_00-00-05__eg.az.fridge_Pwr__power 0 2017-11-25_01-08-21__eg.az.fridge_Pwr__power 0 2017-11-25_01-08-59__eg.az.fridge_Pwr__power 60.32 2017-11-25_01-11-21__eg.az.fridge_Pwr__power 56.26 2017-11-25_01-27-54__eg.az.fridge_Pwr__power 6.19 2017-11-25_01-28-51__eg.az.fridge_Pwr__power 0 2017-11-25_02-39-29__eg.az.fridge_Pwr__power 0 2017-11-25_02-41-18__eg.az.fridge_Pwr__power 105.28 2017-11-25_02-41-26__eg.az.fridge_Pwr__power 61.52 2017-11-25_03-00-06__eg.az.fridge_Pwr__power 47.46 2017-11-25_03-00-33__eg.az.fridge_Pwr__power 0 2017-11-25_23-40-10__eg.az.fridge_Pwr__power 0 2017-11-25_23-42-24__eg.az.fridge_Pwr__power 1 2017-11-25_23-45-27__eg.az.fridge_Pwr__power 1 2017-11-25_23-47-07__eg.az.fridge_Pwr__power 0 2017-11-25_23-48-15__eg.az.fridge_Pwr__power 0 2017-11-25_23-50-21__eg.az.fridge_Pwr__power 59.1 2017-11-25_23-55-14__eg.az.fridge_Pwr__power 52.31 2017-11-25_23-58-09__eg.az.fridge_Pwr__power 51.73
-
-
- deviceRename - renames the device name of a device inside the connected database (Internal DATABASE).
- The devicename will allways be changed in the entire database. Possibly set time limits or restrictions by
- attributes device and/or reading will not be considered.
- Example: Note:
-
- diffValue [display | writeToDB]
- - calculates the difference of database column "VALUE" between period given by
- attributes "timestamp_begin", "timestamp_end" or "timeDiffToNow / timeOlderThan".
- The reading to evaluate must be defined using attribute "reading".
- This function is mostly reasonable if readingvalues are increasing permanently and don't write value-differences to the database.
- The difference will be generated from the first available dataset (VALUE-Field) to the last available dataset between the
- specified time linits/aggregation, in which a balanced difference value of the previous aggregation period will be transfered to the
- following aggregation period in case this period contains a value. attribute "diffAccept").
- Note:
-
- Is no or the option "display" specified, the results are only displayed. Using
- option "writeToDB" the calculation results are stored in the database with a new reading
- name.
- Example of building a new reading name from the original reading "totalpac":
- dumpMySQL [clientSide | serverSide]
- - creates a dump of the connected MySQL database.
- Option clientSide attribute "dumpDirLocal" and has to be
- writable by the FHEM process. Note: attributes "dumpMemlimit" and "dumpSpeed" the run-time behavior of the function can be
- controlled to optimize the performance and demand of ressources.
-
-
- dumpComment : User comment in head of dump file dumpCompress : compress of dump files after creation dumpDirLocal : the local destination directory for dump file creation dumpMemlimit : limits memory usage dumpSpeed : limits CPU utilization dumpFilesKeep : number of dump files to keep executeBeforeProc : execution of FHEM command (or perl-routine) before dump executeAfterProc : execution of FHEM command (or perl-routine) after dump optimizeTablesBeforeDump : table optimization before dump
-
- naming convention of dump files is: <dbname>_<date>_<time>.sql[.gzip]
- set <name> restoreMySQL <filename>
-
- can be used.
- mysql -u <user> -p <dbname> < <filename>.sql
-
- as well to restore the database from dump file. Option serverSide CSV-formatted without
- any restrictions. Note:
-
-
- dumpDirRemote : destination directory of dump file on remote server dumpCompress : compress of dump files after creation dumpDirLocal : the local mounted directory dumpDirRemote dumpFilesKeep : number of dump files to keep executeBeforeProc : execution of FHEM command (or perl-routine) before dump executeAfterProc : execution of FHEM command (or perl-routine) after dump optimizeTablesBeforeDump : table optimization before dump
-
- attribute "dumpDirRemote".
- It must be located on the MySQL-Host and has to be writable by the MySQL-server process. Note: attribute
- "dumpDirLocal".
- Example:
-
- If the internal version management is used, after a successfull finished dump old dumpfiles will
- be deleted and only the number of attribute "dumpFilesKeep" (default: 3) would remain in target
- directory "dumpDirLocal" (the mounted "dumpDirRemote").
- In that case FHEM needs write permissions to the directory "dumpDirLocal". naming convention of dump files is: <dbname>_<date>_<time>.csv[.gzip]
- set <name> <restoreMySQL> <filename>.csv[.gzip]
-
- FTP-Transfer after Dump attribute "ftpUse" or
- "ftpUseSSL" has to be set. The latter if encoding for FTP is to be used.
- The module also carries the version control of dump files in FTP-destination by attribute
- "ftpDumpFilesKeep". attributes are:
-
-
- ftpUse : FTP Transfer after dump will be switched on (without SSL encoding) ftpUser : User for FTP-server login, default: anonymous ftpUseSSL : FTP Transfer with SSL encoding after dump ftpDebug : debugging of FTP communication for diagnostics ftpDir : directory on FTP-server in which the file will be send into (default: "/") ftpDumpFilesKeep : leave the number of dump files in FTP-destination <ftpDir> (default: 3) ftpPassive : set if passive FTP is to be used ftpPort : FTP-Port, default: 21 ftpPwd : password of FTP-User, not set by default ftpServer : name or IP-address of FTP-server. absolutely essential ! ftpTimeout : timeout of FTP-connection in seconds (default: 30).
-
-
-
- dumpSQLite - creates a dump of the connected SQLite database. attribute "dumpDirLocal" and
- has to be writable by the FHEM process. Note:
-
-
- dumpCompress : compress of dump files after creation dumpDirLocal : the local mounted directory dumpDirRemote dumpFilesKeep : number of dump files to keep executeBeforeProc : execution of FHEM command (or perl-routine) before dump executeAfterProc : execution of FHEM command (or perl-routine) after dump optimizeTablesBeforeDump : table optimization before dump
-
- naming convention of dump files is: <dbname>_<date>_<time>.sqlitebkp[.gzip] eraseReadings - deletes all created readings in the device, except reading "state" and readings, which are
- contained in exception list defined by attribute "readingPreventFromDel".
- exportToFile [<file>]
- - exports DB-entries to a file in CSV-format of time period specified by time attributes. attributes device and/or
- reading.
- The filename can be defined by attribute "expimpfile".
-
-
- aggregation : determination of selection time slices device : select only datasets which are contain <device> reading : select only datasets which are contain <reading> executeBeforeProc : execution of FHEM command (or perl-routine) before export executeAfterProc : execution of FHEM command (or perl-routine) after export expimpfile : the name of exportfile time.* : a number of attributes to limit selection by time
-
-
- fetchrows [history|current]
- - provides all table entries (default: history)
- of time period set by time attributes respectively selection conditions
- by attributes "device" and "reading".
- An aggregation set will not be considered. attribute
- "fetchRoute". Note:
-
- attr <DbRep-Device> widgetOverride fetchMarkDuplicates:colorpicker
-
-
-
- Example:
-
-
-
- fetchRoute : direction of selection read in database limit : limits the number of datasets to select and display fetchMarkDuplicates : Highlighting of found doublets device : select only datasets which are contain <device> reading : select only datasets which are contain <reading> time.* : A number of attributes to limit selection by time valueFilter : Filter datasets which are to show by a regular expression. The regex is applied to the whole selected dataset.
-
- Note: attribute "limit".
- Of course ths attribute can be increased if your system capabilities allow a higher workload. insert - use it to insert data ito table "history" manually. Input values for Date, Time and Value are mandatory. The database fields for Type and Event will be filled in with "manual" automatically and the values of Device, Reading will be get from set attributes .
- input format: Date,Time,Value,[Unit] example: 2016-08-01,23:00:09,TestValue,TestUnit Note: importFromFile [<file>]
- - imports data in CSV format from file into database. attribute "expimpfile".
- dataset format: Example for a source dataset:
-
-
- executeBeforeProc : execution of FHEM command (or perl-routine) before import executeAfterProc : execution of FHEM command (or perl-routine) after import expimpfile : the name of exportfile
-
-
- maxValue [display | writeToDB]
- - calculates the maximum value of database column "VALUE" between period given by
- attributes "timestamp_begin", "timestamp_end" or "timeDiffToNow / timeOlderThan".
- The reading to evaluate must be defined using attribute "reading".
- The evaluation contains the timestamp of the last appearing of the identified maximum value
- within the given period.
- Example of building a new reading name from the original reading "totalpac":
- minValue [display | writeToDB]
- - calculates the minimum value of database column "VALUE" between period given by
- attributes "timestamp_begin", "timestamp_end" or "timeDiffToNow / timeOlderThan".
- The reading to evaluate must be defined using attribute "reading".
- The evaluation contains the timestamp of the first appearing of the identified minimum
- value within the given period.
- Example of building a new reading name from the original reading "totalpac":
- optimizeTables - optimize tables in the connected database (MySQL). attributes "executeBeforeProc", "executeAfterProc")
-
- Note: readingRename - renames the reading name of a device inside the connected database (see Internal DATABASE).
- The readingname will allways be changed in the entire database. Possibly set time limits or restrictions by
- attributes device and/or reading will not be considered.
- Example: Note: repairSQLite - repairs a corrupted SQLite database.
- Example: Note: restoreMySQL <File> - restore a database from serverSide- or clientSide-Dump. Usage of serverSide-Dumps attribute
- "dumpDirLocal" to the appropriate value. Usage of clientSide-Dumps attribute
- "dumpDirLocal" to make it usable by the DbRep device. max_allowed_packet ". You can change
- this variable in file my.cnf to adapt the speed. Please consider the need of sufficient ressources
- (especially RAM).
- restoreSQLite <File>.sqlitebkp[.gzip] - restores a backup of SQLite database. sqlCmd - executes an arbitrary user specific command. attribute
- "allowDeletion" has to be set for security reason. attribute "timestamp_begin" respectively "timestamp_end"
- is assumed in the statement, it is possible to use placeholder "§timestamp_begin§ " respectively
- "§timestamp_end§ " on suitable place.
- Examples of SQL-statements:
- set <name> sqlCmd select DEVICE, count(*) from history where TIMESTAMP >= "2017-01-06 00:00:00" group by DEVICE having count(*) > 800
- set <name> sqlCmd select DEVICE, count(*) from history where TIMESTAMP >= "2017-05-06 00:00:00" group by DEVICE
- set <name> sqlCmd select DEVICE, count(*) from history where TIMESTAMP >= §timestamp_begin§ group by DEVICE
- set <name> sqlCmd select * from history where DEVICE like "Te%t" order by `TIMESTAMP` desc
- set <name> sqlCmd select * from history where `TIMESTAMP` > "2017-05-09 18:03:00" order by `TIMESTAMP` desc
- set <name> sqlCmd select * from current order by `TIMESTAMP` desc
- set <name> sqlCmd select sum(VALUE) as 'Einspeisung am 04.05.2017', count(*) as 'Anzahl' FROM history where `READING` = "Einspeisung_WirkP_Zaehler_Diff" and TIMESTAMP between '2017-05-04' AND '2017-05-05'
- set <name> sqlCmd delete from current
- set <name> sqlCmd delete from history where TIMESTAMP < "2016-05-06 00:00:00"
- set <name> sqlCmd update history set TIMESTAMP=TIMESTAMP,VALUE='Val' WHERE VALUE='TestValue'
- set <name> sqlCmd select * from history where DEVICE = "Test"
- set <name> sqlCmd insert into history (TIMESTAMP, DEVICE, TYPE, EVENT, READING, VALUE, UNIT) VALUES ('2017-05-09 17:00:14','Test','manuell','manuell','Tes§e','TestValue','°C')
-
- Reading "SqlResult".
- The formatting of result can be choosen by attribute "sqlResultFormat", as well as the used
- field separator can be determined by attribute "sqlResultFieldSep".
-
-
- allowDeletion : activates capabilty to delete datasets sqlResultFormat : determines presentation style of command result sqlResultFieldSep : choice of a useful field separator for result sqlCmdHistoryLength : activates command history and length
-
- Note: sqlCmdHistory - If history is activated by attribute "sqlCmdHistoryLength", an already
- successfully executed sqlCmd-command can be repeated from a drop-down list. sqlSpecial - This function provides a drop-down list with a selection of prepared reportings. attribute "sqlResultFormat",
- a well as the used field separator by attribute "sqlResultFieldSep".
-
-
-
- sqlResultFormat : determines the formatting of the result sqlResultFieldSep : determines the used field separator in statement result
-
-
-
-
- 50mostFreqLogsLast2days : reports the 50 most occuring log entries of the last 2 days allDevCount : all devices occuring in database and their quantity allDevReadCount : all device/reading combinations occuring in database and their quantity
-
-
- sumValue [display | writeToDB]
- - calculates the summary of database column "VALUE" between period given by
- attributes "timestamp_begin", "timestamp_end" or
- "timeDiffToNow / timeOlderThan". The reading to evaluate must be defined using attribute
- "reading". Using this function is mostly reasonable if value-differences of readings
- are written to the database.
- Example of building a new reading name from the original reading "totalpac": syncStandby <DbLog-Device Standby>
- - datasets of the connected database (source) are transmitted into another database
- (Standby-database). attributes
- or respectively the attributes "device", "reading" are transmitted.
-
-
- aggregation : adjustment of time slices for data transmission (hour,day,week) device : transmit only datasets which are contain <device> reading : transmit only datasets which are contain <reading> time.* : A number of attributes to limit selection by time
-
- tableCurrentFillup - the current-table will be filled u with an extract of the history-table.
- The attributes for limiting time and device, reading are considered.
- Thereby the content of the extract can be affected. In the associated DbLog-device the attribute "DbLogType" should be set to
- "SampleFill/History". tableCurrentPurge - deletes the content of current-table. There are no limits, e.g. by attributes "timestamp_begin", "timestamp_end", device, reading
- and so on, considered. vacuum - optimize tables in the connected database (SQLite, PostgreSQL). attributes "executeBeforeProc", "executeAfterProc")
-
- Note: For all evaluation variants (except sqlCmd,deviceRename,readingRename) applies: Note: Get
-
-
- The get-commands of DbRep provide to retrieve some metadata of the used database instance.
- Those are for example adjusted server parameter, server variables, datadasestatus- and table informations. THe available get-functions depending of
- the used database type. So for SQLite curently only "get svrinfo" is usable. The functions nativ are delivering a lot of outpit values.
- They can be limited by function specific attributes . The filter has to be setup by a comma separated list.
- SQL-Wildcard (%) can be used to setup the list arguments.
- Note: minTimestamp - Identifies the oldest timestamp in the database (will be executed implicitely at FHEM start).
- The timestamp is used as begin of data selection if no time attribut is set to determine the
- start date.
- procinfo - reports the existing database processes in a summary table (only MySQL). there . svrinfo - common database server informations, e.g. DBMS-version, server address and port and so on. The quantity of elements to get depends
- on the database type. Using the attribute "showSvrInfo" the quantity of results can be limited to show only
- the desired values. Further detailed informations of items meaning are explained
- there .
- Example
-
- tableinfo - access detailed informations about tables in MySQL database which is connected by the DbRep-device.
- All available tables in the connected database will be selected by default.
- Using theattribute "showTableInfo" the results can be limited to tables you want to show.
- Further detailed informations of items meaning are explained there .
- Example versionNotes [hints | rel | <key>] -
- Shows realease informations and/or hints about the module. It contains only main release
- informations for module users. Attributes
-
-
- Using the module specific attributes you are able to define the scope of evaluation and the aggregation. Note for SQL-Wildcard Usage: except "insert", "importFromFile" and "deviceRename".
- aggregation - Aggregation of Device/Reading-selections. Possible is hour, day, week, month or "no".
- Delivers e.g. the count of database entries for a day (countEntries), Summation of
- difference values of a reading (sumValue) and so on. Using aggregation "no" (default) an
- aggregation don't happens but the output contaims all values of Device/Reading in the defined time period. allowDeletion - unlocks the delete-function averageCalcForm - specifies the calculation variant of average peak by "averageValue".
-
-
- avgArithmeticMean : the arithmetic average is calculated (default) avgDailyMeanGWS : calculates the daily medium temperature according the
- specifications of german weather service (pls. see "get <name> versionNotes 2"). avgTimeWeightMean : calculates a time weighted average mean value is calculated
-
- countEntriesDetail - If set, the function countEntries creates a detailed report of counted datasets of
- every reading. By default only the summary of counted datasets is reported.
- device - Selection of a particular device.
- Examples: attr <name> device TYPE=DbRep attr <name> device MySTP_5000 attr <name> device SMA.* attr <name> device SMA_Energymeter,MySTP_5000 attr <name> device %5000
- device specifications (devspec) .
- diffAccept - valid for function diffValue. diffAccept determines the threshold, up to that a calaculated
- difference between two straight sequently datasets should be commenly accepted
- (default = 20).
- Example report in logfile if threshold of diffAccept=10 overruns: disable - deactivates the module dumpComment - User-comment. It will be included in the header of the created dumpfile by
- command "dumpMySQL clientSide". dumpCompress - if set, the dump files are compressed after operation of "dumpMySQL" bzw. "dumpSQLite" dumpDirLocal - Target directory of database dumps by command "dumpMySQL clientSide"
- (default: "{global}{modpath}/log/" on the FHEM-Server). dumpDirRemote - Target directory of database dumps by command "dumpMySQL serverSide"
- (default: the Home-directory of MySQL-Server on the MySQL-Host). dumpMemlimit - tolerable memory consumption for the SQL-script during generation period (default: 100000 characters).
- Please adjust this parameter if you may notice memory bottlenecks and performance problems based
- on it on your specific hardware. dumpSpeed - Number of Lines which will be selected in source database with one select by dump-command
- "dumpMySQL ClientSide" (default: 10000).
- This parameter impacts the run-time and consumption of resources directly. dumpFilesKeep - The specified number of dumpfiles remain in the dump directory (default: 3).
- If there more (older) files has been found, these files will be deleted after a new database dump
- was created successfully.
- The global attrubute "archivesort" will be considered. executeAfterProc - you can specify a FHEM command or perl function which should be executed
- after command execution .
- Example:
-sub adump {
- my ($name) = @_;
- my $hash = $defs{$name};
- # own function, e.g.
- Log3($name, 3, "DbRep $name -> Dump finished");
-
- return;
-}
-
-
-
-
- executeBeforeProc - you can specify a FHEM command or perl function which should be executed
- before command execution .
- Example:
-sub bdump {
- my ($name) = @_;
- my $hash = $defs{$name};
- # own function, e.g.
- Log3($name, 3, "DbRep $name -> Dump starts now");
-
- return;
-}
-
-expimpfile - Path/filename for data export/import.
-
-
- %L : is replaced by the value of global logdir attribute %TSB : is replaced by the (calculated) value of the timestamp_begin attribute Common used POSIX-wildcards are: %d : day of month (01..31) %m : month (01..12) %Y : year (1970...) %w : day of week (0..6); 0 represents Sunday %j : day of year (001..366) %U : week number of year with Sunday as first day of week (00..53) %W : week number of year with Monday as first day of week (00..53)
-
-
- Examples: attr <name> expimpfile /sds1/backup/exptest_%TSB.csv attr <name> expimpfile /sds1/backup/exptest_%Y-%m-%d.csv
- Filelog . fetchMarkDuplicates
- - Highlighting of multiple occuring datasets in result of "fetchrows" command fetchRoute [descent | ascent] - specify the direction of data selection of the fetchrows-command.
- descent - the data are read descent (default). If
- amount of datasets specified by attribut "limit" is exceeded,
- the newest x datasets are shown. ascent - the data are read ascent . If
- amount of datasets specified by attribut "limit" is exceeded,
- the oldest x datasets are shown.
-
- ftpUse - FTP Transfer after dump will be switched on (without SSL encoding). The created
- database backup file will be transfered non-blocking to the FTP-Server (Attribut "ftpServer").
- ftpUseSSL - FTP Transfer with SSL encoding after dump. The created database backup file will be transfered
- non-blocking to the FTP-Server (Attribut "ftpServer"). ftpUser - User for FTP-server login, default: "anonymous". ftpDebug - debugging of FTP communication for diagnostics. ftpDir - directory on FTP-server in which the file will be send into (default: "/"). ftpDumpFilesKeep - leave the number of dump files in FTP-destination <ftpDir> (default: 3). Are there more
- (older) dump files present, these files are deleted after a new dump was transfered successfully. ftpPassive - set if passive FTP is to be used ftpPort - FTP-Port, default: 21 ftpPwd - password of FTP-User, is not set by default ftpServer - name or IP-address of FTP-server. absolutely essential ! ftpTimeout - timeout of FTP-connection in seconds (default: 30). limit - limits the number of selected datasets by the "fetchrows", or the shown datasets of "delSeqDoublets adviceDelete",
- "delSeqDoublets adviceRemain" commands (default: 1000).
- This limitation should prevent the browser session from overload and
- avoids FHEMWEB from blocking. Please change the attribut according your requirements or change the
- selection criteria (decrease evaluation period). optimizeTablesBeforeDump - if set to "1", the database tables will be optimized before executing the dump
- (default: 0).
- Thereby the backup run-time time will be extended.
- Note
- reading - Selection of a particular reading.
- More than one reading are specified as a comma separated list.
- Examples: attr <name> reading etotal attr <name> reading et% attr <name> reading etotal,etoday
- readingNameMap - the name of the analyzed reading can be overwritten for output role - the role of the DbRep-device. Standard role is "Client". DbRep-Agent .
-
- readingPreventFromDel - comma separated list of readings which are should prevent from deletion when a
- new operation starts seqDoubletsVariance - accepted variance (+/-) for the command "set <name> delSeqDoublets".
- Examples: attr <name> seqDoubletsVariance 0.0014 attr <name> seqDoubletsVariance 1.45
- showproctime - if set, the reading "sql_processing_time" shows the required execution time (in seconds)
- for the sql-requests. This is not calculated for a single sql-statement, but the summary
- of all sql-statements necessara for within an executed DbRep-function in background. showStatus - limits the sample space of command "get <name> dbstatus". SQL-Wildcard (%) can be used.
- Example: showVariables - limits the sample space of command "get <name> dbvars". SQL-Wildcard (%) can be used.
- Example: showSvrInfo - limits the sample space of command "get <name> svrinfo". SQL-Wildcard (%) can be used.
- Example: showTableInfo - limits the tablename which is selected by command "get <name> tableinfo". SQL-Wildcard
- (%) can be used.
- Example: sqlCmdHistoryLength
- - activates the command history of "sqlCmd" and determines the length of it sqlResultFieldSep - determines the used field separator (default: "|") in the result of some sql-commands. sqlResultFormat - determines the formatting of the "set <name> sqlCmd" command result.
- Possible options are:
- separated - every line of the result will be generated sequentially in a single
- reading. (default) mline - the result will be generated as multiline in
- Reading SqlResult.
- sline - the result will be generated as singleline in
- Reading SqlResult.
- Datasets are separated by "]|[". table - the result will be generated as an table in
- Reading SqlResult. json - creates the Reading SqlResult as a JSON
- coded hash.
- Every hash-element consists of the serial number of the dataset (key)
- and its value.
- sub resfromjson {
- my ($name,$reading,$value) = @_;
- my $hash = $defs{$name};
-
- if ($reading eq "SqlResult") {
- # only reading SqlResult contains JSON encoded data
- my $data = decode_json($value);
-
- foreach my $k (keys(%$data)) {
-
- # use your own processing from here for every hash-element
- # e.g. output of every element that contains "Cam"
- my $ke = $data->{$k};
- if($ke =~ m/Cam/i) {
- my ($res1,$res2) = split("\\|", $ke);
- Log3($name, 1, "$name - extract element $k by userExitFn: ".$res1." ".$res2);
- }
- }
- }
- return;
- }
-
-
- timeYearPeriod - By this attribute an annual time period will be determined for database data selection.
- The time limits are calculated dynamically during execution time. Every time an annual period is determined.
- Periods of less than a year are not possible to set.
- Example:
- timestamp_begin - begin of data selection
- current_year_begin : matches "<current year>-01-01 00:00:00" current_year_end : matches "<current year>-12-31 23:59:59" previous_year_begin : matches "<previous year>-01-01 00:00:00" previous_year_end : matches "<previous year>-12-31 23:59:59" current_month_begin : matches "<current month first day> 00:00:00" current_month_end : matches "<current month last day> 23:59:59" previous_month_begin : matches "<previous month first day> 00:00:00" previous_month_end : matches "<previous month last day> 23:59:59" current_week_begin : matches "<first day of current week> 00:00:00" current_week_end : matches "<last day of current week> 23:59:59" previous_week_begin : matches "<first day of previous week> 00:00:00" previous_week_end : matches "<last day of previous week> 23:59:59" current_day_begin : matches "<current day> 00:00:00" current_day_end : matches "<current day> 23:59:59" previous_day_begin : matches "<previous day> 00:00:00" previous_day_end : matches "<previous day> 23:59:59" current_hour_begin : matches "<current hour>:00:00" current_hour_end : matches "<current hour>:59:59" previous_hour_begin : matches "<previous hour>:00:00" previous_hour_end : matches "<previous hour>:59:59"
- timestamp_end - end of data selection. If not set the current date/time combination will be used.
- current_year_begin : matches "<current year>-01-01 00:00:00" current_year_end : matches "<current year>-12-31 23:59:59" previous_year_begin : matches "<previous year>-01-01 00:00:00" previous_year_end : matches "<previous year>-12-31 23:59:59" current_month_begin : matches "<current month first day> 00:00:00" current_month_end : matches "<current month last day> 23:59:59" previous_month_begin : matches "<previous month first day> 00:00:00" previous_month_end : matches "<previous month last day> 23:59:59" current_week_begin : matches "<first day of current week> 00:00:00" current_week_end : matches "<last day of current week> 23:59:59" previous_week_begin : matches "<first day of previous week> 00:00:00" previous_week_end : matches "<last day of previous week> 23:59:59" current_day_begin : matches "<current day> 00:00:00" current_day_end : matches "<current day> 23:59:59" previous_day_begin : matches "<previous day> 00:00:00" previous_day_end : matches "<previous day> 23:59:59" current_hour_begin : matches "<current hour>:00:00" current_hour_end : matches "<current hour>:59:59" previous_hour_begin : matches "<previous hour>:00:00" previous_hour_end : matches "<previous hour>:59:59"
- Example:
- Note timeDiffToNow - the begin time of data selection will be set to the timestamp "<current time> -
- <timeDiffToNow>" dynamically (e.g. if set to 86400, the last 24 hours are considered by data
- selection). The time period will be calculated dynamically at execution time.
- Examples for input format: attr <name> timeDiffToNow 86400 attr <name> timeDiffToNow d:2 h:3 m:2 s:10 attr <name> timeDiffToNow m:600 attr <name> timeDiffToNow h:2.5 attr <name> timeDiffToNow y:1 h:2.5 attr <name> timeDiffToNow y:1.5
- timeOlderThan - the end time of data selection will be set to the timestamp "<aktuelle Zeit> -
- <timeOlderThan>" dynamically. Always the datasets up to timestamp
- "<current time> - <timeOlderThan>" will be considered (e.g. if set to
- 86400, all datasets older than one day are considered). The time period will be calculated dynamically at
- execution time.
- Examples for input format: attr <name> timeOlderThan 86400 attr <name> timeOlderThan d:2 h:3 m:2 s:10 attr <name> timeOlderThan m:600 attr <name> timeOlderThan h:2.5 attr <name> timeOlderThan y:1 h:2.5 attr <name> timeOlderThan y:1.5
- timeout - set the timeout-value for Blocking-Call Routines in background in seconds (default 86400) userExitFn - provides an interface to execute user specific program code.
- sub UserFunction {
- my ($name,$reading,$value) = @_;
- my $hash = $defs{$name};
- ...
- # e.g. output transfered data
- Log3 $name, 1, "UserExitFn $name called - transfer parameter are Reading: $reading, Value: $value " ;
- ...
- return;
- }
-
- The interface activation takes place by setting the subroutine name into the attribute.
- Optional you may set a Reading:Value combination (Regex) as argument. If no Regex is
- specified, all value combinations will be evaluated as "true" (related to .*:.*).
-
- Example: userExitFn UserFunction .*:.*
-
- $name - the name of the DbRep-Device
- $reading - the name of the created reading
- $value - the value of the reading
-
-
- valueFilter - Regular expression to filter datasets within particular functions. The regex is
- applied to a particular field or to the whole selected dataset (inclusive Device, Reading and
- so on).
- Please consider the explanations within the set-commands. Readings
-
-
- Regarding to the selected operation the reasults will be shown as readings. At the beginning of a new operation all old readings will be deleted to avoid
- that unsuitable or invalid readings would remain.
- state - contains the current state of evaluation. If warnings are occured (state = Warning) compare Readings
- "diff_overrun_limit_<diffLimit>" and "less_data_in_period" errortext - description about the reason of an error state background_processing_time - the processing time spent for operations in background/forked operation sql_processing_time - the processing time wasted for all sql-statements used for an operation diff_overrun_limit_<diffLimit> - contains a list of pairs of datasets which have overrun the threshold (<diffLimit>)
- of calculated difference each other determined by attribute "diffAccept" (default=20). less_data_in_period - contains a list of time periods within only one dataset was found. The difference calculation considers
- the last value of the aggregation period before the current one. Valid for function "diffValue". SqlResult - result of the last executed sqlCmd-command. The formatting can be specified
- by attribute "sqlResultFormat" sqlCmd - contains the last executed sqlCmd-command
-
-DbRep Agent - automatic change of device names in databases and DbRep-definitions after FHEM "rename" command
-
-
- By the attribute "role" the role of DbRep-device will be configured. The standard role is "Client". If the role has changed to "Agent", the DbRep device
- react automatically on renaming devices in your FHEM installation. The DbRep device is now called DbRep-Agent.
- in the database connected to the DbRep-Agent (Internal Database) dataset containing the old device name will be searched and renamed to the
- to the new device name in all affected datasets. in the DbLog-Device assigned to the DbRep-Agent the definition will be changed to substitute the old device name by the new one. Thereby the logging of
- the renamed device will be going on in the database. in other existing DbRep-definitions with Type "Client" a possibly set attribute "device = old device name" will be changed to "device = new device name".
- Because of that, reporting definitions will be kept consistent automatically if devices are renamed in FHEM.
- within a FHEM installation only one DbRep-Agent can be configured for every defined DbLog-database. That means, if more than one DbLog-database is present,
- you could define same numbers of DbRep-Agents as well as DbLog-devices are defined. after changing to DbRep-Agent role only the set-command "renameDevice" will be available and as well as a reduced set of module specific attributes will be
- permitted. If a DbRep-device of privious type "Client" has changed an Agent, furthermore not permitted attributes will be deleted if set.
- Example of definition of a DbRep-device as an Agent:
- define Rep.Agent DbRep LogDB
-
-
- Note:
-
-=end html
-=begin html_DE
-
-DbRep
-
- Attribute ).
- Selektion aller Datensätze innerhalb einstellbarer Zeitgrenzen
- Darstellung der Datensätze einer Device/Reading-Kombination innerhalb einstellbarer Zeitgrenzen.
- Selektion der Datensätze unter Verwendung von dynamisch berechneter Zeitgrenzen zum Ausführungszeitpunkt.
- Dubletten-Hervorhebung bei Datensatzanzeige (fetchrows)
- Berechnung der Anzahl von Datensätzen einer Device/Reading-Kombination unter Berücksichtigung von Zeitgrenzen
- und verschiedenen Aggregationen.
- Die Berechnung von Summen-, Differenz-, Maximum-, Minimum- und Durchschnittswerten numerischer Readings
- in Zeitgrenzen und verschiedenen Aggregationen.
- Speichern von Summen-, Differenz- , Maximum- , Minimum- und Durchschnittswertberechnungen in der Datenbank
- Löschung von Datensätzen. Die Eingrenzung der Löschung kann durch Device und/oder Reading sowie fixer oder
- dynamisch berechneter Zeitgrenzen zum Ausführungszeitpunkt erfolgen.
- Export von Datensätzen in ein File im CSV-Format
- Import von Datensätzen aus File im CSV-Format
- Umbenennen von Device/Readings in Datenbanksätzen
- Ändern von Reading-Werten (VALUES) in der Datenbank (changeValue)
- automatisches Umbenennen von Device-Namen in Datenbanksätzen und DbRep-Definitionen nach FHEM "rename"
- Befehl (siehe DbRep-Agent )
- Ausführen von beliebigen Benutzer spezifischen SQL-Kommandos (non-blocking)
- Ausführen von beliebigen Benutzer spezifischen SQL-Kommandos (blocking) zur Verwendung in eigenem Code (dbValue)
- Backups der FHEM-Datenbank im laufenden Betrieb erstellen (MySQL, SQLite)
- senden des Dumpfiles zu einem FTP-Server nach dem Backup incl. Versionsverwaltung
- Restore von SQLite- und MySQL-Dumps
- Optimierung der angeschlossenen Datenbank (optimizeTables, vacuum)
- Ausgabe der existierenden Datenbankprozesse (MySQL)
- leeren der current-Tabelle
- Auffüllen der current-Tabelle mit einem (einstellbaren) Extrakt der history-Tabelle
- Bereinigung sequentiell aufeinander folgender Datensätze mit unterschiedlichen Zeitstempel aber gleichen Werten (sequentielle Dublettenbereinigung)
- Reparatur einer korrupten SQLite Datenbank ("database disk image is malformed")
- Übertragung von Datensätzen aus der Quelldatenbank in eine andere (Standby) Datenbank (syncStandby)
- Reduktion der Anzahl von Datensätzen in der Datenbank (reduceLog)
- Autorename wird dem definierten DbRep-Device mit dem Attribut "role" die Rolle "Agent" zugewiesen. Die Standardrolle nach Definition
- ist "Client". Mehr ist dazu im Abschnitt DbRep-Agent beschrieben. UserExit zur Verfügung. Über diese Schnittstelle kann der Nutzer in Abhängigkeit von
- frei definierbaren Reading/Value-Kombinationen (Regex) eigenen Code zur Ausführung bringen. Diese Schnittstelle arbeitet
- unabhängig von einer Eventgenerierung. Weitere Informationen dazu ist unter Attribut
- "userExitFn" beschrieben. DbReadingsVal zur Verfügung gestellt.
- Mit dieser Funktion läßt sich, ähnlich dem allgemeinen ReadingsVal, der Wert eines Readings aus der Datenbank abrufen.
- Die Funktionsausführung erfolgt blockierend.
- Die Befehlssyntax ist:
- DbReadingsVal("<name>","<device:reading>","<timestamp>","<default>") Beispiele:
-
- <name> : Name des abzufragenden DbRep-Device <device:reading> : Device:Reading dessen Wert geliefert werden soll <timestamp> : Zeitpunkt des zu liefernden Readingwertes (*) in der Form "YYYY-MM-DD hh:mm:ss" <default> : Defaultwert falls kein Readingwert ermittelt werden konnte
-
- Modul 93_DbRep - Reporting und Management von Datenbankinhalten (DbLog) . DbRep - Reporting und Management von DbLog-Datenbankinhalten .
-
-Voraussetzungen
- Das Modul setzt den Einsatz einer oder mehrerer DbLog-Instanzen voraus. Es werden die Zugangsdaten dieser
- Datenbankdefinition genutzt.
- CREATE INDEX Report_Idx ON `history` (TIMESTAMP, READING) USING BTREE;
-
-
-Definition
-
-
-
- define <name> DbRep <Name der DbLog-Instanz>
-
-
- nicht der Datenbankname selbst)
-
-
-
-Set
-
-
- Zur Zeit gibt es folgende Set-Kommandos. Über sie werden die Auswertungen angestoßen und definieren selbst die Auswertungsvariante.
- Nach welchen Kriterien die Datenbankinhalte durchsucht werden und die Aggregation erfolgt, wird durch Attribute gesteuert.
-
- averageValue [display | writeToDB]
- - berechnet einen Durchschnittswert des Datenbankfelds "VALUE" in den
- gegebenen Zeitgrenzen ( siehe Attribute ).
- Es muss das auszuwertende Reading über das Attribut "reading"
- angegeben sein.
- Beispiel neuer Readingname gebildet aus dem Originalreading "totalpac":
-
- cancelDump - bricht einen laufenden Datenbankdump ab. changeValue - ändert den gespeicherten Wert eines Readings.
- Ist die Selektion auf bestimmte Device/Reading-Kombinationen durch die
- Attribute "device" bzw. "reading" beschränkt, werden sie genauso
- berücksichtigt wie gesetzte Zeitgrenzen (Attribute time.*).
- Syntax:
-<alter String> : * ein einfacher String mit/ohne Leerzeichen, z.B. "OL 12"
- * ein String mit Verwendung von SQL-Wildcard, z.B. "%OL%"
-
-<neuer String> : * ein einfacher String mit/ohne Leerzeichen, z.B. "12 kWh"
- * Perl Code eingeschlossen in "{}" inkl. Quotes, z.B. "{($VALUE,$UNIT) = split(" ",$VALUE)}".
- Dem Perl-Ausdruck werden die Variablen $VALUE und $UNIT übergeben. Sie können innerhalb
- des Perl-Code geändert werden. Der zurückgebene Wert von $VALUE und $UNIT wird in dem Feld
- VALUE bzw. UNIT des Datensatzes gespeichert.
-
-
- Beispiele:
-
-
- device : Selektion nur von Datensätzen die <device> enthalten reading : Selektion nur von Datensätzen die <reading> enthalten time.* : eine Reihe von Attributen zur Zeitabgrenzung executeBeforeProc : ausführen FHEM Kommando (oder perl-Routine) vor Start changeValue executeAfterProc : ausführen FHEM Kommando (oder perl-Routine) nach Ende changeValue
-
- Hinweis: countEntries [history | current]
- - liefert die Anzahl der Tabelleneinträge (default: history) in den gegebenen
- Zeitgrenzen (siehe Attribute ).
- Sind die Timestamps nicht gesetzt, werden alle Einträge der Tabelle gezählt.
- Beschränkungen durch die Attribute Device bzw. Reading
- gehen in die Selektion mit ein.
-
-
- aggregation : Zusammenfassung/Gruppierung von Zeitintervallen countEntriesDetail : detaillierte Ausgabe der Datensatzanzahl device : Selektion nur von Datensätzen die <device> enthalten reading : Selektion nur von Datensätzen die <reading> enthalten time.* : eine Reihe von Attributen zur Zeitabgrenzung
-
- delEntries - löscht alle oder die durch die Attribute device und/oder
- reading definierten Datenbankeinträge. Die Eingrenzung über Timestamps erfolgt
- folgendermaßen:
- "timestamp_begin" gesetzt -> gelöscht werden DB-Einträge ab diesem Zeitpunkt bis zum aktuellen Datum/Zeit -> gelöscht werden DB-Einträge bis bis zu diesem Zeitpunkt -> gelöscht werden DB-Einträge zwischen diesen Zeitpunkten -> gelöscht werden DB-Einträge älter als aktuelle Zeit minus "timeOlderThan" -> gelöscht werden DB-Einträge ab aktueller Zeit minus "timeDiffToNow" bis jetzt Attribut "allowDeletion"
- gesetzt sein um die Löschfunktion freizuschalten.
-
-
- allowDeletion : Freischaltung der Löschfunktion device : Selektion nur von Datensätzen die <device> enthalten reading : Selektion nur von Datensätzen die <reading> enthalten time.* : eine Reihe von Attributen zur Zeitabgrenzung executeBeforeProc : ausführen FHEM Kommando (oder perl-Routine) vor Start delEntries executeAfterProc : ausführen FHEM Kommando (oder perl-Routine) nach Ende delEntries
-
-
-
- delSeqDoublets [adviceRemain | adviceDelete | delete] - zeigt bzw. löscht aufeinander folgende identische Datensätze.
- Dazu wird Device,Reading und Value ausgewertet. Nicht gelöscht werden der erste und der letzte Datensatz
- einer Aggregationsperiode (z.B. hour, day, week usw.) sowie die Datensätze vor oder nach einem Wertewechsel
- (Datenbankfeld VALUE). Attribute zur Aggregation,Zeit-,Device- und Reading-Abgrenzung werden dabei
- berücksichtigt. Ist das Attribut "aggregation" nicht oder auf "no" gesetzt, wird als Standard die Aggregation
- "day" verwendet. Für Datensätze mit numerischen Werten kann mit dem Attribut
- "seqDoubletsVariance" eine Abweichung eingestellt werden, bis zu der aufeinander folgende numerische Werte als
- identisch angesehen und gelöscht werden sollen.
-
-
-
- adviceRemain : simuliert die nach der Operation in der DB verbleibenden Datensätze (es wird nichts gelöscht !) adviceDelete : simuliert die zu löschenden Datensätze (es wird nichts gelöscht !) delete : löscht die sequentiellen Dubletten (siehe Beispiel)
-
- Attribut "allowDeletion" für die "delete" Option
- gesetzt sein. Attribut "limit" angepasst werden.
- Die Einstellung von "limit" hat keinen Einfluss auf die "delSeqDoublets delete" Funktion, sondern beeinflusst NUR die
- Anzeige der Daten. Attribute "executeBeforeProc", "executeAfterProc")
-
- Beispiel - die nach Verwendung der delete-Option in der DB verbleibenden Datensätze sind fett
- gekennzeichnet:
- 2017-11-25_00-00-05__eg.az.fridge_Pwr__power 0 2017-11-25_01-08-21__eg.az.fridge_Pwr__power 0 2017-11-25_01-08-59__eg.az.fridge_Pwr__power 60.32 2017-11-25_01-11-21__eg.az.fridge_Pwr__power 56.26 2017-11-25_01-27-54__eg.az.fridge_Pwr__power 6.19 2017-11-25_01-28-51__eg.az.fridge_Pwr__power 0 2017-11-25_02-39-29__eg.az.fridge_Pwr__power 0 2017-11-25_02-41-18__eg.az.fridge_Pwr__power 105.28 2017-11-25_02-41-26__eg.az.fridge_Pwr__power 61.52 2017-11-25_03-00-06__eg.az.fridge_Pwr__power 47.46 2017-11-25_03-00-33__eg.az.fridge_Pwr__power 0 2017-11-25_23-40-10__eg.az.fridge_Pwr__power 0 2017-11-25_23-42-24__eg.az.fridge_Pwr__power 1 2017-11-25_23-45-27__eg.az.fridge_Pwr__power 1 2017-11-25_23-47-07__eg.az.fridge_Pwr__power 0 2017-11-25_23-48-15__eg.az.fridge_Pwr__power 0 2017-11-25_23-50-21__eg.az.fridge_Pwr__power 59.1 2017-11-25_23-55-14__eg.az.fridge_Pwr__power 52.31 2017-11-25_23-58-09__eg.az.fridge_Pwr__power 51.73
-
-
- deviceRename - benennt den Namen eines Device innerhalb der angeschlossenen Datenbank (Internal
- DATABASE) um.
- Der Gerätename wird immer in der gesamten Datenbank umgesetzt. Eventuell gesetzte
- Zeitgrenzen oder Beschränkungen durch die Attribute Device bzw.
- Reading werden nicht berücksichtigt.
- Beispiel: Hinweis: diffValue [display | writeToDB]
- - berechnet den Differenzwert des Datenbankfelds "VALUE" in den Zeitgrenzen (Attribute) "timestamp_begin", "timestamp_end" bzw "timeDiffToNow / timeOlderThan".
- Es muss das auszuwertende Reading im Attribut "reading" angegeben sein.
- Diese Funktion ist z.B. zur Auswertung von Eventloggings sinnvoll, deren Werte sich fortlaufend erhöhen und keine Wertdifferenzen wegschreiben. Attribut "diffAccept").
- Hinweis:
- Ist keine oder die Option "display" angegeben, werden die Ergebnisse nur angezeigt. Mit
- der Option "writeToDB" werden die Berechnungsergebnisse mit einem neuen Readingnamen
- in der Datenbank gespeichert.
- Beispiel neuer Readingname gebildet aus dem Originalreading "totalpac": dumpMySQL [clientSide | serverSide]
- - erstellt einen Dump der angeschlossenen MySQL-Datenbank.
- Option clientSide Attribut "dumpDirLocal" verändert werden und muß auf
- dem Client durch FHEM beschreibbar sein. Achtung ! Attribute "dumpMemlimit" und "dumpSpeed" kann das Laufzeitverhalten der
- Funktion beeinflusst werden um eine Optimierung bezüglich Performance und Ressourcenbedarf zu erreichen.
-
-
- dumpComment : User-Kommentar im Dumpfile dumpCompress : Komprimierung des Dumpfiles nach der Erstellung dumpDirLocal : das lokale Zielverzeichnis für die Erstellung des Dump dumpMemlimit : Begrenzung der Speicherverwendung dumpSpeed : Begrenzung die CPU-Belastung dumpFilesKeep : Anzahl der aufzubwahrenden Dumpfiles executeBeforeProc : ausführen FHEM Kommando (oder perl-Routine) vor dem Dump executeAfterProc : ausführen FHEM Kommando (oder perl-Routine) nach dem Dump optimizeTablesBeforeDump : Tabelloptimierung vor dem Dump ausführen
-
- Namenskonvention der Dumpfiles ist: <dbname>_<date>_<time>.sql[.gzip]
- set <name> restoreMySQL <filename>
-
- verwendet werden.
- mysql -u <user> -p <dbname> < <filename>.sql
-
- auf dem MySQL-Server ausgeführt werden um die Datenbank aus dem Dump wiederherzustellen. Option serverSide im CSV-Format ohne
- Einschränkungen exportiert. Achtung !
-
-
- dumpDirRemote : das Erstellungsverzeichnis des Dumpfile auf dem entfernten Server dumpCompress : Komprimierung des Dumpfiles nach der Erstellung dumpDirLocal : Directory des lokal gemounteten dumpDirRemote-Verzeichnisses dumpFilesKeep : Anzahl der aufzubwahrenden Dumpfiles executeBeforeProc : ausführen FHEM Kommando (oder perl-Routine) vor dem Dump executeAfterProc : ausführen FHEM Kommando (oder perl-Routine) nach dem Dump optimizeTablesBeforeDump : Tabelloptimierung vor dem Dump ausführen
-
- Attribut "dumpDirRemote" verändert werden.
- Es muß sich auf dem MySQL-Host gefinden und durch den MySQL-Serverprozess beschreibbar sein. Hinweis: Attribut "dumpDirLocal" dem DbRep-Device bekannt zu machen.
- Beispiel:
-
- Wird die interne Versionsverwaltung genutzt, werden nach einem erfolgreichen Dump alte Dumpfiles gelöscht
- und nur die Anzahl "dumpFilesKeep" (default: 3) verbleibt im Zielverzeichnis "dumpDirRemote".
- FHEM benötigt in diesem Fall Schreibrechte auf dem Verzeichnis "dumpDirLocal". Namenskonvention der Dumpfiles ist: <dbname>_<date>_<time>.csv[.gzip]
- set <name> <restoreMySQL> <filename>.csv[.gzip]
-
- gestartet werden. FTP Transfer nach Dump Attribut "ftpUse" oder
- "ftpUseSSL" zu setzen. Letzteres gilt wenn eine verschlüsselte Übertragung genutzt werden soll. Attribute sind:
-
-
- ftpUse : FTP Transfer nach dem Dump wird eingeschaltet (ohne SSL Verschlüsselung) ftpUser : User zur Anmeldung am FTP-Server, default: anonymous ftpUseSSL : FTP Transfer mit SSL Verschlüsselung nach dem Dump wird eingeschaltet ftpDebug : Debugging des FTP Verkehrs zur Fehlersuche ftpDir : Verzeichnis auf dem FTP-Server in welches das File übertragen werden soll (default: "/") ftpDumpFilesKeep : Es wird die angegebene Anzahl Dumpfiles im <ftpDir> belassen (default: 3) ftpPassive : setzen wenn passives FTP verwendet werden soll ftpPort : FTP-Port, default: 21 ftpPwd : Passwort des FTP-Users, default nicht gesetzt ftpServer : Name oder IP-Adresse des FTP-Servers. notwendig ! ftpTimeout : Timeout für die FTP-Verbindung in Sekunden (default: 30).
-
-
- dumpSQLite - erstellt einen Dump der angeschlossenen SQLite-Datenbank. Attribut "dumpDirLocal" verändert werden und muß
- durch FHEM beschreibbar sein.
- Vor dem Dump kann optional eine Tabellenoptimierung (Attribut "optimizeTablesBeforeDump")
- zugeschaltet werden.
- Achtung !
-
-
- dumpCompress : Komprimierung des Dumpfiles nach der Erstellung dumpDirLocal : Directory des lokal gemounteten dumpDirRemote-Verzeichnisses dumpFilesKeep : Anzahl der aufzubwahrenden Dumpfiles executeBeforeProc : ausführen FHEM Kommando (oder perl-Routine) vor dem Dump executeAfterProc : ausführen FHEM Kommando (oder perl-Routine) nach dem Dump optimizeTablesBeforeDump : Tabelloptimierung vor dem Dump ausführen
-
- Namenskonvention der Dumpfiles ist: <dbname>_<date>_<time>.sqlitebkp[.gzip] eraseReadings - Löscht alle angelegten Readings im Device, außer dem Reading "state" und Readings, die in der
- Ausnahmeliste definiert mit Attribut "readingPreventFromDel" enthalten sind.
- exportToFile [<File>]
- - exportiert DB-Einträge im CSV-Format in den gegebenen Zeitgrenzen. Attribute "device" bzw. "reading" gehen in die Selektion mit ein.
- Der Dateiname wird durch das Attribut "expimpfile" bestimmt.
-
-
- aggregation : Festlegung der Selektionspaketierung device : Einschränkung des Exports auf ein bestimmtes Device reading : Einschränkung des Exports auf ein bestimmtes Reading executeBeforeProc : FHEM Kommando (oder perl-Routine) vor dem Export ausführen executeAfterProc : FHEM Kommando (oder perl-Routine) nach dem Export ausführen expimpfile : der Name des Exportfiles time.* : eine Reihe von Attributen zur Zeitabgrenzung
-
-
- fetchrows [history|current]
- - liefert alle Tabelleneinträge (default: history)
- in den gegebenen Zeitgrenzen bzw. Selektionsbedingungen durch die Attribute
- "device" und "reading".
- Eine evtl. gesetzte Aggregation wird dabei nicht berücksichtigt. Attribut
- "fetchRoute" bestimmt werden. Hinweis:
-
- attr <name> widgetOverride fetchMarkDuplicates:colorpicker
-
-
-
- Beispiel:
-
-
-
- fetchRoute : Leserichtung der Selektion innerhalb der Datenbank limit : begrenzt die Anzahl zu selektierenden bzw. anzuzeigenden Datensätze fetchMarkDuplicates : Hervorhebung von gefundenen Dubletten device : Selektion nur von Datensätzen die <device> enthalten reading : Selektion nur von Datensätzen die <reading> enthalten time.* : eine Reihe von Attributen zur Zeitabgrenzung valueFilter : filtert die anzuzeigenden Datensätze mit einem regulären Ausdruck. Der Regex wird auf den gesamten anzuzeigenden Datensatz angewendet.
-
- Hinweis: Attribut "limit" begrenzt. Bei Bedarf kann dieses Attribut
- geändert werden, falls eine Anpassung der Selektionsbedingungen nicht möglich oder
- gewünscht ist. insert - Manuelles Einfügen eines Datensatzes in die Tabelle "history". Obligatorisch sind Eingabewerte für Datum, Zeit und Value.
- Die Werte für die DB-Felder Type bzw. Event werden mit "manual" gefüllt, sowie die Werte für Device, Reading aus den gesetzten Attributen genommen.
- Eingabeformat: Datum,Zeit,Value,[Unit] Beispiel: 2016-08-01,23:00:09,TestValue,TestUnit Hinweis: importFromFile [<File>]
- - importiert Datensätze im CSV-Format aus einer Datei in die Datenbank. Attribut "expimpfile" bestimmt.
- Datensatzformat: Beispiel:
-
-
- executeBeforeProc : FHEM Kommando (oder perl-Routine) vor dem Import ausführen executeAfterProc : FHEM Kommando (oder perl-Routine) nach dem Import ausführen expimpfile : der Name des Importfiles
-
- maxValue [display | writeToDB]
- - berechnet den Maximalwert des Datenbankfelds "VALUE" in den Zeitgrenzen
- (Attribute) "timestamp_begin", "timestamp_end" bzw. "timeDiffToNow / timeOlderThan".
- Es muss das auszuwertende Reading über das Attribut "reading"
- angegeben sein.
- Die Auswertung enthält den Zeitstempel des ermittelten Maximumwertes innerhalb der
- Aggregation bzw. Zeitgrenzen.
- Im Reading wird der Zeitstempel des letzten Auftretens vom Maximalwert ausgegeben
- falls dieser Wert im Intervall mehrfach erreicht wird.
- Beispiel neuer Readingname gebildet aus dem Originalreading "totalpac": minValue [display | writeToDB]
- - berechnet den Minimalwert des Datenbankfelds "VALUE" in den Zeitgrenzen
- (Attribute) "timestamp_begin", "timestamp_end" bzw. "timeDiffToNow / timeOlderThan".
- Es muss das auszuwertende Reading über das Attribut "reading"
- angegeben sein.
- Die Auswertung enthält den Zeitstempel des ermittelten Minimumwertes innerhalb der
- Aggregation bzw. Zeitgrenzen.
- Im Reading wird der Zeitstempel des ersten Auftretens vom Minimalwert ausgegeben
- falls dieser Wert im Intervall mehrfach erreicht wird.
- Beispiel neuer Readingname gebildet aus dem Originalreading "totalpac": optimizeTables - optimiert die Tabellen in der angeschlossenen Datenbank (MySQL). Attribute "executeBeforeProc", "executeAfterProc")
-
- Hinweis: readingRename - benennt den Namen eines Readings innerhalb der angeschlossenen Datenbank (siehe Internal DATABASE) um.
- Der Readingname wird immer in der gesamten Datenbank umgesetzt. Eventuell
- gesetzte Zeitgrenzen oder Beschränkungen durch die Attribute
- Device bzw. Reading werden nicht berücksichtigt.
- Beispiel: Hinweis: reduceLog [average[=day]] [exclude=device1:reading1,device2:reading2,...] [include=device:reading]
-
-
- executeBeforeProc : FHEM Kommando (oder perl-Routine) vor dem Export ausführen executeAfterProc : FHEM Kommando (oder perl-Routine) nach dem Export ausführen timeOlderThan : es werden Datenbankeinträge älter als dieses Attribut reduziert timestamp_end : es werden Datenbankeinträge älter als dieses Attribut reduziert timeDiffToNow : es werden Datenbankeinträge neuer als dieses Attribut reduziert timestamp_begin : es werden Datenbankeinträge neuer als dieses Attribut reduziert
-
- Tipp: Wird "exclude=.*:.*" angegeben, wird nichts in der Datenbank gelöscht. Das kann
- z.B. verwendet werden um vorab die gesetzten Zeitgrenzen und die Anzahl der zu bearbeitenden
- Datenbankeinträge zu checken.
- Beispiel:
-
- Hinweis: repairSQLite - repariert eine korrupte SQLite-Datenbank.
- Beispiel: Hinweis: restoreMySQL <File> - stellt die Datenbank aus einem serverSide- oder clientSide-Dump wieder her. Verwendung eines serverSide-Dumps Attribut "dumpDirLocal" dem DbRep-Device bekannt zu machen. Verwendung eines clientSide-Dumps Attribut "dumpDirLocal" dem
- DbRep-Device bekannt zu machen. max_allowed_packet ". Durch Veränderung
- dieser Variable im File my.cnf kann die Geschwindigkeit angepasst werden. Auf genügend verfügbare Ressourcen (insbesondere
- RAM) ist dabei zu achten. restoreSQLite <File>.sqlitebkp[.gzip] - stellt das Backup einer SQLite-Datenbank wieder her. sqlCmd - führt ein beliebiges Benutzer spezifisches Kommando aus. Attribut "allowDeletion" gesetzt sein. Attribute "timestamp_begin" bzw.
- "timestamp_end" im Statement berücksichtigt werden, können die Platzhalter
- "§timestamp_begin§ " bzw. "§timestamp_end§ " dafür verwendet werden.
- Beispiele für Statements:
- set <name> sqlCmd select DEVICE, count(*) from history where TIMESTAMP >= "2017-01-06 00:00:00" group by DEVICE having count(*) > 800
- set <name> sqlCmd select DEVICE, count(*) from history where TIMESTAMP >= "2017-05-06 00:00:00" group by DEVICE
- set <name> sqlCmd select DEVICE, count(*) from history where TIMESTAMP >= §timestamp_begin§ group by DEVICE
- set <name> sqlCmd select * from history where DEVICE like "Te%t" order by `TIMESTAMP` desc
- set <name> sqlCmd select * from history where `TIMESTAMP` > "2017-05-09 18:03:00" order by `TIMESTAMP` desc
- set <name> sqlCmd select * from current order by `TIMESTAMP` desc
- set <name> sqlCmd select sum(VALUE) as 'Einspeisung am 04.05.2017', count(*) as 'Anzahl' FROM history where `READING` = "Einspeisung_WirkP_Zaehler_Diff" and TIMESTAMP between '2017-05-04' AND '2017-05-05'
- set <name> sqlCmd delete from current
- set <name> sqlCmd delete from history where TIMESTAMP < "2016-05-06 00:00:00"
- set <name> sqlCmd update history set TIMESTAMP=TIMESTAMP,VALUE='Val' WHERE VALUE='TestValue'
- set <name> sqlCmd select * from history where DEVICE = "Test"
- set <name> sqlCmd insert into history (TIMESTAMP, DEVICE, TYPE, EVENT, READING, VALUE, UNIT) VALUES ('2017-05-09 17:00:14','Test','manuell','manuell','Tes§e','TestValue','°C')
-
- Reading "SqlResult" dargestellt.
- Die Ergebnis-Formatierung kann durch das Attribut "sqlResultFormat" ausgewählt, sowie der verwendete
- Feldtrenner durch das Attribut "sqlResultFieldSep" festgelegt werden.
-
-
- allowDeletion : aktiviert Löschmöglichkeit sqlResultFormat : legt die Darstellung des Kommandoergebnis fest sqlResultFieldSep : Auswahl Feldtrenner im Ergebnis sqlCmdHistoryLength : Aktivierung Kommando-Historie und deren Umfang
-
- Hinweis: sqlCmdHistory - Wenn mit dem Attribut "sqlCmdHistoryLength" aktiviert, kann
- aus einer Liste ein bereits erfolgreich ausgeführtes sqlCmd-Kommando wiederholt werden. sqlSpecial - Die Funktion bietet eine Drop-Downliste mit einer Auswahl vorbereiter Auswertungen
- an. Attribut "sqlResultFormat"
- ausgewählt, sowie der verwendete Feldtrenner durch das Attribut
- "sqlResultFieldSep" festgelegt werden.
-
-
- sqlResultFormat : Optionen der Ergebnisformatierung sqlResultFieldSep : Auswahl des Trennzeichens zwischen Ergebnisfeldern
-
-
-
-
- 50mostFreqLogsLast2days : ermittelt die 50 am häufigsten vorkommenden Loggingeinträge der letzten 2 Tage allDevCount : alle in der Datenbank vorkommenden Devices und deren Anzahl allDevReadCount : alle in der Datenbank vorkommenden Device/Reading-Kombinationen und deren Anzahl
-
-
- sumValue [display | writeToDB]
- - Berechnet die Summenwerte des Datenbankfelds "VALUE" in den Zeitgrenzen
- (Attribute) "timestamp_begin", "timestamp_end" bzw. "timeDiffToNow / timeOlderThan".
- Es muss das auszuwertende Reading im Attribut "reading"
- angegeben sein. Diese Funktion ist sinnvoll wenn fortlaufend Wertedifferenzen eines
- Readings in die Datenbank geschrieben werden.
- Beispiel neuer Readingname gebildet aus dem Originalreading "totalpac": syncStandby <DbLog-Device Standby>
- - Es werden die Datensätze aus der angeschlossenen Datenbank (Quelle) direkt in eine weitere
- Datenbank (Standby-Datenbank) übertragen.
- Dabei ist "<DbLog-Device Standby>" das DbLog-Device, welches mit der Standby-Datenbank
- verbunden ist. Attribute
- bzw. die Attribute "device", "reading" bestimmt sind.
-
-
- aggregation : Einstellung der Zeitscheiben zur Übertragung (hour,day,week) device : Übertragung nur von Datensätzen die <device> enthalten reading : Übertragung nur von Datensätzen die <reading> enthalten time.* : Attribute zur Zeitabgrenzung der zu übertragenden Datensätze.
-
- tableCurrentFillup - Die current-Tabelle wird mit einem Extrakt der history-Tabelle aufgefüllt.
- Die Attribute zur Zeiteinschränkung bzw. device, reading werden ausgewertet.
- Dadurch kann der Inhalt des Extrakts beeinflusst werden. Im zugehörigen DbLog-Device sollte sollte das Attribut
- "DbLogType=SampleFill/History" gesetzt sein. tableCurrentPurge - löscht den Inhalt der current-Tabelle. Es werden keine Limitierungen, z.B. durch die Attribute "timestamp_begin",
- "timestamp_end", device, reading, usw. , ausgewertet. vacuum - optimiert die Tabellen in der angeschlossenen Datenbank (SQLite, PostgreSQL). Attribute "executeBeforeProc", "executeAfterProc")
-
- Hinweis: Für alle Auswertungsvarianten (Ausnahme sqlCmd,deviceRename,readingRename) gilt: Hinweis: Get
-
-
- Die Get-Kommandos von DbRep dienen dazu eine Reihe von Metadaten der verwendeten Datenbankinstanz abzufragen.
- Dies sind zum Beispiel eingestellte Serverparameter, Servervariablen, Datenbankstatus- und Tabelleninformationen. Die verfügbaren get-Funktionen
- sind von dem verwendeten Datenbanktyp abhängig. So ist für SQLite z.Zt. nur "svrinfo" verfügbar. Die Funktionen liefern nativ sehr viele Ausgabewerte,
- die über über funktionsspezifische Attribute abgrenzbar sind. Der Filter ist als kommaseparierte Liste anzuwenden.
- Dabei kann SQL-Wildcard (%) verwendet werden.
- Hinweis: minTimestamp - Ermittelt den Zeitstempel des ältesten Datensatzes in der Datenbank (wird implizit beim Start von
- FHEM ausgeführt).
- Der Zeitstempel wird als Selektionsbeginn verwendet wenn kein Zeitattribut den Selektionsbeginn
- festlegt.
- procinfo - Listet die existierenden Datenbank-Prozesse in einer Tabelle auf (nur MySQL). hier verfügbar. svrinfo - allgemeine Datenbankserver-Informationen wie z.B. die DBMS-Version, Serveradresse und Port usw. Die Menge der Listenelemente
- ist vom Datenbanktyp abhängig. Mit dem Attribut "showSvrInfo" kann die Ergebnismenge eingeschränkt werden.
- Weitere Erläuterungen zu den gelieferten Informationen sind
- hier zu finden.
- Bespiel
-
- tableinfo - ruft Tabelleninformationen aus der mit dem DbRep-Device verbundenen Datenbank ab (MySQL).
- Es werden per default alle in der verbundenen Datenbank angelegten Tabellen ausgewertet.
- Mit dem Attribut "showTableInfo" können die Ergebnisse eingeschränkt werden. Erläuterungen zu den erzeugten
- Readings sind hier zu finden.
- Bespiel versionNotes [hints | rel | <key>] -
- Zeigt Release Informationen und/oder Hinweise zum Modul an. Es sind nur Release Informationen mit
- Bedeutung für den Modulnutzer enthalten. Attribute
-
-
- Über die modulspezifischen Attribute wird die Abgrenzung der Auswertung und die Aggregation der Werte gesteuert. Hinweis zur SQL-Wildcard Verwendung: ausser "insert", "importFromFile" und "deviceRename".
- aggregation - Zusammenfassung der Device/Reading-Selektionen in Stunden,Tage,Kalenderwochen,Kalendermonaten
- oder "no". allowDeletion - schaltet die Löschfunktion des Moduls frei averageCalcForm - legt die Berechnungsvariante für die Ermittlung des Durchschnittswertes mit "averageValue"
- fest.
-
-
- avgArithmeticMean : es wird der arithmetische Mittelwert berechnet (default) avgDailyMeanGWS : berechnet die Tagesmitteltemperatur entsprechend den
- Vorschriften des deutschen Wetterdienstes (siehe "get <name> versionNotes 2"). avgTimeWeightMean : berechnet den zeitgewichteten Mittelwert
-
- countEntriesDetail - Wenn gesetzt, erstellt die Funktion "countEntries" eine detallierte Ausgabe der Datensatzzahl
- pro Reading und Zeitintervall.
- Standardmäßig wird nur die Summe aller selektierten Datensätze ausgegeben.
- device - Abgrenzung der DB-Selektionen auf ein bestimmtes Device.
- Beispiele: attr <name> device TYPE=DbRep attr <name> device MySTP_5000 attr <name> device SMA.*,MySTP.* attr <name> device SMA_Energymeter,MySTP_5000 attr <name> device %5000
-
- Geräte-Spezifikationen (devspec) .
- diffAccept - gilt für Funktion diffValue. diffAccept legt fest bis zu welchem Schwellenwert eine berechnete positive Werte-Differenz
- zwischen zwei unmittelbar aufeinander folgenden Datensätzen akzeptiert werden soll (Standard ist 20).
- Beispiel Ausgabe im Logfile beim Überschreiten von diffAccept=10: disable - deaktiviert das Modul dumpComment - User-Kommentar. Er wird im Kopf des durch den Befehl "dumpMyQL clientSide" erzeugten Dumpfiles
- eingetragen. dumpCompress - wenn gesetzt, werden die Dumpfiles nach "dumpMySQL" bzw. "dumpSQLite" komprimiert dumpDirLocal - Zielverzeichnis für die Erstellung von Dumps mit "dumpMySQL clientSide".
- default: "{global}{modpath}/log/" auf dem FHEM-Server. dumpDirRemote - Zielverzeichnis für die Erstellung von Dumps mit "dumpMySQL serverSide".
- default: das Home-Dir des MySQL-Servers auf dem MySQL-Host dumpMemlimit - erlaubter Speicherverbrauch für das Dump SQL-Script zur Generierungszeit (default: 100000 Zeichen).
- Bitte den Parameter anpassen, falls es zu Speicherengpässen und damit verbundenen Performanceproblemen
- kommen sollte. dumpSpeed - Anzahl der abgerufenen Zeilen aus der Quelldatenbank (default: 10000) pro Select durch "dumpMySQL ClientSide".
- Dieser Parameter hat direkten Einfluß auf die Laufzeit und den Ressourcenverbrauch zur Laufzeit. dumpFilesKeep - Es wird die angegebene Anzahl Dumpfiles im Dumpdir belassen (default: 3). Sind mehr (ältere) Dumpfiles
- vorhanden, werden diese gelöscht nachdem ein neuer Dump erfolgreich erstellt wurde. Das globale
- Attribut "archivesort" wird berücksichtigt. executeAfterProc - Es kann ein FHEM-Kommando oder eine Perl-Funktion angegeben werden welche nach der
- Befehlsabarbeitung ausgeführt werden soll.
- Beispiel:
-sub adump {
- my ($name) = @_;
- my $hash = $defs{$name};
- # die eigene Funktion, z.B.
- Log3($name, 3, "DbRep $name -> Dump ist beendet");
-
- return;
-}
-
-
-
-
- executeBeforeProc - Es kann ein FHEM-Kommando oder eine Perl-Funktion angegeben werden welche vor der
- Befehlsabarbeitung ausgeführt werden soll.
- Beispiel:
-sub bdump {
- my ($name) = @_;
- my $hash = $defs{$name};
- # die eigene Funktion, z.B.
- Log3($name, 3, "DbRep $name -> Dump startet");
-
- return;
-}
-
-expimpfile - Pfad/Dateiname für Export/Import in/aus einem File.
-
-
- %L : wird ersetzt durch den Wert des global logdir Attributs %TSB : wird ersetzt durch den (berechneten) Wert des timestamp_begin Attributs Allgemein gebräuchliche POSIX-Wildcards sind: %d : Tag des Monats (01..31) %m : Monat (01..12) %Y : Jahr (1970...) %w : Wochentag (0..6); beginnend mit Sonntag (0) %j : Tag des Jahres (001..366) %U : Wochennummer des Jahres, wobei Wochenbeginn = Sonntag (00..53) %W : Wochennummer des Jahres, wobei Wochenbeginn = Montag (00..53)
-
-
- Beispiele: attr <name> expimpfile /sds1/backup/exptest_%TSB.csv attr <name> expimpfile /sds1/backup/exptest_%Y-%m-%d.csv
- Filelog .
- fetchMarkDuplicates
- - Markierung von mehrfach vorkommenden Datensätzen im Ergebnis des "fetchrows" Kommandos fetchRoute [descent | ascent] - bestimmt die Leserichtung des fetchrows-Befehl.
- descent - die Datensätze werden absteigend gelesen (default). Wird
- die durch das Attribut "limit" festgelegte Anzahl der Datensätze
- überschritten, werden die neuesten x Datensätze angezeigt. ascent - die Datensätze werden aufsteigend gelesen. Wird
- die durch das Attribut "limit" festgelegte Anzahl der Datensätze
- überschritten, werden die ältesten x Datensätze angezeigt.
-
- ftpUse - FTP Transfer nach einem Dump wird eingeschaltet (ohne SSL Verschlüsselung). Das erzeugte
- Datenbank Backupfile wird non-blocking zum angegebenen FTP-Server (Attribut "ftpServer")
- übertragen. ftpUseSSL - FTP Transfer mit SSL Verschlüsselung nach einem Dump wird eingeschaltet. Das erzeugte
- Datenbank Backupfile wird non-blocking zum angegebenen FTP-Server (Attribut "ftpServer")
- übertragen. ftpUser - User zur Anmeldung am FTP-Server nach einem Dump, default: "anonymous". ftpDebug - Debugging der FTP Kommunikation zur Fehlersuche. ftpDir - Verzeichnis des FTP-Servers in welches das File nach einem Dump übertragen werden soll
- (default: "/"). ftpDumpFilesKeep - Es wird die angegebene Anzahl Dumpfiles im <ftpDir> belassen (default: 3). Sind mehr
- (ältere) Dumpfiles vorhanden, werden diese gelöscht nachdem ein neuer Dump erfolgreich
- übertragen wurde. ftpPassive - setzen wenn passives FTP verwendet werden soll ftpPort - FTP-Port, default: 21 ftpPwd - Passwort des FTP-Users, default nicht gesetzt ftpServer - Name oder IP-Adresse des FTP-Servers zur Übertragung von Files nach einem Dump. ftpTimeout - Timeout für eine FTP-Verbindung in Sekunden (default: 30). limit - begrenzt die Anzahl der resultierenden Datensätze im select-Statement von "fetchrows", bzw. der anzuzeigenden Datensätze
- der Kommandos "delSeqDoublets adviceDelete", "delSeqDoublets adviceRemain" (default 1000).
- Diese Limitierung soll eine Überlastung der Browsersession und ein
- blockieren von FHEMWEB verhindern. Bei Bedarf entsprechend ändern bzw. die
- Selektionskriterien (Zeitraum der Auswertung) anpassen. optimizeTablesBeforeDump - wenn "1", wird vor dem Datenbankdump eine Tabellenoptimierung ausgeführt (default: 0).
- Dadurch verlängert sich die Laufzeit des Dump.
- Hinweis
- reading - Abgrenzung der DB-Selektionen auf ein bestimmtes oder mehrere Readings.
- Mehrere Readings werden als Komma separierte Liste angegeben.
- Beispiele: attr <name> reading etotal attr <name> reading et% attr <name> reading etotal,etoday
- readingNameMap - der Name des ausgewerteten Readings wird mit diesem String für die Anzeige überschrieben readingPreventFromDel - Komma separierte Liste von Readings die vor einer neuen Operation nicht gelöscht
- werden sollen role - die Rolle des DbRep-Device. Standard ist "Client". Die Rolle "Agent" ist im Abschnitt
- "DbRep-Agent" beschrieben. DbRep-Agent .
- seqDoubletsVariance - akzeptierte Abweichung (+/-) für das Kommando "set <name> delSeqDoublets".
- Beispiele: attr <name> seqDoubletsVariance 0.0014 attr <name> seqDoubletsVariance 1.45
- showproctime - wenn gesetzt, zeigt das Reading "sql_processing_time" die benötigte Abarbeitungszeit (in Sekunden)
- für die SQL-Ausführung der durchgeführten Funktion. Dabei wird nicht ein einzelnes
- SQl-Statement, sondern die Summe aller notwendigen SQL-Abfragen innerhalb der jeweiligen
- Funktion betrachtet. showStatus - grenzt die Ergebnismenge des Befehls "get <name> dbstatus" ein. Es können SQL-Wildcard (%) verwendet werden.
- Bespiel: showVariables - grenzt die Ergebnismenge des Befehls "get <name> dbvars" ein. Es können SQL-Wildcard (%) verwendet werden.
- Bespiel: showSvrInfo - grenzt die Ergebnismenge des Befehls "get <name> svrinfo" ein. Es können SQL-Wildcard (%) verwendet werden.
- Bespiel: showTableInfo - grenzt die Ergebnismenge des Befehls "get <name> tableinfo" ein. Es können SQL-Wildcard (%) verwendet werden.
- Bespiel: sqlResultFieldSep - legt den verwendeten Feldseparator (default: "|") im Ergebnis des Kommandos
- "set ... sqlCmd" fest. sqlCmdHistoryLength
- - aktiviert die Kommandohistorie von "sqlCmd" und legt deren Länge fest sqlResultFormat - legt die Formatierung des Ergebnisses des Kommandos "set <name> sqlCmd" fest.
- Mögliche Optionen sind:
- separated - die Ergebniszeilen werden als einzelne Readings fortlaufend
- generiert. (default)mline - das Ergebnis wird als Mehrzeiler im Reading
- SqlResult dargestellt. sline - das Ergebnis wird als Singleline im Reading
- SqlResult dargestellt. Satztrenner ist"]|[". table - das Ergebnis wird als Tabelle im Reading
- SqlResult dargestellt. json - erzeugt das Reading SqlResult als
- JSON-kodierten Hash.
- Jedes Hash-Element (Ergebnissatz) setzt sich aus der laufenden Nummer
- des Datensatzes (Key) und dessen Wert zusammen.
- sub resfromjson {
- my ($name,$reading,$value) = @_;
- my $hash = $defs{$name};
-
- if ($reading eq "SqlResult") {
- # nur Reading SqlResult enthält JSON-kodierte Daten
- my $data = decode_json($value);
-
- foreach my $k (keys(%$data)) {
-
- # ab hier eigene Verarbeitung für jedes Hash-Element
- # z.B. Ausgabe jedes Element welches "Cam" enthält
- my $ke = $data->{$k};
- if($ke =~ m/Cam/i) {
- my ($res1,$res2) = split("\\|", $ke);
- Log3($name, 1, "$name - extract element $k by userExitFn: ".$res1." ".$res2);
- }
- }
- }
- return;
- }
-
-
- timeYearPeriod - Mit Hilfe dieses Attributes wird eine jährliche Zeitperiode für die Datenbankselektion bestimmt.
- Die Zeitgrenzen werden zur Ausführungszeit dynamisch berechnet. Es wird immer eine Jahresperiode
- bestimmt. Eine unterjährige Angabe ist nicht möglich.
- Beispiel:
- timestamp_begin - der zeitliche Beginn für die Datenselektion
- current_year_begin : entspricht "<aktuelles Jahr>-01-01 00:00:00" current_year_end : entspricht "<aktuelles Jahr>-12-31 23:59:59" previous_year_begin : entspricht "<vorheriges Jahr>-01-01 00:00:00" previous_year_end : entspricht "<vorheriges Jahr>-12-31 23:59:59" current_month_begin : entspricht "<aktueller Monat erster Tag> 00:00:00" current_month_end : entspricht "<aktueller Monat letzter Tag> 23:59:59" previous_month_begin : entspricht "<Vormonat erster Tag> 00:00:00" previous_month_end : entspricht "<Vormonat letzter Tag> 23:59:59" current_week_begin : entspricht "<erster Tag der akt. Woche> 00:00:00" current_week_end : entspricht "<letzter Tag der akt. Woche> 23:59:59" previous_week_begin : entspricht "<erster Tag Vorwoche> 00:00:00" previous_week_end : entspricht "<letzter Tag Vorwoche> 23:59:59" current_day_begin : entspricht "<aktueller Tag> 00:00:00" current_day_end : entspricht "<aktueller Tag> 23:59:59" previous_day_begin : entspricht "<Vortag> 00:00:00" previous_day_end : entspricht "<Vortag> 23:59:59" current_hour_begin : entspricht "<aktuelle Stunde>:00:00" current_hour_end : entspricht "<aktuelle Stunde>:59:59" previous_hour_begin : entspricht "<vorherige Stunde>:00:00" previous_hour_end : entspricht "<vorherige Stunde>:59:59" timestamp_end - das zeitliche Ende für die Datenselektion. Wenn nicht gesetzt wird immer die aktuelle
- Datum/Zeit-Kombi für das Ende der Selektion eingesetzt.
- current_year_begin : entspricht "<aktuelles Jahr>-01-01 00:00:00" current_year_end : entspricht "<aktuelles Jahr>-12-31 23:59:59" previous_year_begin : entspricht "<vorheriges Jahr>-01-01 00:00:00" previous_year_end : entspricht "<vorheriges Jahr>-12-31 23:59:59" current_month_begin : entspricht "<aktueller Monat erster Tag> 00:00:00" current_month_end : entspricht "<aktueller Monat letzter Tag> 23:59:59" previous_month_begin : entspricht "<Vormonat erster Tag> 00:00:00" previous_month_end : entspricht "<Vormonat letzter Tag> 23:59:59" current_week_begin : entspricht "<erster Tag der akt. Woche> 00:00:00" current_week_end : entspricht "<letzter Tag der akt. Woche> 23:59:59" previous_week_begin : entspricht "<erster Tag Vorwoche> 00:00:00" previous_week_end : entspricht "<letzter Tag Vorwoche> 23:59:59" current_day_begin : entspricht "<aktueller Tag> 00:00:00" current_day_end : entspricht "<aktueller Tag> 23:59:59" previous_day_begin : entspricht "<Vortag> 00:00:00" previous_day_end : entspricht "<Vortag> 23:59:59" current_hour_begin : entspricht "<aktuelle Stunde>:00:00" current_hour_end : entspricht "<aktuelle Stunde>:59:59" previous_hour_begin : entspricht "<vorherige Stunde>:00:00" previous_hour_end : entspricht "<vorherige Stunde>:59:59"
- Beispiel:
- Hinweis timeDiffToNow - der Selektionsbeginn wird auf den Zeitpunkt "<aktuelle Zeit> - <timeDiffToNow>"
- gesetzt (z.b. werden die letzten 24 Stunden in die Selektion eingehen wenn das Attribut auf "86400" gesetzt
- wurde). Die Timestampermittlung erfolgt dynamisch zum Ausführungszeitpunkt.
- Eingabeformat Beispiel: attr <name> timeDiffToNow 86400 attr <name> timeDiffToNow d:2 h:3 m:2 s:10 attr <name> timeDiffToNow m:600 attr <name> timeDiffToNow h:2.5 attr <name> timeDiffToNow y:1 h:2.5 attr <name> timeDiffToNow y:1.5
- timeOlderThan - das Selektionsende wird auf den Zeitpunkt "<aktuelle Zeit> - <timeOlderThan>"
- gesetzt. Dadurch werden alle Datensätze bis zu dem Zeitpunkt "<aktuelle
- Zeit> - <timeOlderThan>" berücksichtigt (z.b. wenn auf 86400 gesetzt, werden alle
- Datensätze die älter als ein Tag sind berücksichtigt). Die Timestampermittlung erfolgt
- dynamisch zum Ausführungszeitpunkt.
- Eingabeformat Beispiel: attr <name> timeOlderThan 86400 attr <name> timeOlderThan d:2 h:3 m:2 s:10 attr <name> timeOlderThan m:600 attr <name> timeOlderThan h:2.5 attr <name> timeOlderThan y:1 h:2.5 attr <name> timeOlderThan y:1.5
- timeout - das Attribut setzt den Timeout-Wert für die Blocking-Call Routinen in Sekunden
- (Default: 86400) userExitFn - stellt eine Schnittstelle zur Ausführung eigenen Usercodes zur Verfügung.
- sub UserFunction {
- my ($name,$reading,$value) = @_;
- my $hash = $defs{$name};
- ...
- # z.B. übergebene Daten loggen
- Log3 $name, 1, "UserExitFn $name called - transfer parameter are Reading: $reading, Value: $value " ;
- ...
- return;
- }
-
-
- Die Aktivierung der Schnittstelle erfogt durch Setzen des Funktionsnamens im Attribut.
- Optional kann ein Reading:Value Regex als Argument angegeben werden. Wird kein Regex
- angegeben, werden alle Wertekombinationen als "wahr" gewertet (entspricht .*:.*).
-
- Beispiel: userExitFn UserFunction .*:.*
-
- $name - der Name des DbRep-Devices
- $reading - der Namen des erstellen Readings
- $value - der Wert des Readings
-
-
- valueFilter - Regulärer Ausdruck zur Filterung von Datensätzen innerhalb bestimmter Funktionen. Der
- Regex wird auf ein bestimmtes Feld oder den gesamten selektierten Datensatz (inkl. Device,
- Reading usw.) angewendet.
- Bitte beachten sie die Erläuterungen zu den entsprechenden Set-Kommandos. Readings
-
-
- Abhängig von der ausgeführten DB-Operation werden die Ergebnisse in entsprechenden Readings dargestellt. Zu Beginn einer neuen Operation
- werden alle alten Readings einer vorangegangenen Operation gelöscht um den Verbleib unpassender bzw. ungültiger Readings zu vermeiden.
-
- state - enthält den aktuellen Status der Auswertung. Wenn Warnungen auftraten (state = Warning) vergleiche Readings
- "diff_overrun_limit_<diffLimit>" und "less_data_in_period" errortext - Grund eines Fehlerstatus background_processing_time - die gesamte Prozesszeit die im Hintergrund/Blockingcall verbraucht wird diff_overrun_limit_<diffLimit> - enthält eine Liste der Wertepaare die eine durch das Attribut "diffAccept" festgelegte Differenz
- <diffLimit> (Standard: 20) überschreiten. Gilt für Funktion "diffValue". less_data_in_period - enthält eine Liste der Zeitperioden in denen nur ein einziger Datensatz gefunden wurde. Die
- Differenzberechnung berücksichtigt den letzten Wert der Vorperiode. Gilt für Funktion "diffValue". sql_processing_time - der Anteil der Prozesszeit die für alle SQL-Statements der ausgeführten
- Operation verbraucht wird SqlResult - Ergebnis des letzten sqlCmd-Kommandos. Die Formatierung erfolgt entsprechend
- des Attributes "sqlResultFormat" sqlCmd - das letzte ausgeführte sqlCmd-Kommando
-
-DbRep Agent - automatisches Ändern von Device-Namen in Datenbanken und DbRep-Definitionen nach FHEM "rename" Kommando
-
-
- Mit dem Attribut "role" wird die Rolle des DbRep-Device festgelegt. Die Standardrolle ist "Client". Mit der Änderung der Rolle in "Agent" wird das Device
- veranlasst auf Umbenennungen von Geräten in der FHEM Installation zu reagieren.
- in der dem DbRep-Agenten zugeordneten Datenbank (Internal Database) wird nach Datensätzen mit dem alten Gerätenamen gesucht und dieser Gerätename in
- allen betroffenen Datensätzen in den neuen Namen geändert. in dem DbRep-Agenten zugeordneten DbLog-Device wird in der Definition das alte durch das umbenannte Device ersetzt. Dadurch erfolgt ein weiteres Logging
- des umbenannten Device in der Datenbank. in den existierenden DbRep-Definitionen vom Typ "Client" wird ein evtl. gesetztes Attribut "device = alter Devicename" in "device = neuer Devicename"
- geändert. Dadurch werden Auswertungsdefinitionen bei Geräteumbenennungen automatisch konstistent gehalten.
- es kann nur einen Agenten pro Datenbank in der FHEM-Installation geben. Ist mehr als eine Datenbank mit DbLog definiert, können
- ebenso viele DbRep-Agenten eingerichtet werden mit der Umwandlung in einen Agenten wird nur noch das Set-Komando "renameDevice" verfügbar sein sowie nur ein eingeschränkter Satz von DbRep-spezifischen
- Attributen zugelassen. Wird ein DbRep-Device vom bisherigen Typ "Client" in einen Agenten geändert, werden evtl. gesetzte und nun nicht mehr zugelassene
- Attribute glöscht.
- Beispiel für die Definition eines DbRep-Device als Agent:
- define Rep.Agent DbRep LogDB
-
-
- Hinweis:
-
-=end html_DE
-=cu
\ No newline at end of file
![](\"$FW_ME/www/images/sscam/black_btn_CAMBLANK.png\"){kind=spacer}
"; # nicht sichtbare Leertaste
+ my $cmdstop = "cmd=set $d stopView"; # Stream deaktivieren
+ my $imgstop = "![](\"$FW_ME/www/images/default/remotecontrol/black_btn_POWEROFF3.png\")
";
+ my $cmdhlsreact = "cmd=set $d hlsreactivate"; # HLS Stream reaktivieren
+ my $imghlsreact = "![](\"$FW_ME/www/images/default/remotecontrol/black_btn_BACKDroid.png\")
";
+ my $cmdmjpegrun = "cmd=set $d runView live_fw"; # MJPEG Stream aktivieren
+ my $imgmjpegrun = "![](\"$FW_ME/www/images/sscam/black_btn_MJPEG.png\")
";
+ my $cmdhlsrun = "cmd=set $d runView live_fw_hls"; # HLS Stream aktivieren
+ my $imghlsrun = "![](\"$FW_ME/www/images/sscam/black_btn_HLS.png\")
";
+ my $cmdlrirun = "cmd=set $d runView lastrec_fw"; # Last Record IFrame
+ my $imglrirun = "![](\"$FW_ME/www/images/sscam/black_btn_LASTRECIFRAME.png\")
";
+ my $cmdlh264run = "cmd=set $d runView lastrec_fw_MPEG4/H.264"; # Last Record H.264
+ my $imglh264run = "![](\"$FW_ME/www/images/sscam/black_btn_LRECH264.png\")
";
+ my $cmdlmjpegrun = "cmd=set $d runView lastrec_fw_MJPEG"; # Last Record MJPEG
+ my $imglmjpegrun = "![](\"$FW_ME/www/images/sscam/black_btn_LRECMJPEG.png\")
";
+ my $cmdlsnaprun = "cmd=set $d runView lastsnap_fw STRM"; # Last SNAP
+ my $imglsnaprun = "![](\"$FW_ME/www/images/sscam/black_btn_LSNAP.png\")
";
+ my $cmdrecendless = "cmd=set $d on 0"; # Endlosaufnahme Start
+ my $imgrecendless = "![](\"$FW_ME/www/images/sscam/black_btn_RECSTART.png\")
";
+ my $cmdrecstop = "cmd=set $d off"; # Aufnahme Stop
+ my $imgrecstop = "![](\"$FW_ME/www/images/sscam/black_btn_RECSTOP.png\")
";
+ my $cmddosnap = "cmd=set $d snap STRM"; # Snapshot auslösen mit Kennzeichnung "by STRM-Device"
+ my $imgdosnap = "![](\"$FW_ME/www/images/sscam/black_btn_DOSNAP.png\")
";
+
+
+ my $attr = AttrVal($d, "htmlattr", " ");
+ Log3($name, 4, "$name - SSCam_FWsummaryFn called - FW_wname: $FW_wname, device: $d, room: $room, attributes: $attr");
+
+ if($wltype eq "image") {
+ $ret = "