9231 lines
269 KiB
PHP
Executable File
9231 lines
269 KiB
PHP
Executable File
<?php
|
|
|
|
include_once( "kd_einsprungspunkte.php" );
|
|
include_once( "w_fkt.php" );
|
|
|
|
|
|
|
|
|
|
function liefere_konfig_2( $mandant_name, $parameter )
|
|
{
|
|
$ok = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok[0] > 0 )
|
|
{
|
|
$STATEMENT = "select wert from ca_konfig where lower( einstellung ) = '".mb_strtolower( $parameter, "UTF-8" )."' and mandant_id = ".$ok[ 0 ];
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] <> -1 )
|
|
{
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
$wert = $ergebnis[ 1 ][ 0 ][ "wert" ];
|
|
$rc = 0;
|
|
$meldung = "Liefere zum Parameter >".$parameter."< den Wert >".$wert."<.";
|
|
}
|
|
else
|
|
{
|
|
$wert = "";
|
|
$rc = -1;
|
|
$meldung = "Der Parameter >".$parameter."< wurde nicht gefunden.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$wert = "";
|
|
$rc = -2;
|
|
$meldung = "Es ist ein Fehler aufgetreten: '".$ergebnis[ 1 ]."'.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok[ 0 ];
|
|
$meldung = $ok[ 1 ];
|
|
}
|
|
|
|
xlog( 6, "__wfl.liefere_konfig: ".$meldung );
|
|
|
|
return array( $rc, $meldung, $wert );
|
|
}
|
|
|
|
function liefere_konfig_3( $mandant_name, $parameter )
|
|
{
|
|
$ok = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok[0] > 0 )
|
|
{
|
|
$STATEMENT = "select wert, beschreibung, einstellung, wertemenge, kategorie from ca_konfig where lower( einstellung ) = '".mb_strtolower( $parameter, "UTF-8" )."' and mandant_id = ".$ok[ 0 ];
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] <> -1 )
|
|
{
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
$einstellung_arr[ "wert" ] = $ergebnis[ 1 ][ 0 ][ "wert" ];
|
|
$einstellung_arr[ "beschreibung" ] = $ergebnis[ 1 ][ 0 ][ "beschreibung" ];
|
|
$einstellung_arr[ "einstellung" ] = $ergebnis[ 1 ][ 0 ][ "einstellung" ];
|
|
$einstellung_arr[ "wertemenge" ] = $ergebnis[ 1 ][ 0 ][ "wertemenge" ];
|
|
$einstellung_arr[ "kategorie" ] = $ergebnis[ 1 ][ 0 ][ "kategorie" ];
|
|
$rc = 0;
|
|
$meldung = "Liefere Konfiguration zum Parameter >".$parameter."<.";
|
|
}
|
|
else
|
|
{
|
|
$wert = "";
|
|
$rc = -1;
|
|
$meldung = "Der Parameter >".$parameter."< wurde nicht gefunden.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$wert = "";
|
|
$rc = -2;
|
|
$meldung = "Es ist ein Fehler aufgetreten: '".$ergebnis[ 1 ]."'.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok[ 0 ];
|
|
$meldung = $ok[ 1 ];
|
|
}
|
|
|
|
xlog( 6, "__wfl.liefere_konfig: ".$meldung );
|
|
|
|
return array( $rc, $meldung, $einstellung_arr );
|
|
}
|
|
|
|
function liefere_konfig( $mandant_name, $parameter )
|
|
{
|
|
$ok = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok[ 0 ] > 0 )
|
|
{
|
|
$STATEMENT = "select wert from ca_konfig where lower(einstellung) = '".mb_strtolower( $parameter, "UTF-8" )."' and mandant_id = ".$ok[ 0 ];
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
$wert = $ergebnis[ 1 ][ 0 ][ "wert" ];
|
|
$rc = 0;
|
|
$meldung = "Liefere zum Parameter >".$parameter."< den Wert >".$wert."<.";
|
|
}
|
|
else
|
|
{
|
|
$wert = "";
|
|
$rc = -1;
|
|
$meldung = "Der Parameter >".$parameter."< wurde nicht gefunden.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok[ 0 ];
|
|
$meldung = $ok[ 1 ];
|
|
}
|
|
|
|
xlog( 6, "__wfl.liefere_konfig: RC ".$rc." Meldung: ".$meldung );
|
|
|
|
return $wert;
|
|
}
|
|
|
|
function erstelle_konfig( $mandant_name, $parameter, $kategorie, $wert = "", $wertemenge = "", $beschreibung = "" )
|
|
{
|
|
$exekutor = $_SESSION[ "benutzer_anmeldename" ];
|
|
$ok = existiert_mandant( $mandant_name );
|
|
$connection = mysqli_connect( "localhost", "ca_db", "ca_db", "ca_system" );
|
|
|
|
if ( $ok[ 0 ] > 0 )
|
|
{
|
|
if ( strlen( $parameter ) > 0 )
|
|
{
|
|
if ( strlen( $kategorie ) > 0 )
|
|
{
|
|
$existiert = liefere_konfig_2( $mandant_name, $parameter );
|
|
|
|
if ( $existiert[ 0 ] < 0 )
|
|
{
|
|
if ( mb_strtoupper( $exekutor, "UTF-8" ) == "SUPERUSER" )
|
|
{
|
|
$exec[ 0 ] = 1;
|
|
}
|
|
else
|
|
{
|
|
$exec = besitzt_benutzer_systemrecht( $mandant_name, $exekutor, "ADMINISTRATOR" );
|
|
}
|
|
|
|
if ( $exec[ 0 ] == 1 )
|
|
{
|
|
$parameter = mb_strtolower( $parameter, "UTF-8" );
|
|
$kategorie = mb_strtolower( $kategorie, "UTF-8" );
|
|
|
|
$STATEMENT = "insert into ca_konfig ( wertemenge, mandant_id, einstellung, kategorie, wert, beschreibung ) values ( '".mysqli_real_escape_string( $connection, $wertemenge )."', ".mysqli_real_escape_string( $connection, $ok[ 0 ] ).", '".mysqli_real_escape_string( $connection, $parameter )."', '".mysqli_real_escape_string( $connection, $kategorie )."', '".mysqli_real_escape_string( $connection, $wert )."', '".mysqli_real_escape_string( $connection, $beschreibung )."' )";
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] <> -1 )
|
|
{
|
|
$rc = 0;
|
|
$meldung = "Die Konfigurationsoption >".$parameter."< wurde für den Mandanten >".$ok[ 0 ]."< erstellt.";
|
|
}
|
|
else
|
|
{
|
|
$rc = -5;
|
|
$meldung = "Es ist ein Fehler aufgetreten: '".$ergebnis[ 1 ]."'.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -12;
|
|
$meldung = "Der Benutzer >".$exekutor."< verfügt nicht über ausreichende Berechtigungen.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -4;
|
|
$meldung = "Die Konfigurationsoption >".$parameter."< existiert bereits.";
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = -3;
|
|
$meldung = "Es wurde keine Kategorie angegeben.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -2;
|
|
$meldung = "Es wurde kein Parameter angegeben.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok[ 0 ];
|
|
$meldung = $ok[ 1 ];
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
mysqli_close( $connection );
|
|
|
|
xlog( $level, "__wfl.erstelle_konfig: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung );
|
|
|
|
}
|
|
|
|
function aktualisiere_konfig( $mandant_name, $parameter, $wert, $kategorie = "", $beschreibung = "" )
|
|
{
|
|
$exekutor = $_SESSION[ "benutzer_anmeldename" ];
|
|
$connection = mysqli_connect( "localhost", "ca_db", "ca_db", "ca_system" );
|
|
|
|
$ok = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok[ 0 ] > 0 )
|
|
{
|
|
if ( strlen( $parameter ) > 0 )
|
|
{
|
|
|
|
$existiert = liefere_konfig_2( $mandant_name, $parameter );
|
|
|
|
if ( $existiert[ 0 ] == 0 )
|
|
{
|
|
if ( mb_strtoupper( $exekutor, "UTF-8" ) == "SUPERUSER" )
|
|
{
|
|
$exec[ 0 ] = 1;
|
|
}
|
|
else
|
|
{
|
|
$exec = besitzt_benutzer_systemrecht( $mandant_name, $exekutor, "ADMINISTRATOR" );
|
|
}
|
|
|
|
if ( $exec[ 0 ] == 1 )
|
|
{
|
|
$parameter = mb_strtolower( $parameter, "UTF-8" );
|
|
$kategorie = mb_strtolower( $kategorie, "UTF-8" );
|
|
|
|
if ( strlen( $kategorie ) > 0 )
|
|
{
|
|
$kate_sql = ", kategorie = '".mysqli_real_escape_string( $connection, $kategorie )."'";
|
|
}
|
|
else
|
|
{
|
|
$kate_sql = "";
|
|
}
|
|
|
|
if ( strlen( $beschreibung ) > 0 )
|
|
{
|
|
$besch_sql = ", beschreibung = '".mysqli_real_escape_string( $connection, $beschreibung )."'";
|
|
}
|
|
else
|
|
{
|
|
$besch_sql = "";
|
|
}
|
|
|
|
$esc_wert = mysqli_real_escape_string( $connection, $wert );
|
|
|
|
$STATEMENT = "insert into ca_konfig_history (aenderungszeitpunkt_ts, benutzer_anmeldename, beschreibung, einstellung, kategorie, mandant_id, wertemenge_alt, wertemenge_neu, wert_alt, wert_neu ) values ( '".time()."', '".$exekutor."', '".$beschreibung."', '".$parameter."', '".$kategorie."', ".$ok[ 0 ].", '', '', '".$existiert[ 2 ]."', '".$esc_wert."' );";
|
|
|
|
//xlog( 4, $STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
$STATEMENT = "update ca_konfig set wert='".$esc_wert."' ".$kate_sql.$besch_sql." where mandant_id = ".$ok[ 0 ]." and einstellung = '".mysqli_real_escape_string( $connection, $parameter )."'";
|
|
|
|
//xlog( 4, $STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] <> -1 )
|
|
{
|
|
$rc = 0;
|
|
$meldung = "Die Konfigurationsoption >".$parameter."< wurde für den Mandanten ".$mandant_name." auf den Wert >".$wert."< geändert.";
|
|
}
|
|
else
|
|
{
|
|
$rc = -5;
|
|
$meldung = "Es ist ein Fehler aufgetreten: '".$ergebnis[ 1 ]."'.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -12;
|
|
$meldung = "Der Benutzer >".$exekutor."< verfügt nicht über ausreichende Berechtigungen.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -4;
|
|
$meldung = "Die Konfigurationsoption >".$parameter."< existiert bereits.";
|
|
}
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = -2;
|
|
$meldung = "Es wurde kein Parameter angegeben.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok[ 0 ];
|
|
$meldung = $ok[ 1 ];
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
mysqli_close( $connection );
|
|
|
|
xlog( $level, "__wfl.aktualisiere_konfig: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung );
|
|
|
|
}
|
|
|
|
function liefere_anzahl_zeichen( $anzahl, $zeichen )
|
|
{
|
|
/****************
|
|
BESCHREIBUNG_____liefert die angegebene Anzahl des angegebenen Zeichens
|
|
RETURNS_____String
|
|
****************/
|
|
$temp = "";
|
|
for( $i = 1; $i <= $anzahl; $i++ )
|
|
{
|
|
$temp = $temp.$zeichen;
|
|
}
|
|
return $temp;
|
|
}
|
|
|
|
function datum2mysql( $date )
|
|
{
|
|
/****************
|
|
BESCHREIBUNG_____Konvertiert ein Datum (dd.mm.yyyy) in mysql-Format
|
|
RETURNS_____String: Formatiertes Datum
|
|
****************/
|
|
if ( strlen( $date ) > 0 )
|
|
{
|
|
$array = explode(".",$date);
|
|
$date=$array[2].'-'.$array[1].'-'.$array[0];
|
|
}
|
|
else
|
|
{
|
|
|
|
}
|
|
|
|
return $date;
|
|
}
|
|
|
|
function mysql2datum( $date )
|
|
{
|
|
/****************
|
|
BESCHREIBUNG_____Konvertiert ein Datum in mysql-Format nach (dd.mm.yyyy)
|
|
RETURNS_____String: Formatiertes Datum
|
|
****************/
|
|
//xlog( 4, 'datum '.$date );
|
|
if ( $date <> null )
|
|
{
|
|
$array = explode("-",$date);
|
|
$date=$array[2].'.'.$array[1].'.'.$array[0];
|
|
|
|
if ( strlen( str_replace( ".", "", str_replace( "0", "", $date ) ) ) == 0 )
|
|
{
|
|
$date = "";
|
|
}
|
|
else
|
|
{
|
|
// Datum ist gefüllt
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$date = "";
|
|
}
|
|
return $date;
|
|
}
|
|
|
|
function liefere_zufaelligen_string( $laenge=25 )
|
|
{
|
|
/***************
|
|
BESCHREIBUNG_____Genaugenommen liefert diese Funktion nicht einen Dateinamen, sondern einfach einen zufälligen String, dessen Länge man angeben kann.
|
|
RETURNS_____String mit der Länge $laenge
|
|
***************/
|
|
|
|
if ( ( strlen( $laenge ) == 0 ) or ( $laenge <= 0 ) )
|
|
{
|
|
$laenge = 25;
|
|
}
|
|
|
|
$aZ09 = array_merge( range( 'A', 'Z' ), range( 'a', 'z' ),range( 0, 9 ) );
|
|
|
|
$string = "";
|
|
|
|
for( $c = 0 ; $c < $laenge ; $c++ )
|
|
{
|
|
$string = $string.$aZ09[ mt_rand( 0 , count( $aZ09 ) - 1 ) ];
|
|
}
|
|
|
|
return $string;
|
|
|
|
}
|
|
|
|
function mb_str_replace($needle, $replacement, $haystack)
|
|
{
|
|
$needle_len = mb_strlen($needle);
|
|
$replacement_len = mb_strlen($replacement);
|
|
$pos = mb_strpos($haystack, $needle);
|
|
while ($pos !== false)
|
|
{
|
|
$haystack = mb_substr($haystack, 0, $pos) . $replacement
|
|
. mb_substr($haystack, $pos + $needle_len);
|
|
$pos = mb_strpos($haystack, $needle, $pos + $replacement_len);
|
|
}
|
|
return $haystack;
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
Wertemengen
|
|
*/
|
|
|
|
function liefere_alle_wertemengen_kuerzel( $mandant_name )
|
|
{
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
$kuerzel = array();
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
$STATEMENT = "select kuerzel, bezeichnung from ca_wertemenge where mandant_id = ".$ok_1[ 0 ]." order by bezeichnung";
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
foreach ( $ergebnis[ 1 ] as $zeile )
|
|
{
|
|
$kuerzel[ ] = (string)$zeile[ "kuerzel" ];
|
|
}
|
|
}
|
|
|
|
$rc = count( $kuerzel );
|
|
$meldung = "Liefere ".$rc." Wertemengen des Mandants ".$mandant_name.".";
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = $ok_1[ 1 ];
|
|
}
|
|
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.liefere_alle_wertemengen_kuerzel: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung, $kuerzel );
|
|
}
|
|
|
|
function liefere_alle_wertemengen( $mandant_name )
|
|
{
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
$wertemengen = array();
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
$STATEMENT = "select kuerzel, bezeichnung, beschreibung from ca_wertemenge where mandant_id = ".$ok_1[ 0 ]." order by bezeichnung";
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
foreach( $ergebnis[ 1 ] as $zeile )
|
|
{
|
|
$wertemengen[ ] = array( "kuerzel"=>(string)$zeile[ "kuerzel" ], "bezeichnung"=>(string)$zeile[ "bezeichnung" ], "beschreibung"=>(string)$zeile[ "beschreibung" ] );
|
|
}
|
|
}
|
|
|
|
$rc = count( $wertemengen );
|
|
$meldung = "Liefere ".$rc." Wertemengen des Mandants ".$mandant_name.".";
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = $ok_1[ 1 ];
|
|
}
|
|
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.liefere_alle_wertemengen_kuerzel: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung, $wertemengen );
|
|
}
|
|
|
|
function liefere_wertemenge( $mandant_name, $kuerzel )
|
|
{
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
|
|
//xlog( 5, "encoding: ".mb_detect_encoding ( $kuerzel ) );
|
|
|
|
$wertemengen = array();
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
$kuerzel = mb_strtolower( $kuerzel, "UTF-8" );
|
|
|
|
$ok_2 = existiert_wertemenge( $mandant_name, $kuerzel );
|
|
|
|
if ( $ok_2[ 0 ] > 0 )
|
|
{
|
|
$STATEMENT = "select kategorie, bezeichnung_text_01, bezeichnung_geld_01, bezeichnung_geld_03, bezeichnung_geld_02, bezeichnung_num_01, bezeichnung_num_02, bezeichnung_num_03, bezeichnung_datum_01, bezeichnung_datum_02, bezeichnung_datum_03, bezeichnung_alpha_01, bezeichnung_alpha_02, bezeichnung_alpha_03, bezeichnung_alpha_04, bezeichnung_alpha_05, bezeichnung_alpha_06, bezeichnung_alpha_07, bezeichnung_alpha_08, bezeichnung_alpha_09, bezeichnung_alpha_10, bezeichnung_alpha_11, bezeichnung_alpha_12, bezeichnung_alpha_13, bezeichnung_alpha_14, bezeichnung_alpha_15, bezeichnung_alpha_16, bezeichnung_alpha_17, bezeichnung_alpha_18, bezeichnung_alpha_19, bezeichnung_alpha_20, bezeichnung_alpha_21, bezeichnung_alpha_22, bezeichnung_alpha_23, bezeichnung_alpha_24, bezeichnung_alpha_25, bezeichnung_alpha_26, bezeichnung_alpha_27, bezeichnung_alpha_28, bezeichnung_alpha_29, bezeichnung_alpha_30, kuerzel, erstellt_am, konfig, typ, bezeichnung, beschreibung from ca_wertemenge where mandant_id = ".$ok_1[ 0 ]." and kuerzel = '".$kuerzel."'";
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
|
|
if ( $ergebnis[ 0 ] <> -1 )
|
|
{
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
$wertemenge = $ergebnis[ 1 ][ 0 ];
|
|
|
|
$j = 0;
|
|
|
|
foreach( $wertemenge as $key=>$value )
|
|
{
|
|
if ( substr( $key, 0, 12 ) == "bezeichnung_" )
|
|
{
|
|
if ( strlen( $value ) > 0 )
|
|
{
|
|
$j = bcadd( $j, 1, 0 );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
$ergebnis_array = array( "anzahl_felder"=>(string)$j, "kategorie"=>(string)$wertemenge[ "kategorie" ], "bezeichnung_alpha_01"=>(string)$wertemenge[ "bezeichnung_alpha_01" ], "bezeichnung_alpha_02"=>(string)$wertemenge[ "bezeichnung_alpha_02" ], "bezeichnung_alpha_03"=>(string)$wertemenge[ "bezeichnung_alpha_03" ], "bezeichnung_alpha_04"=>(string)$wertemenge[ "bezeichnung_alpha_04" ], "bezeichnung_alpha_05"=>(string)$wertemenge[ "bezeichnung_alpha_05" ], "bezeichnung_alpha_06"=>(string)$wertemenge[ "bezeichnung_alpha_06" ], "bezeichnung_alpha_07"=>(string)$wertemenge[ "bezeichnung_alpha_07" ], "bezeichnung_alpha_08"=>(string)$wertemenge[ "bezeichnung_alpha_08" ], "bezeichnung_alpha_09"=>(string)$wertemenge[ "bezeichnung_alpha_09" ], "bezeichnung_alpha_10"=>(string)$wertemenge[ "bezeichnung_alpha_10" ], "bezeichnung_alpha_11"=>(string)$wertemenge[ "bezeichnung_alpha_11" ], "bezeichnung_alpha_12"=>(string)$wertemenge[ "bezeichnung_alpha_12" ], "bezeichnung_alpha_13"=>(string)$wertemenge[ "bezeichnung_alpha_13" ], "bezeichnung_alpha_14"=>(string)$wertemenge[ "bezeichnung_alpha_14" ], "bezeichnung_alpha_15"=>(string)$wertemenge[ "bezeichnung_alpha_15" ], "bezeichnung_alpha_16"=>(string)$wertemenge[ "bezeichnung_alpha_16" ], "bezeichnung_alpha_17"=>(string)$wertemenge[ "bezeichnung_alpha_17" ], "bezeichnung_alpha_18"=>(string)$wertemenge[ "bezeichnung_alpha_18" ], "bezeichnung_alpha_19"=>(string)$wertemenge[ "bezeichnung_alpha_19" ], "bezeichnung_alpha_20"=>(string)$wertemenge[ "bezeichnung_alpha_20" ], "bezeichnung_alpha_21"=>(string)$wertemenge[ "bezeichnung_alpha_21" ], "bezeichnung_alpha_22"=>(string)$wertemenge[ "bezeichnung_alpha_22" ], "bezeichnung_alpha_23"=>(string)$wertemenge[ "bezeichnung_alpha_23" ], "bezeichnung_alpha_24"=>(string)$wertemenge[ "bezeichnung_alpha_24" ], "bezeichnung_alpha_25"=>(string)$wertemenge[ "bezeichnung_alpha_25" ], "bezeichnung_alpha_26"=>(string)$wertemenge[ "bezeichnung_alpha_26" ], "bezeichnung_alpha_27"=>(string)$wertemenge[ "bezeichnung_alpha_27" ], "bezeichnung_alpha_28"=>(string)$wertemenge[ "bezeichnung_alpha_28" ], "bezeichnung_alpha_29"=>(string)$wertemenge[ "bezeichnung_alpha_29" ], "bezeichnung_alpha_30"=>(string)$wertemenge[ "bezeichnung_alpha_30" ], "bezeichnung_geld_01"=>(string)$wertemenge[ "bezeichnung_geld_01" ], "bezeichnung_geld_02"=>(string)$wertemenge[ "bezeichnung_geld_02" ], "bezeichnung_geld_03"=>(string)$wertemenge[ "bezeichnung_geld_03" ], "bezeichnung_num_01"=>(string)$wertemenge[ "bezeichnung_num_01" ], "bezeichnung_num_02"=>(string)$wertemenge[ "bezeichnung_num_02" ], "bezeichnung_num_03"=>(string)$wertemenge[ "bezeichnung_num_03" ], "bezeichnung_datum_01"=>(string)$wertemenge[ "bezeichnung_datum_01" ], "bezeichnung_datum_02"=>(string)$wertemenge[ "bezeichnung_datum_02" ], "bezeichnung_datum_03"=>(string)$wertemenge[ "bezeichnung_datum_03" ], "bezeichnung_text_01"=>(string)$wertemenge[ "bezeichnung_text_01" ], "erstellt_am"=>(string)$wertemenge[ "erstellt_am" ], "konfig"=>(string)$wertemenge[ "konfig" ], "typ"=>(string)$wertemenge[ "typ" ], "kuerzel"=>(string)$wertemenge[ "kuerzel" ], "bezeichnung"=>(string)$wertemenge[ "bezeichnung" ], "beschreibung"=>( (string)$wertemenge[ "beschreibung" ] ) );
|
|
|
|
$STATEMENT = "select count(*) calbers from ca_wertemenge_elemente where mandant_id = ".$ok_1[ 0 ]." and kuerzel = '".$kuerzel."'";
|
|
|
|
|
|
|
|
$ergebnis_1 = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis_1[ 0 ] > 0 )
|
|
{
|
|
$rc = $ergebnis_1[ 1 ][ 0 ][ "calbers" ];
|
|
|
|
$ergebnis_array[ "anzahl_elemente" ] = $rc;
|
|
|
|
$meldung = "Liefere Informationen über die Wertemenge >".$kuerzel."< aus dem Mandanten ".$mandant_name.".";
|
|
}
|
|
else
|
|
{
|
|
$rc = -3;
|
|
$meldung = "Beim Feststellen der Anzahl der Wertemengenelemente ist ein Fehler aufgetreten.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// darf nicht auftreten, da schon mit $ok_2 abgefangen
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -2;
|
|
$meldung = "Es ist ein Fehler aufgetreten: '".$sql_ok."'.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -1;
|
|
$meldung = "Die Wertemenge >".$kuerzel."< existiert nicht im Mandanten ".$mandant_name.".";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = $ok_1[ 1 ];
|
|
}
|
|
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
//xlog( $level, "__wfl.liefere_wertemenge: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung, $ergebnis_array );
|
|
}
|
|
|
|
function liefere_wertemenge_elemente( $mandant_name, $kuerzel )
|
|
{
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
$wertemenge = array();
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
$kuerzel = mb_strtolower( $kuerzel, "UTF-8" );
|
|
|
|
$ok_2 = liefere_wertemenge( $mandant_name, $kuerzel );
|
|
|
|
if ( $ok_2[ 0 ] >= 0 )
|
|
{
|
|
switch( $ok_2[ 2 ][ "typ" ] )
|
|
{
|
|
case "static":
|
|
|
|
$STATEMENT = "select element_id, kuerzel, alpha_01, alpha_02, alpha_03, alpha_04, alpha_05, alpha_06, alpha_07, alpha_08, alpha_09, alpha_10, alpha_11, alpha_12, alpha_13, alpha_14, alpha_15, alpha_16, alpha_17, alpha_18, alpha_19, alpha_20, alpha_21, alpha_22, alpha_23, alpha_24, alpha_25, alpha_26, alpha_27, alpha_28, alpha_29, alpha_30, geld_01, geld_02, geld_03, datum_01, datum_02, datum_03, num_01, num_02, num_03, text_01 from ca_wertemenge_elemente where mandant_id = ".$ok_1[ 0 ]." and kuerzel = '".$kuerzel."'";
|
|
//xlog( 4, $STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
//var_dump( $ergebnis[ 0 ] );
|
|
|
|
if ( bccomp( $ergebnis[ 0 ], 0 ) >= 0 )
|
|
{
|
|
if ( bccomp( $ergebnis[ 0 ], 0 ) > 0 )
|
|
{
|
|
foreach( $ergebnis[ 1 ] as $zeile )
|
|
{
|
|
$wertemenge[ ] = array( "element_id"=>(string)$zeile[ "element_id" ], "kuerzel"=>(string)$zeile[ "kuerzel" ], "alpha_01"=>(string)$zeile[ "alpha_01" ], "alpha_02"=>(string)$zeile[ "alpha_02" ], "alpha_03"=>(string)$zeile[ "alpha_03" ], "alpha_04"=>(string)$zeile[ "alpha_04" ], "alpha_05"=>(string)$zeile[ "alpha_05" ], "alpha_06"=>(string)$zeile[ "alpha_06" ], "alpha_07"=>(string)$zeile[ "alpha_07" ], "alpha_08"=>(string)$zeile[ "alpha_08" ], "alpha_09"=>(string)$zeile[ "alpha_09" ], "alpha_10"=>(string)$zeile[ "alpha_10" ], "alpha_11"=>(string)$zeile[ "alpha_11" ], "alpha_12"=>(string)$zeile[ "alpha_12" ], "alpha_13"=>(string)$zeile[ "alpha_13" ], "alpha_14"=>(string)$zeile[ "alpha_14" ], "alpha_15"=>(string)$zeile[ "alpha_15" ], "alpha_16"=>(string)$zeile[ "alpha_16" ], "alpha_17"=>(string)$zeile[ "alpha_17" ], "alpha_18"=>(string)$zeile[ "alpha_18" ], "alpha_19"=>(string)$zeile[ "alpha_19" ], "alpha_20"=>(string)$zeile[ "alpha_20" ], "alpha_21"=>(string)$zeile[ "alpha_21" ], "alpha_22"=>(string)$zeile[ "alpha_22" ], "alpha_23"=>(string)$zeile[ "alpha_23" ], "alpha_24"=>(string)$zeile[ "alpha_24" ], "alpha_25"=>(string)$zeile[ "alpha_25" ], "alpha_26"=>(string)$zeile[ "alpha_26" ], "alpha_27"=>(string)$zeile[ "alpha_27" ], "alpha_28"=>(string)$zeile[ "alpha_28" ], "alpha_29"=>(string)$zeile[ "alpha_29" ], "alpha_30"=>(string)$zeile[ "alpha_30" ], "num_01"=>(string)$zeile[ "num_01" ], "num_02"=>(string)$zeile[ "num_02" ], "num_03"=>(string)$zeile[ "num_03" ], "geld_01"=>(string)$zeile[ "geld_01" ], "geld_02"=>(string)$zeile[ "geld_02" ], "geld_03"=>(string)$zeile[ "geld_03" ], "datum_01"=>(string)mysql2datum( $zeile[ "datum_01" ] ), "datum_02"=>(string)mysql2datum( $zeile[ "datum_02" ] ), "datum_03"=>(string)mysql2datum( $zeile[ "datum_03" ] ), "text_01"=>(string)$zeile[ "text_01" ] );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//xlog( 4, "kein element hinzugefügt");
|
|
}
|
|
$rc = count( $wertemenge );
|
|
$meldung = "Liefere ".$rc." Elemente der Wertemenge >".$kuerzel."<.";
|
|
}
|
|
else
|
|
{
|
|
$rc = -2;
|
|
$meldung = "Es ist ein Fehler aufgetreten: '".$ergebnis[ 1 ]."'.";
|
|
}
|
|
break;
|
|
case "local_sql":
|
|
|
|
$STATEMENT = $ok_2[ 2 ][ "konfig" ];
|
|
|
|
//$mandant = liefere_mandant( $mandant_name );
|
|
|
|
$STATEMENT = str_replace( "##mandant_id##", $ok_1[ 0 ], $STATEMENT );
|
|
|
|
|
|
xlog( 6, "__wfl.liefere_wertemenge_elemente: ".$STATEMENT );
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( bccomp( $ergebnis[ 0 ], 0 ) >= 0 )
|
|
{
|
|
if ( bccomp( $ergebnis[ 0 ], 0 ) > 0 )
|
|
{
|
|
foreach( $ergebnis[ 1 ] as $zeile )
|
|
{
|
|
$i = 0;
|
|
$erg_arr = array();
|
|
foreach ( $zeile as $feld=>$wert )
|
|
{
|
|
$i++;
|
|
//xlog( 4, "alpha_".liefere_anzahl_zeichen( 2 - strlen( $i ), "0" ).$i );
|
|
//xlog( 4, $wert );
|
|
$erg_arr[ "alpha_".liefere_anzahl_zeichen( 2 - strlen( $i ), "0" ).$i ] = $wert;
|
|
//xlog( 4, $wertemenge[ "alpha_".liefere_anzahl_zeichen( 2 - strlen( $i ), "0" ).$i ] );
|
|
|
|
}
|
|
$wertemenge[ ] = $erg_arr;
|
|
//$wertemenge[ ] = array( "element_id"=>(string)$zeile[ "element_id" ], "kuerzel"=>(string)$zeile[ "kuerzel" ], "alpha_01"=>(string)$zeile[ "alpha_01" ], "alpha_02"=>(string)$zeile[ "alpha_02" ], "alpha_03"=>(string)$zeile[ "alpha_03" ], "alpha_04"=>(string)$zeile[ "alpha_04" ], "alpha_05"=>(string)$zeile[ "alpha_05" ], "alpha_06"=>(string)$zeile[ "alpha_06" ], "alpha_07"=>(string)$zeile[ "alpha_07" ], "alpha_08"=>(string)$zeile[ "alpha_08" ], "alpha_09"=>(string)$zeile[ "alpha_09" ], "alpha_10"=>(string)$zeile[ "alpha_10" ], "alpha_11"=>(string)$zeile[ "alpha_11" ], "alpha_12"=>(string)$zeile[ "alpha_12" ], "alpha_13"=>(string)$zeile[ "alpha_13" ], "alpha_14"=>(string)$zeile[ "alpha_14" ], "alpha_15"=>(string)$zeile[ "alpha_15" ], "alpha_16"=>(string)$zeile[ "alpha_16" ], "alpha_17"=>(string)$zeile[ "alpha_17" ], "alpha_18"=>(string)$zeile[ "alpha_18" ], "alpha_19"=>(string)$zeile[ "alpha_19" ], "alpha_20"=>(string)$zeile[ "alpha_20" ], "alpha_21"=>(string)$zeile[ "alpha_21" ], "alpha_22"=>(string)$zeile[ "alpha_22" ], "alpha_23"=>(string)$zeile[ "alpha_23" ], "alpha_24"=>(string)$zeile[ "alpha_24" ], "alpha_25"=>(string)$zeile[ "alpha_25" ], "alpha_26"=>(string)$zeile[ "alpha_26" ], "alpha_27"=>(string)$zeile[ "alpha_27" ], "alpha_28"=>(string)$zeile[ "alpha_28" ], "alpha_29"=>(string)$zeile[ "alpha_29" ], "alpha_30"=>(string)$zeile[ "alpha_30" ], "num_01"=>(string)$zeile[ "num_01" ], "num_02"=>(string)$zeile[ "num_02" ], "num_03"=>(string)$zeile[ "num_03" ], "geld_01"=>(string)$zeile[ "geld_01" ], "geld_02"=>(string)$zeile[ "geld_02" ], "geld_03"=>(string)$zeile[ "geld_03" ], "datum_01"=>(string)mysql2datum( $zeile[ "datum_01" ] ), "datum_02"=>(string)mysql2datum( $zeile[ "datum_02" ] ), "datum_03"=>(string)mysql2datum( $zeile[ "datum_03" ] ), "text_01"=>(string)$zeile[ "text_01" ] );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//xlog( 4, "kein element hinzugefügt");
|
|
}
|
|
$rc = count( $wertemenge );
|
|
$meldung = "Liefere ".$rc." Elemente der Wertemenge >".$kuerzel."<.";
|
|
}
|
|
else
|
|
{
|
|
$rc = -2;
|
|
$meldung = "Es ist ein Fehler aufgetreten: '".$ergebnis[ 1 ]."'.";
|
|
}
|
|
break;
|
|
case "number":
|
|
$konfig = $ok_2[ 2 ][ "konfig" ];
|
|
|
|
$konfig = explode( "|", $konfig );
|
|
|
|
if ( mb_strlen( $konfig[ 1 ], "utf-8" ) > 0 )
|
|
{
|
|
$step = $konfig[ 1 ];
|
|
}
|
|
else
|
|
{
|
|
$step = 1;
|
|
}
|
|
|
|
$konfig_2 = explode( "-", $konfig[ 0 ] );
|
|
|
|
//xlog( 4, $konfig_2[ 0 ] );
|
|
//xlog( 4, $konfig_2[ 1 ] );
|
|
|
|
for ( $i = $konfig_2[ 0 ]; $i <= $konfig_2[ 1 ]; $i = $i + $step )
|
|
{
|
|
$wertemenge[ ] = array( "alpha_01"=>$i );
|
|
//xlog( 4, $i );
|
|
}
|
|
|
|
$rc = count( $wertemenge );
|
|
$meldung = "Liefere ".$rc." Elemente der Wertemenge >".$kuerzel."<.";
|
|
|
|
break;
|
|
case "character":
|
|
|
|
$konfig = $ok_2[ 2 ][ "konfig" ];
|
|
|
|
$klein = array( "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z" );
|
|
|
|
$gross = array( "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" );
|
|
|
|
$konfig = explode( "|", $konfig );
|
|
|
|
$step = $konfig[ 1 ];
|
|
$grossklein = $konfig[ 2 ];
|
|
$konfig_2 = explode( "-", $konfig[ 0 ] );
|
|
|
|
foreach ( $klein as $key=>$buchstabe )
|
|
{
|
|
if ( $buchstabe == mb_strtolower( $konfig_2[ 0 ], "utf-8" ) )
|
|
{
|
|
$startelement = $key;
|
|
}
|
|
if ( $buchstabe == mb_strtolower( $konfig_2[ 1 ], "utf-8" ) )
|
|
{
|
|
$endeelement = $key;
|
|
}
|
|
}
|
|
|
|
|
|
if ( $grossklein == "g" )
|
|
{
|
|
for ( $i = $startelement; $i <= $endeelement; $i = $i + $step )
|
|
{
|
|
$wertemenge[ ] = array( "alpha_01"=>$gross[ $i ] );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for ( $i = $startelement; $i <= $endeelement; $i = $i + $step )
|
|
{
|
|
$wertemenge[ ] = array( "alpha_01"=>$klein[ $i ] );
|
|
}
|
|
}
|
|
|
|
$rc = count( $wertemenge );
|
|
$meldung = "Liefere ".$rc." Elemente der Wertemenge >".$kuerzel."<.";
|
|
|
|
|
|
break;
|
|
case "local_directory":
|
|
|
|
$konfig = $ok_2[ 2 ][ "konfig" ];
|
|
$konfig = explode( "|", $konfig );
|
|
$pfad = getenv("DOCUMENT_ROOT")."/".$konfig[ 0 ];
|
|
$suchtext = $konfig[ 1 ];
|
|
$inkl_pfad = $konfig[ 2 ];
|
|
|
|
$ergebnis = scandir( $pfad );
|
|
|
|
if ( $inkl_pfad == "j" )
|
|
{
|
|
$pfadangabe = $pfad."/";
|
|
}
|
|
else
|
|
{
|
|
$pfadangabe = "";
|
|
}
|
|
|
|
foreach ( $ergebnis as $file )
|
|
{
|
|
$gefunden = strpos( $file, $suchtext );
|
|
if ( $gefunden !== false )
|
|
{
|
|
//xlog( 4, "File ".$file );
|
|
|
|
$wertemenge[ ] = array( "alpha_01"=>$pfadangabe.$file, "alpha_02"=>$pfad."/" );
|
|
}
|
|
}
|
|
|
|
$rc = count( $wertemenge );
|
|
$meldung = "Liefere ".$rc." Elemente der Wertemenge >".$kuerzel."<.";
|
|
|
|
break;
|
|
case "local_file":
|
|
|
|
$konfig = $ok_2[ 2 ][ "konfig" ];
|
|
$konfig = explode( "|", $konfig );
|
|
|
|
$datei = getenv("DOCUMENT_ROOT")."/".$konfig[ 0 ];
|
|
$trenner = $konfig[ 1 ];
|
|
|
|
$wertemenge = array();
|
|
|
|
if ( file_exists( $datei ) )
|
|
{
|
|
$handle = fopen( $datei, "r" );
|
|
|
|
while ( ! feof( $handle ) )
|
|
{
|
|
$buffer = fgets( $handle );
|
|
$zeile = explode( $trenner, $buffer );
|
|
|
|
// $anzahl = count( $zeile );
|
|
|
|
$i = 1;
|
|
|
|
foreach( $zeile as $element )
|
|
{
|
|
$erg[ "alpha_".liefere_anzahl_zeichen( 2 - strlen( $i ), "0" ).$i ] = str_replace( "\n", "", $element );
|
|
$i++;
|
|
}
|
|
|
|
$wertemenge[ ] = $erg;
|
|
|
|
}
|
|
|
|
fclose ($handle);
|
|
}
|
|
$rc = count( $wertemenge );
|
|
$meldung = "Liefere ".$rc." Elemente der Wertemenge >".$kuerzel."<.";
|
|
|
|
break;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = -1;
|
|
$meldung = "Die Wertemenge >".$kuerzel."< existiert nicht im Mandanten ".$mandant_name.".";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = $ok_1[ 1 ];
|
|
}
|
|
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 6;
|
|
}
|
|
|
|
xlog( $level, "__wfl.liefere_wertemenge_elemente: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung, $wertemenge );
|
|
|
|
}
|
|
|
|
function wertemenge_anlegen( $mandant_name, $kuerzel, $typ, $konfig, $bezeichnung, $kategorie = "system", $beschreibung = "", $feld_bezeichnungen = array(), $werte = array() )
|
|
{
|
|
$exekutor = $_SESSION[ "benutzer_anmeldename" ];
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
$connection = mysqli_connect( "localhost", "ca_db", "ca_db", "ca_system" );
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
$kuerzel = mb_strtolower( $kuerzel, "UTF-8" );
|
|
//xlog( 4, "exec ".$exekutor );
|
|
/*
|
|
mb_regex_encoding( "UTF-8" );
|
|
|
|
$regex_kuerzel = true;
|
|
|
|
$regex_kuerzel = mb_ereg_match( "/[\;]/", $kuerzel ); // /[\!\"\§\$\%\&\\\,\.\ \?\:\;\/\(\)\=\*\#\'\{\}\[\]\~\|]/
|
|
|
|
if ( $regex_kuerzel == false )
|
|
{*/
|
|
$ok_2 = existiert_wertemenge( $mandant_name, $kuerzel );
|
|
|
|
if ( $ok_2[ 0 ] == 0 )
|
|
{
|
|
if ( mb_strtoupper( $exekutor, "UTF-8" ) == "SUPERUSER" )
|
|
{
|
|
$exec[ 0 ] = 1;
|
|
}
|
|
else
|
|
{
|
|
$exec = besitzt_benutzer_systemrecht( $mandant_name, $exekutor, "ADMINISTRATOR" );
|
|
}
|
|
|
|
if ( $exec[ 0 ] == 1 )
|
|
{
|
|
if ( strlen( $bezeichnung ) > 0 )
|
|
{
|
|
$konfig_erforderlich = true;
|
|
switch ( $typ )
|
|
{
|
|
case "static":
|
|
$konfig_erforderlich = false;
|
|
case "local_sql":
|
|
case "local_file":
|
|
case "local_directory":
|
|
case "number":
|
|
case "character":
|
|
|
|
if ( $konfig_erforderlich )
|
|
{
|
|
if ( strlen( $konfig ) == 0 )
|
|
{
|
|
$rc = -4;
|
|
$meldung = "Für den Typ >".$typ."< ist die Angabe einer Konfiguration erforderlich.";
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*xlog( 4, "eingabe kürzel (".$kuerzel.") : ".mb_detect_encoding( $kuerzel ) );
|
|
xlog( 4, "eingabe bezeichnung (".$bezeichnung."): ".mb_detect_encoding( $bezeichnung ) );
|
|
xlog( 4, "eingabe konfig: ".mb_detect_encoding( $konfig ) );
|
|
xlog( 4, "eingabe typ : ".mb_detect_encoding( $typ ) );
|
|
*/
|
|
$STATEMENT = "insert into ca_wertemenge ( kategorie, erstellt_am, typ, konfig, mandant_id, kuerzel, bezeichnung, beschreibung, ";
|
|
$values = "'".$kategorie."',
|
|
'".time()."',
|
|
'".mysqli_real_escape_string( $connection, $typ )."',
|
|
'".mysqli_real_escape_string( $connection, $konfig )."',
|
|
".$ok_1[ 0 ].",
|
|
'".mysqli_real_escape_string( $connection, $kuerzel )."',
|
|
'".mysqli_real_escape_string( $connection, $bezeichnung )."',
|
|
'".mysqli_real_escape_string( $connection, $beschreibung )."', ";
|
|
|
|
|
|
foreach ( $feld_bezeichnungen as $feld=>$bezeichnung )
|
|
{
|
|
if ( strlen( $bezeichnung ) > 0 )
|
|
{
|
|
//xlog(4, $feld."=>".$bezeichnung );
|
|
$STATEMENT = $STATEMENT." ".$feld.", ";
|
|
$values = $values." '".mysqli_real_escape_string( $connection, $bezeichnung )."', ";
|
|
}
|
|
}
|
|
|
|
$STATEMENT = substr( $STATEMENT, 0, -2 )." ) values ( ".substr( $values, 0, -2 )." )";
|
|
|
|
//xlog( 4, "wertemenge_anlegen: ".$STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] <> -1 )
|
|
{
|
|
$flag = false;
|
|
|
|
if ( ( is_array( $werte ) ) and ( count( $werte ) > 0 ) )
|
|
{
|
|
|
|
|
|
foreach ( $werte as $zeile )
|
|
{
|
|
$STATEMENT = "insert into ca_wertemenge_elemente ( mandant_id, kuerzel, ";
|
|
$values = "( ".$ok_1[ 0 ].", '".mysqli_real_escape_string( $connection, mb_strtolower( $kuerzel, "UTF-8" ) )."', ";
|
|
|
|
foreach( $zeile as $feld=>$wert )
|
|
{
|
|
|
|
/*xlog( 4, $zeile );
|
|
xlog( 4, $feld );
|
|
xlog( 4, $wert );
|
|
*/
|
|
$feld_arr = explode( "_", $feld );
|
|
|
|
$feld_arr[ 0 ] = mb_strtolower( $feld_arr[ 0 ], "UTF-8" );
|
|
|
|
//xlog( 4, "feld_arr".$feld_arr[ 0 ] );
|
|
|
|
switch ( $feld_arr[ 0 ] )
|
|
{
|
|
case "alpha":
|
|
case "geld":
|
|
case "num":
|
|
case "text":
|
|
$STATEMENT = $STATEMENT." ".$feld.", ";
|
|
$values = $values." '".mysqli_real_escape_string( $connection, $wert )."', ";
|
|
break;
|
|
case "datum":
|
|
$STATEMENT = $STATEMENT." ".$feld.", ";
|
|
$values = $values." '".mysqli_real_escape_string( $connection, datum2mysql( $wert ) )."', ";
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
$STATEMENT = substr( $STATEMENT, 0, -2 )." ) values ".substr( $values, 0, -2 )." )";
|
|
|
|
//xlog( 4, $STATEMENT );
|
|
|
|
$ergebnis_1 = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis_1[ 0 ] == -1 )
|
|
{
|
|
$flag = $true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( $flag )
|
|
{
|
|
$ergaenzung = "Es ist ein Fehler beim Einfügen eines Wertemengen-Elements aufgetreten: '".$sql_ok."'.";
|
|
}
|
|
else
|
|
{
|
|
$ergaenzung = " Es wurden ".count( $werte )." Wertemengenelemente eingefügt.";
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$ergaenzung = " Es wurden keine Wertemengen-Elemente übergeben.";
|
|
}
|
|
|
|
if ( $flag )
|
|
{
|
|
$rc = -2;
|
|
$meldung = "Beim Anlegen der Wertemenge >".$kuerzel."< im Mandanten >".$mandant_name."< ist ein Fehler aufgetreten: >".$ergaenzung."'.";
|
|
}
|
|
else
|
|
{
|
|
$rc = 1;
|
|
$meldung = "Die Wertemenge >".$kuerzel."< wurde im Mandanten >".$mandant_name."< angelegt.".$ergaenzung;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = -1;
|
|
$meldung = "Es ist ein Fehler aufgetreten: '".$sql_ok."'.";
|
|
}
|
|
break;
|
|
default:
|
|
$rc = -3;
|
|
$meldung = "Es wurde kein gültiger Wertemengen-Typ (".$typ.") angegeben.";
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -5;
|
|
$meldung = "Es wurde keine Bezeichnung angegeben.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -12;
|
|
$meldung = "Der Benutzer >".$exekutor."< verfügt nicht über ausreichende Berechtigungen.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_2[ 0 ];
|
|
$meldung = $ok_2[ 1 ];
|
|
}
|
|
/*
|
|
}
|
|
else
|
|
{
|
|
$rc = -6;
|
|
$meldung = "Im Kürzel einer Wertemenge sind Sonderzeichen nicht erlaubt.";
|
|
}
|
|
*/
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = $ok_1[ 1 ];
|
|
}
|
|
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
mysqli_close( $connection );
|
|
|
|
xlog( $level, "__wfl.wertemenge_anlegen: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung );
|
|
}
|
|
|
|
function wertemenge_aendern( $mandant_name, $wertemenge_kuerzel, $typ, $konfig, $bezeichnung, $beschreibung, $kategorie = "system", $feldbezeichnungen=array( ) )
|
|
{
|
|
$exekutor = $_SESSION[ "benutzer_anmeldename" ];
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
$connection = mysqli_connect( "localhost", "ca_db", "ca_db", "ca_system" );
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
$wertemenge_kuerzel = mb_strtolower( $wertemenge_kuerzel, "UTF-8" );
|
|
|
|
$ok_2 = existiert_wertemenge( $mandant_name, $wertemenge_kuerzel );
|
|
|
|
if ( $ok_2[ 0 ] > 0 )
|
|
{
|
|
if ( mb_strtoupper( $exekutor, "UTF-8" ) == "SUPERUSER" )
|
|
{
|
|
$exec[ 0 ] = 1;
|
|
}
|
|
else
|
|
{
|
|
$exec = besitzt_benutzer_systemrecht( $mandant_name, $exekutor, "ADMINISTRATOR" );
|
|
}
|
|
|
|
if ( $exec[ 0 ] == 1 )
|
|
{
|
|
$STATEMENT = "update ca_wertemenge set typ='".mysqli_real_escape_string( $connection, $typ )."', konfig='".mysqli_real_escape_string( $connection, $konfig )."', bezeichnung='".mysqli_real_escape_string( $connection, $bezeichnung )."', beschreibung='".mysqli_real_escape_string( $connection, $beschreibung )."', kategorie='".mysqli_real_escape_string( $connection, $kategorie )."' ";
|
|
|
|
if ( count( $feldbezeichnungen ) > 0 )
|
|
{
|
|
foreach( $feldbezeichnungen as $feld=>$wert )
|
|
{
|
|
$STATEMENT = $STATEMENT.", ".$feld." = '".mysqli_real_escape_string( $connection, $wert )."' ";
|
|
}
|
|
}
|
|
|
|
$STATEMENT = $STATEMENT." where mandant_id = ".$ok_1[ 0 ]." and kuerzel = '".mysqli_real_escape_string( $connection, $wertemenge_kuerzel )."'";
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
//xlog( 4, $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] <> -1 )
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = "Die Wertemenge ".$wertemenge_kuerzel." im Mandant >".$mandant_name."< (ID ".$ok_1[ 0 ].") wurde geändert.";
|
|
}
|
|
else
|
|
{
|
|
$rc = -3;
|
|
$meldung = "Es ist ein Problem aufgetreten: '".$ergebnis[ 1 ]."'.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -12;
|
|
$meldung = "Der Benutzer >".$exekutor."< verfügt nicht über ausreichende Berechtigungen.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_2[ 0 ];
|
|
$meldung = $ok_2[ 1 ];
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = $ok_1[ 1 ];
|
|
}
|
|
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
mysqli_close( $connection );
|
|
|
|
xlog( $level, "__wfl.wertemenge_aendern: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung );
|
|
}
|
|
|
|
function existiert_wertemenge( $mandant_name, $kuerzel )
|
|
{
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
//xlog(4, "Kürzel 1: ".$kuerzel );
|
|
$kuerzel = mb_strtolower( $kuerzel, "UTF-8" );
|
|
//xlog(4, "Kürzel 2: ".$kuerzel );
|
|
if ( strlen( $kuerzel ) > 0 )
|
|
{
|
|
$STATEMENT = "select count(*) calbers from ca_wertemenge where mandant_id = ".$ok_1[ 0 ]." and kuerzel = '".$kuerzel."'";
|
|
//xlog( 4, $STATEMENT );
|
|
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
//xlog( 4, " String: ".$ergebnis[ 1 ][ 0 ] );
|
|
$anzahl = $ergebnis[ 1 ][ 0 ][ "calbers" ];
|
|
|
|
if ( bccomp( $anzahl , 0 ) > 0 )
|
|
{
|
|
$rc = 1;
|
|
$meldung = "Die Wertemenge >".mb_strtolower( $kuerzel, "UTF-8" )."< existiert.";
|
|
}
|
|
else
|
|
{
|
|
$rc = 0;
|
|
$meldung = "Die Wertemenge >".mb_strtolower( $kuerzel, "UTF-8" )."< existiert nicht.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -1;
|
|
$meldung = "Es wurde kein Kürzel angegeben.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = $ok_1[ 1 ];
|
|
}
|
|
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 6;
|
|
}
|
|
|
|
xlog( $level, "__wfl.existiert_wertemenge: RC ".$rc.": ".$meldung );
|
|
|
|
return array( $rc, $meldung );
|
|
}
|
|
|
|
function wertemenge_loeschen( $mandant_name, $kuerzel )
|
|
{
|
|
$exekutor = $_SESSION[ "benutzer_anmeldename" ];
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
|
|
$kuerzel = mb_strtolower( $kuerzel, "UTF-8" );
|
|
|
|
$ok_2 = existiert_wertemenge( $mandant_name, $kuerzel );
|
|
|
|
if ( $ok_2[ 0 ] > 0 )
|
|
{
|
|
if ( mb_strtoupper( $exekutor, "UTF-8" ) == "SUPERUSER" )
|
|
{
|
|
$exec[ 0 ] = 1;
|
|
}
|
|
else
|
|
{
|
|
$exec = besitzt_benutzer_systemrecht( $mandant_name, $exekutor, "ADMINISTRATOR" );
|
|
}
|
|
|
|
if ( $exec[ 0 ] == 1 )
|
|
{
|
|
$STATEMENT = "delete from ca_wertemenge_elemente where kuerzel = '".$kuerzel."' and mandant_id = ".$ok_1[ 0 ];
|
|
//xlog( 4, "wertemenge_loeschen: ".$STATEMENT );
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] <> -1 )
|
|
{
|
|
$STATEMENT = "delete from ca_wertemenge where kuerzel = '".$kuerzel."' and mandant_id = ".$ok_1[ 0 ];
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] <> -1 )
|
|
{
|
|
$rc = 1;
|
|
$meldung = "Die Wertemenge >".$kuerzel."< wurde im Mandanten >".$mandant_name."< entfernt.";
|
|
}
|
|
else
|
|
{
|
|
$rc = -1;
|
|
$meldung = "Es ist ein Fehler beim Entfernen der Wertemenge aufgetreten: '".$sql_ok."'.";
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = -1;
|
|
$meldung = "Es ist ein Fehler beim Entfernen der Wertemengenelemente aufgetreten: '".$sql_ok."'.";
|
|
}
|
|
}
|
|
else
|
|
{}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_2[ 0 ];
|
|
$meldung = "Es ist ein Fehler aufgetreten: '".$ok_2[ 1 ]."'";
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = $ok_1[ 1 ];
|
|
}
|
|
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.wertemenge_loeschen: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung );
|
|
|
|
}
|
|
|
|
function wertemengen_element_loeschen( $mandant_name, $kuerzel, $element_id )
|
|
{
|
|
$exekutor = $_SESSION[ "benutzer_anmeldename" ];
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
$kuerzel = mb_strtolower( $kuerzel, "UTF-8" );
|
|
$ok_2 = liefere_wertemenge( $mandant_name, $kuerzel );
|
|
|
|
if ( $ok_2[ 0 ] >= 0 )
|
|
{
|
|
if ( mb_strtoupper( $exekutor, "UTF-8" ) == "SUPERUSER" )
|
|
{
|
|
$exec[ 0 ] = 1;
|
|
}
|
|
else
|
|
{
|
|
$exec = besitzt_benutzer_systemrecht( $mandant_name, $exekutor, "ADMINISTRATOR" );
|
|
}
|
|
|
|
if ( $exec[ 0 ] == 1 )
|
|
{
|
|
$STATEMENT = "select count(*) calbers from ca_wertemenge_elemente where mandant_id = ".$ok_1[ 0 ]." and kuerzel = '".$kuerzel."' and element_id = ".$element_id;
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] <> -1 )
|
|
{
|
|
$anzahl = $ergebnis[ 0 ];
|
|
|
|
if ( $anzahl > 0 )
|
|
{
|
|
$STATEMENT = "delete from ca_wertemenge_elemente where element_id = ".$element_id;
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] <> -1 )
|
|
{
|
|
$rc = 1;
|
|
$meldung = "Das Wertemengenelement ".$element_id." der Wertemenge >".$kuerzel."< wurde im Mandanten ".$mandant_name." gelöscht.";
|
|
}
|
|
else
|
|
{
|
|
$rc = -3;
|
|
$meldung = "Es ist ein Fehler aufgetreten: '".$sql_ok."'.";
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = -2;
|
|
$meldung = "Das Element kommt im Mandanten ".$mandant_name." nicht in der Wertemenge >".$kuerzel."< vor.";
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = -1;
|
|
$meldung = "Es ist ein Fehler aufgetreten: '".$sql_ok."'.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -12;
|
|
$meldung = "Der Benutzer >".$exekutor."< verfügt nicht über ausreichende Berechtigungen.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_2[ 0 ];
|
|
$meldung = "Es ist ein Fehler aufgetreten: '".$ok_2[ 1 ]."'.";
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = $ok_1[ 1 ];
|
|
}
|
|
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.wertemengen_element_loeschen: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung );
|
|
|
|
}
|
|
|
|
function wertemengen_element_hinzufuegen( $mandant_name, $kuerzel, $element = array() )
|
|
{
|
|
|
|
/*
|
|
Das Array "element" hat folgenden Aufbau:
|
|
|
|
element[ "alpha_01" ] = "wert";
|
|
element[ "alpha_02" ] = "wert";
|
|
element[ "alpha_03" ] = "wert";
|
|
element[ "num_01" ] = 4712;
|
|
und so weiter. Nicht gefüllte Felder werden nicht belegt.
|
|
|
|
*/
|
|
|
|
$exekutor = $_SESSION[ "benutzer_anmeldename" ];
|
|
$connection = mysqli_connect( "localhost", "ca_db", "ca_db", "ca_system" );
|
|
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
$kuerzel = mb_strtolower( $kuerzel, "UTF-8" );
|
|
$ok_2 = liefere_wertemenge( $mandant_name, $kuerzel );
|
|
|
|
if ( $ok_2[ 0 ] >= 0 )
|
|
{
|
|
if ( mb_strtoupper( $exekutor, "UTF-8" ) == "SUPERUSER" )
|
|
{
|
|
$exec[ 0 ] = 1;
|
|
}
|
|
else
|
|
{
|
|
$exec = besitzt_benutzer_systemrecht( $mandant_name, $exekutor, "ADMINISTRATOR" );
|
|
}
|
|
|
|
if ( $exec[ 0 ] == 1 )
|
|
{
|
|
$STATEMENT = "insert into ca_wertemenge_elemente ( mandant_id, kuerzel, ";
|
|
$values = "( ".$ok_1[ 0 ].", '".mysqli_real_escape_string( $connection, $kuerzel )."', ";
|
|
|
|
foreach( $element as $feld=>$wert )
|
|
{
|
|
$STATEMENT = $STATEMENT." ".$feld.", ";
|
|
|
|
$feld_arr = explode( "_", $feld );
|
|
|
|
$feld_arr[ 0 ] = mb_strtolower( $feld_arr[ 0 ], "UTF-8" );
|
|
|
|
switch ( $feld_arr[ 0 ] )
|
|
{
|
|
case "alpha":
|
|
case "geld":
|
|
case "num":
|
|
case "text":
|
|
$values = $values." '".mysqli_real_escape_string( $connection, $wert )."', ";
|
|
break;
|
|
case "datum":
|
|
$values = $values." '".mysqli_real_escape_string( $connection, datum2mysql( $wert ) )."', ";
|
|
break;
|
|
}
|
|
}
|
|
|
|
$STATEMENT = substr( $STATEMENT, 0, -2 )." ) values ".substr( $values, 0, -2 )." )";
|
|
|
|
//xlog( 4, $STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] <> -1 )
|
|
{
|
|
$rc = $ergebnis[ 0 ];
|
|
$meldung = "In der Wertemenge >".$kuerzel."< wurde im Mandanten ".$mandant_name." ein Element mit der ID ".$rc." angelegt.";
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_2[ 0 ];
|
|
$meldung = "Es ist ein Fehler aufgetreten: '".$ergebnis[ 1 ]."'.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -12;
|
|
$meldung = "Der Benutzer >".$exekutor."< verfügt nicht über ausreichende Berechtigungen.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_2[ 0 ];
|
|
$meldung = "Es ist ein Fehler aufgetreten: '".$ok_2[ 1 ]."'.";
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = $ok_1[ 1 ];
|
|
}
|
|
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
mysqli_close( $connection );
|
|
|
|
xlog( $level, "__wfl.wertemengen_element_hinzufuegen: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung );
|
|
}
|
|
|
|
function wertemengen_element_aendern( $mandant_name, $kuerzel, $element_id, $neue_attribute )
|
|
{
|
|
/*
|
|
Das Array "element" hat folgenden Aufbau:
|
|
|
|
element[ "alpha_01" ] = "wert";
|
|
element[ "alpha_02" ] = "wert";
|
|
element[ "alpha_03" ] = "wert";
|
|
element[ "num_01" ] = 4712;
|
|
und so weiter. Nicht gefüllte Felder werden nicht belegt.
|
|
|
|
*/
|
|
|
|
$exekutor = $_SESSION[ "benutzer_anmeldename" ];
|
|
$connection = mysqli_connect( "localhost", "ca_db", "ca_db", "ca_system" );
|
|
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
$kuerzel = mb_strtolower( $kuerzel, "UTF-8" );
|
|
$ok_2 = liefere_wertemenge( $mandant_name, $kuerzel );
|
|
|
|
if ( $ok_2[ 0 ] >= 0 )
|
|
{
|
|
if ( count( $neue_attribute ) > 0 )
|
|
{
|
|
if ( mb_strtoupper( $exekutor, "UTF-8" ) == "SUPERUSER" )
|
|
{
|
|
$exec[ 0 ] = 1;
|
|
}
|
|
else
|
|
{
|
|
$exec = besitzt_benutzer_systemrecht( $mandant_name, $exekutor, "ADMINISTRATOR" );
|
|
}
|
|
|
|
if ( $exec[ 0 ] == 1 )
|
|
{
|
|
$STATEMENT = "update ca_wertemenge_elemente set ";
|
|
|
|
foreach( $neue_attribute as $feld=>$wert )
|
|
{
|
|
|
|
$feld_arr = explode( "_", $feld );
|
|
|
|
$feld_arr[ 0 ] = mb_strtolower( $feld_arr[ 0 ], "UTF-8" );
|
|
|
|
switch ( $feld_arr[ 0 ] )
|
|
{
|
|
case "alpha":
|
|
case "geld":
|
|
case "num":
|
|
case "text":
|
|
$value = " '".mysqli_real_escape_string( $connection, $wert )."'";
|
|
break;
|
|
case "datum":
|
|
$value = " '".mysqli_real_escape_string( $connection, datum2mysql( $wert ) )."'";
|
|
break;
|
|
}
|
|
$STATEMENT = $STATEMENT." ".$feld." = ".$value.", ";
|
|
}
|
|
|
|
$STATEMENT = substr( $STATEMENT, 0, -2 )." where element_id = ".$element_id." and kuerzel = '".$kuerzel."' and mandant_id = ".$ok_1[ 0 ];
|
|
|
|
//xlog( 4, $STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] <> -1 )
|
|
{
|
|
$rc = $element_id;
|
|
$meldung = "In der Wertemenge >".$kuerzel."< wurde im Mandanten ".$mandant_name." das Element mit der ID ".$rc." geändert.";
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_2[ 0 ];
|
|
$meldung = "Es ist ein Fehler aufgetreten: '".$ergebnis[ 1 ]."'.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -12;
|
|
$meldung = "Der Benutzer >".$exekutor."< verfügt nicht über ausreichende Berechtigungen.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -1;
|
|
$meldung = "Es wurden keine neuen Attribute angegeben.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_2[ 0 ];
|
|
$meldung = "Es ist ein Fehler aufgetreten: '".$ok_2[ 1 ]."'.";
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = $ok_1[ 1 ];
|
|
}
|
|
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
mysqli_close( $connection );
|
|
|
|
xlog( $level, "__wfl.wertemengen_element_aendern: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung );
|
|
}
|
|
|
|
function wertemengen_element_liefern( $mandant_name, $kuerzel, $element_id )
|
|
{
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
$kuerzel = mb_strtolower( $kuerzel, "UTF-8" );
|
|
$ok_2 = liefere_wertemenge( $mandant_name, $kuerzel );
|
|
|
|
if ( $ok_2[ 0 ] >= 0 )
|
|
{
|
|
if ( strlen( $element_id ) > 0 )
|
|
{
|
|
$STATEMENT = "select element_id, kuerzel, alpha_01, alpha_02, alpha_03, alpha_04, alpha_05, alpha_06, alpha_07, alpha_08, alpha_09, alpha_10, alpha_11, alpha_12, alpha_13, alpha_14, alpha_15, alpha_16, alpha_17, alpha_18, alpha_19, alpha_20, alpha_21, alpha_22, alpha_23, alpha_24, alpha_25, alpha_26, alpha_27, alpha_28, alpha_29, alpha_30, geld_01, geld_02, geld_03, datum_01, datum_02, datum_03, num_01, num_02, num_03, text_01 from ca_wertemenge_elemente where mandant_id = ".$ok_1[ 0 ]." and kuerzel = '".$kuerzel."' and element_id = ".$element_id;
|
|
|
|
//xlog( 3, $STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
switch( $ergebnis[ 0 ] )
|
|
{
|
|
case -1:
|
|
$rc = -1;
|
|
$meldung = "Es ist ein Fehler aufgetreten: '".$ergebnis[ 1 ]."'.";
|
|
break;
|
|
case 0:
|
|
$rc = -1;
|
|
$meldung = "Das gewünschte Element wurde nicht gefunden.";
|
|
break;
|
|
case 1:
|
|
$rc = $ergebnis[ 1 ][ 0 ][ "element_id" ];
|
|
$meldung = "Liefere Element ".$ergebnis[ 1 ][ 0 ][ "element_id" ]." aus Wertemenge ".$kuerzel." im Mandanten ".$mandant_name.".";
|
|
|
|
foreach ( $ergebnis[ 1 ][ 0 ] as $key=>$value )
|
|
{
|
|
$key_arr = explode( "_", $key );
|
|
|
|
switch ( $key_arr[ 0 ] )
|
|
{
|
|
case "alpha":
|
|
case "num":
|
|
case "text":
|
|
$wert = $value;
|
|
break;
|
|
case "datum":
|
|
if ( mb_strlen( mb_str_replace( ".", "", mb_str_replace( "0", "", mysql2datum( $value ) ) ) ) > 0 )
|
|
{
|
|
$wert = mysql2datum( $value );
|
|
}
|
|
else
|
|
{
|
|
$wert = "";
|
|
}
|
|
break;
|
|
case "geld":
|
|
if ( mb_strlen( mb_str_replace( ".", "", mb_str_replace( "0", "", $value ) ) ) > 0 )
|
|
{
|
|
$wert = $value;
|
|
}
|
|
else
|
|
{
|
|
$wert = "";
|
|
}
|
|
break;
|
|
}
|
|
|
|
$ergebnis_element[ $key ] = $wert;
|
|
}
|
|
//$ergebnis_element = $ergebnis[ 1 ][ 0 ];
|
|
// so nicht -
|
|
$ergebnis_element[ "mandant_name" ] = $mandant_name;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -3;
|
|
$meldung = "Es wurde keine Element-ID angegeben.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_2[ 0 ];
|
|
$meldung = "Es ist ein Fehler aufgetreten: '".$ok_2[ 1 ]."'.";
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = $ok_1[ 1 ];
|
|
}
|
|
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.wertemengen_element_liefern: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung, $ergebnis_element );
|
|
}
|
|
|
|
function wertemengen_elemente_hinzufuegen( $mandant_name, $kuerzel, $elemente = array() )
|
|
{
|
|
/*
|
|
Das Array "elemente" hat folgenden Aufbau:
|
|
|
|
elemente[ ] = array( "alpha_01" => "wert", "alpha_02" => "wert", "alpha_03" => "wert", "num_01" => 4712 );
|
|
|
|
... enthält also mehrere Arrays, die den gleichen Aufbau haben dürfen. Nicht gefüllte Felder werden nicht belegt.
|
|
|
|
*/
|
|
|
|
$exekutor = $_SESSION[ "benutzer_anmeldename" ];
|
|
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
$kuerzel = mb_strtolower( $kuerzel, "UTF-8" );
|
|
$ok_2 = liefere_wertemenge( $mandant_name, $kuerzel );
|
|
|
|
|
|
if ( $ok_2[ 0 ] >= 0 )
|
|
{
|
|
if ( mb_strtoupper( $exekutor, "UTF-8" ) == "SUPERUSER" )
|
|
{
|
|
$exec[ 0 ] = 1;
|
|
}
|
|
else
|
|
{
|
|
$exec = besitzt_benutzer_systemrecht( $mandant_name, $exekutor, "ADMINISTRATOR" );
|
|
}
|
|
|
|
if ( $exec[ 0 ] == 1 )
|
|
{
|
|
$elementliste = "(";
|
|
$fehler = false;
|
|
|
|
foreach ( $elemente as $element )
|
|
{
|
|
$STATEMENT = "insert into ca_wertemenge_elemente ( mandant_id, kuerzel, ";
|
|
$values = "( ".$ok_1[ 0 ].", '".$kuerzel."', ";
|
|
|
|
foreach( $element as $feld=>$wert )
|
|
{
|
|
$STATEMENT = $STATEMENT." ".$feld.", ";
|
|
|
|
$feld_arr = explode( "_", $feld );
|
|
|
|
$feld_arr[ 0 ] = mb_strtolower( $feld_arr[ 0 ], "UTF-8" );
|
|
|
|
switch ( $feld_arr[ 0 ] )
|
|
{
|
|
case "alpha":
|
|
case "geld":
|
|
case "num":
|
|
case "text":
|
|
$values = $values." '".$wert."', ";
|
|
break;
|
|
case "datum":
|
|
$values = $values." '".datum2mysql( $wert )."', ";
|
|
break;
|
|
}
|
|
|
|
|
|
}
|
|
$STATEMENT = substr( $STATEMENT, 0, -2 )." ) values ".substr( $values, 0, -2 )." )";
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] <> -1 )
|
|
{
|
|
$element_id = $ergebnis[ 0 ];
|
|
$elementliste = $elementliste." ".$element_id.", ";
|
|
}
|
|
else
|
|
{
|
|
$rc = -1;
|
|
$meldung = "Es ist ein Fehler aufgetreten: '".$ergebnis[ 1 ]."'.";
|
|
$fehler = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( $fehler == false )
|
|
{
|
|
$rc = count( $elemente );
|
|
$meldung = "Es wurden ".$rc." Elemente in der Wertemenge >".$kuerzel."< im Mandanten ".$mandant_name." angelegt.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -12;
|
|
$meldung = "Der Benutzer >".$exekutor."< verfügt nicht über ausreichende Berechtigungen.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_2[ 0 ];
|
|
$meldung = "Es ist ein Fehler aufgetreten: '".$ok_2[ 1 ]."'.";
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = $ok_1[ 1 ];
|
|
}
|
|
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.fuege_wertemenge_element_hinzu: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung );
|
|
}
|
|
|
|
function ist_element_in_wertemenge( $mandant_name, $kuerzel, $element )
|
|
{
|
|
/*
|
|
Diese Funktion prüft nur einfache, ein-Tupel-Elemente, d. h. ausschließich, ob das angegebene Element in "alpha_01" der Wertemenge des Mandanten vorkommt.
|
|
Alles andere ist mir jetzt zu kompliziert.
|
|
*/
|
|
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
$kuerzel = mb_strtolower( $kuerzel, "UTF-8" );
|
|
$ok_2 = liefere_wertemenge( $mandant_name, $kuerzel );
|
|
|
|
if ( $ok_2[ 0 ] > 0 )
|
|
{
|
|
$STATEMENT = "select element_id from ca_wertemenge_elemente where mandant_id = ".$ok_1[ 0 ]." and kuerzel = '".$kuerzel."' and alpha_01 = '".$element."'";
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] <> -1 )
|
|
{
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
$rc = $ergebnis[ 1 ][ 0 ][ "element_id" ];
|
|
|
|
$meldung = "Das Element >".$element."< existiert im Mandanten >".$mandant_name."< in der Wertemenge >".$kuerzel."< mit der ID >".$rc."<.";
|
|
}
|
|
else
|
|
{
|
|
$rc = 0;
|
|
$meldung = "Das Element >".$element."< existiert im Mandanten >".$mandant_name."< in der Wertemenge >".$kuerzel."< nicht.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -2;
|
|
$meldung = "Es ist ein Fehler aufgetreten: '".$sql_ok."'.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_2[ 0 ];
|
|
$meldung = "Die Wertemenge hat keine Elemente oder es ist ein Fehler aufgetreten.";
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = $ok_1[ 1 ];
|
|
}
|
|
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 6;
|
|
}
|
|
|
|
xlog( $level, "__wfl.ist_element_in_wertemenge: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung );
|
|
|
|
}
|
|
|
|
function liefere_wertemengen_kategorien( $mandant_name )
|
|
{
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
$STATEMENT = "select distinct kategorie from ca_wertemenge where mandant_id = ".$ok_1[ 0 ]." order by kategorie ";
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
$kategorien = array();
|
|
|
|
if ( $ergebnis[ 0 ] <> -1 )
|
|
{
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
foreach( $ergebnis[ 1 ] as $zeile )
|
|
{
|
|
$kategorien[] = $zeile[ "kategorie" ];
|
|
}
|
|
|
|
$rc = count( $kategorien );
|
|
|
|
$meldung = "Liefere ".$rc." Kategorien aus dem Mandanten ".$mandant_name.".";
|
|
}
|
|
else
|
|
{
|
|
$rc = 0;
|
|
$meldung = "Es wurden keine Kategorien im Mandanten ".$mandant_name." gefunden.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -2;
|
|
$meldung = "Es ist ein Fehler aufgetreten: '".$sql_ok."'.";
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = $ok_1[ 1 ];
|
|
}
|
|
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.liefere_wertemengen_kategorien: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung, $kategorien );
|
|
}
|
|
|
|
function liefere_wertemengen_aus_kategorie( $mandant_name, $kategorie )
|
|
{
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
$STATEMENT = "select distinct kuerzel, bezeichnung from ca_wertemenge where mandant_id = ".$ok_1[ 0 ]." and kategorie = '".$kategorie."' order by bezeichnung";
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
$kuerzel = array();
|
|
|
|
if ( $ergebnis[ 0 ] <> -1 )
|
|
{
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
foreach( $ergebnis[ 1 ] as $zeile )
|
|
{
|
|
$kuerzel[] = $zeile[ "kuerzel" ];
|
|
}
|
|
|
|
$rc = count( $kuerzel );
|
|
|
|
$meldung = "Liefere ".$rc." Wertemengen aus dem Mandanten ".$mandant_name." (Kategorie ".$kategorie.").";
|
|
}
|
|
else
|
|
{
|
|
$rc = 0;
|
|
$meldung = "Es wurden keine Wertemengen im Mandanten ".$mandant_name." in der Kategorie ".$kategorie." gefunden.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -2;
|
|
$meldung = "Es ist ein Fehler aufgetreten: '".$sql_ok."'.";
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = $ok_1[ 1 ];
|
|
}
|
|
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.liefere_wertemengen_kategorien: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung, $kuerzel );
|
|
}
|
|
|
|
function suche_wertemengen_element( $mandant_name, $kuerzel, $suchstring )
|
|
{
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
$kuerzel = mb_strtolower( $kuerzel, "UTF-8" );
|
|
$ok_2 = liefere_wertemenge( $mandant_name, $kuerzel );
|
|
|
|
$wertemenge = array();
|
|
|
|
if ( $ok_2[ 0 ] >= 0 )
|
|
{
|
|
switch( $ok_2[ 2 ][ "typ" ] )
|
|
{
|
|
case "static":
|
|
|
|
if ( strlen( $suchstring ) > 0 )
|
|
{
|
|
$STATEMENT_ERW = " and ( ( alpha_01 like '%".$suchstring."%' ) or ( alpha_02 like '%".$suchstring."%' ) or ( alpha_03 like '%".$suchstring."%' ) or ( alpha_04 like '%".$suchstring."%' ) or ( alpha_05 like '%".$suchstring."%' ) or ( alpha_06 like '%".$suchstring."%' ) or ( alpha_07 like '%".$suchstring."%' ) or ( alpha_08 like '%".$suchstring."%' ) or ( alpha_09 like '%".$suchstring."%' ) or ( alpha_10 like '%".$suchstring."%' ) or ( alpha_11 like '%".$suchstring."%' ) or ( alpha_12 like '%".$suchstring."%' ) or ( alpha_13 like '%".$suchstring."%' ) or ( alpha_14 like '%".$suchstring."%' ) or ( alpha_15 like '%".$suchstring."%' ) or ( alpha_16 like '%".$suchstring."%' ) or ( alpha_17 like '%".$suchstring."%' ) or ( alpha_18 like '%".$suchstring."%' ) or ( alpha_19 like '%".$suchstring."%' ) or ( alpha_20 like '%".$suchstring."%' ) or ( alpha_21 like '%".$suchstring."%' ) or ( alpha_22 like '%".$suchstring."%' ) or ( alpha_23 like '%".$suchstring."%' ) or ( alpha_24 like '%".$suchstring."%' ) or ( alpha_25 like '%".$suchstring."%' ) or ( alpha_26 like '%".$suchstring."%' ) or ( alpha_27 like '%".$suchstring."%' ) or ( alpha_28 like '%".$suchstring."%' ) or ( alpha_29 like '%".$suchstring."%' ) or ( alpha_30 like '%".$suchstring."%' ) ) order by alpha_01, alpha_02, alpha_03, alpha_04, alpha_05;";
|
|
}
|
|
else
|
|
{
|
|
$STATEMENT_ERW = "";
|
|
}
|
|
|
|
$STATEMENT = "select alpha_01, alpha_02, alpha_03, alpha_04, alpha_05, alpha_06, alpha_07, alpha_08, alpha_09, alpha_10, alpha_11, alpha_12, alpha_13, alpha_14, alpha_15, alpha_16, alpha_17, alpha_18, alpha_19, alpha_20, alpha_21, alpha_22, alpha_23, alpha_24, alpha_25, alpha_26, alpha_27, alpha_28, alpha_29, alpha_30, num_01, num_02, num_03, datum_01, datum_02, datum_03, geld_01, geld_02, geld_03, text_01, element_id, mandant_id, kuerzel from ca_wertemenge_elemente where ( kuerzel = '".$kuerzel."' ) and ( mandant_id = ".$ok_1[ 0 ]." ) ".$STATEMENT_ERW;
|
|
//xlog( 4, $STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
//var_dump( $ergebnis[ 0 ] );
|
|
|
|
if ( bccomp( $ergebnis[ 0 ], 0 ) >= 0 )
|
|
{
|
|
if ( bccomp( $ergebnis[ 0 ], 0 ) > 0 )
|
|
{
|
|
foreach( $ergebnis[ 1 ] as $zeile )
|
|
{
|
|
$wertemenge[ ] = array( "element_id"=>(string)$zeile[ "element_id" ], "kuerzel"=>(string)$zeile[ "kuerzel" ], "alpha_01"=>(string)$zeile[ "alpha_01" ], "alpha_02"=>(string)$zeile[ "alpha_02" ], "alpha_03"=>(string)$zeile[ "alpha_03" ], "alpha_04"=>(string)$zeile[ "alpha_04" ], "alpha_05"=>(string)$zeile[ "alpha_05" ], "alpha_06"=>(string)$zeile[ "alpha_06" ], "alpha_07"=>(string)$zeile[ "alpha_07" ], "alpha_08"=>(string)$zeile[ "alpha_08" ], "alpha_09"=>(string)$zeile[ "alpha_09" ], "alpha_10"=>(string)$zeile[ "alpha_10" ], "alpha_11"=>(string)$zeile[ "alpha_11" ], "alpha_12"=>(string)$zeile[ "alpha_12" ], "alpha_13"=>(string)$zeile[ "alpha_13" ], "alpha_14"=>(string)$zeile[ "alpha_14" ], "alpha_15"=>(string)$zeile[ "alpha_15" ], "alpha_16"=>(string)$zeile[ "alpha_16" ], "alpha_17"=>(string)$zeile[ "alpha_17" ], "alpha_18"=>(string)$zeile[ "alpha_18" ], "alpha_19"=>(string)$zeile[ "alpha_19" ], "alpha_20"=>(string)$zeile[ "alpha_20" ], "alpha_21"=>(string)$zeile[ "alpha_21" ], "alpha_22"=>(string)$zeile[ "alpha_22" ], "alpha_23"=>(string)$zeile[ "alpha_23" ], "alpha_24"=>(string)$zeile[ "alpha_24" ], "alpha_25"=>(string)$zeile[ "alpha_25" ], "alpha_26"=>(string)$zeile[ "alpha_26" ], "alpha_27"=>(string)$zeile[ "alpha_27" ], "alpha_28"=>(string)$zeile[ "alpha_28" ], "alpha_29"=>(string)$zeile[ "alpha_29" ], "alpha_30"=>(string)$zeile[ "alpha_30" ], "num_01"=>(string)$zeile[ "num_01" ], "num_02"=>(string)$zeile[ "num_02" ], "num_03"=>(string)$zeile[ "num_03" ], "geld_01"=>(string)$zeile[ "geld_01" ], "geld_02"=>(string)$zeile[ "geld_02" ], "geld_03"=>(string)$zeile[ "geld_03" ], "datum_01"=>(string)mysql2datum( $zeile[ "datum_01" ] ), "datum_02"=>(string)mysql2datum( $zeile[ "datum_02" ] ), "datum_03"=>(string)mysql2datum( $zeile[ "datum_03" ] ), "text_01"=>(string)$zeile[ "text_01" ] );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//xlog( 4, "kein element hinzugefügt");
|
|
}
|
|
$rc = count( $wertemenge );
|
|
$meldung = "Liefere ".$rc." Elemente der Wertemenge >".$kuerzel."<.";
|
|
}
|
|
else
|
|
{
|
|
$rc = -2;
|
|
$meldung = "Es ist ein Fehler aufgetreten: '".$ergebnis[ 1 ]."'.";
|
|
}
|
|
break;
|
|
default:
|
|
$elemente = liefere_wertemenge_elemente( $mandant_name, $kuerzel );
|
|
|
|
if ( strlen( $suchstring ) == 0 )
|
|
{
|
|
$wertemenge = $elemente[ 2 ];
|
|
}
|
|
else
|
|
{
|
|
|
|
if ( $elemente[ 0 ] > 0 )
|
|
{
|
|
foreach( $elemente[ 2 ] as $element )
|
|
{
|
|
if ( strpos( mb_strtoupper( $element[ "alpha_01" ], "UTF-8" ) , mb_strtoupper( $suchstring ) ) !== false )
|
|
{
|
|
$wertemenge[ ] = $element;
|
|
continue;
|
|
}
|
|
if ( strpos( mb_strtoupper( $element[ "alpha_02" ], "UTF-8" ), mb_strtoupper( $suchstring, "UTF-8" ) ) !== false )
|
|
{
|
|
$wertemenge[ ] = $element;
|
|
continue;
|
|
}
|
|
if ( strpos( mb_strtoupper( $element[ "alpha_03" ], "UTF-8" ), mb_strtoupper( $suchstring, "UTF-8" ) ) !== false )
|
|
{
|
|
$wertemenge[ ] = $element;
|
|
continue;
|
|
}
|
|
if ( strpos( mb_strtoupper( $element[ "alpha_04" ], "UTF-8" ), mb_strtoupper( $suchstring, "UTF-8" ) ) !== false )
|
|
{
|
|
$wertemenge[ ] = $element;
|
|
continue;
|
|
}
|
|
if ( strpos( mb_strtoupper( $element[ "alpha_05" ], "UTF-8" ), mb_strtoupper( $suchstring, "UTF-8" ) ) !== false )
|
|
{
|
|
$wertemenge[ ] = $element;
|
|
continue;
|
|
}
|
|
if ( strpos( mb_strtoupper( $element[ "alpha_06" ], "UTF-8" ), mb_strtoupper( $suchstring, "UTF-8" ) ) !== false )
|
|
{
|
|
$wertemenge[ ] = $element;
|
|
continue;
|
|
}
|
|
if ( strpos( mb_strtoupper( $element[ "alpha_07" ], "UTF-8" ), mb_strtoupper( $suchstring, "UTF-8" ) ) !== false )
|
|
{
|
|
$wertemenge[ ] = $element;
|
|
continue;
|
|
}
|
|
if ( strpos( mb_strtoupper( $element[ "alpha_08" ], "UTF-8" ), mb_strtoupper( $suchstring, "UTF-8" ) ) !== false )
|
|
{
|
|
$wertemenge[ ] = $element;
|
|
continue;
|
|
}
|
|
if ( strpos( mb_strtoupper( $element[ "alpha_09" ], "UTF-8" ), mb_strtoupper( $suchstring, "UTF-8" ) ) !== false )
|
|
{
|
|
$wertemenge[ ] = $element;
|
|
continue;
|
|
}
|
|
if ( strpos( mb_strtoupper( $element[ "alpha_10" ], "UTF-8" ), mb_strtoupper( $suchstring, "UTF-8" ) ) !== false )
|
|
{
|
|
$wertemenge[ ] = $element;
|
|
continue;
|
|
}
|
|
if ( strpos( mb_strtoupper( $element[ "alpha_11" ], "UTF-8" ), mb_strtoupper( $suchstring, "UTF-8" ) ) !== false )
|
|
{
|
|
$wertemenge[ ] = $element;
|
|
continue;
|
|
}
|
|
if ( strpos( mb_strtoupper( $element[ "alpha_12" ], "UTF-8" ), mb_strtoupper( $suchstring, "UTF-8" ) ) !== false )
|
|
{
|
|
$wertemenge[ ] = $element;
|
|
continue;
|
|
}
|
|
if ( strpos( mb_strtoupper( $element[ "alpha_13" ], "UTF-8" ), mb_strtoupper( $suchstring, "UTF-8" ) ) !== false )
|
|
{
|
|
$wertemenge[ ] = $element;
|
|
continue;
|
|
}
|
|
if ( strpos( mb_strtoupper( $element[ "alpha_14" ], "UTF-8" ), mb_strtoupper( $suchstring, "UTF-8" ) ) !== false )
|
|
{
|
|
$wertemenge[ ] = $element;
|
|
continue;
|
|
}
|
|
if ( strpos( mb_strtoupper( $element[ "alpha_15" ], "UTF-8" ), mb_strtoupper( $suchstring, "UTF-8" ) ) !== false )
|
|
{
|
|
$wertemenge[ ] = $element;
|
|
continue;
|
|
}
|
|
if ( strpos( mb_strtoupper( $element[ "alpha_16" ], "UTF-8" ), mb_strtoupper( $suchstring, "UTF-8" ) ) !== false )
|
|
{
|
|
$wertemenge[ ] = $element;
|
|
continue;
|
|
}
|
|
if ( strpos( mb_strtoupper( $element[ "alpha_17" ], "UTF-8" ), mb_strtoupper( $suchstring, "UTF-8" ) ) !== false )
|
|
{
|
|
$wertemenge[ ] = $element;
|
|
continue;
|
|
}
|
|
if ( strpos( mb_strtoupper( $element[ "alpha_18" ], "UTF-8" ), mb_strtoupper( $suchstring, "UTF-8" ) ) !== false )
|
|
{
|
|
$wertemenge[ ] = $element;
|
|
continue;
|
|
}
|
|
if ( strpos( mb_strtoupper( $element[ "alpha_19" ], "UTF-8" ), mb_strtoupper( $suchstring, "UTF-8" ) ) !== false )
|
|
{
|
|
$wertemenge[ ] = $element;
|
|
continue;
|
|
}
|
|
if ( strpos( mb_strtoupper( $element[ "alpha_20" ], "UTF-8" ), mb_strtoupper( $suchstring, "UTF-8" ) ) !== false )
|
|
{
|
|
$wertemenge[ ] = $element;
|
|
continue;
|
|
}
|
|
if ( strpos( mb_strtoupper( $element[ "alpha_21" ], "UTF-8" ), mb_strtoupper( $suchstring, "UTF-8" ) ) !== false )
|
|
{
|
|
$wertemenge[ ] = $element;
|
|
continue;
|
|
}
|
|
if ( strpos( mb_strtoupper( $element[ "alpha_22" ], "UTF-8" ), mb_strtoupper( $suchstring, "UTF-8" ) ) !== false )
|
|
{
|
|
$wertemenge[ ] = $element;
|
|
continue;
|
|
}
|
|
if ( strpos( mb_strtoupper( $element[ "alpha_23" ], "UTF-8" ), mb_strtoupper( $suchstring, "UTF-8" ) ) !== false )
|
|
{
|
|
$wertemenge[ ] = $element;
|
|
continue;
|
|
}
|
|
if ( strpos( mb_strtoupper( $element[ "alpha_24" ], "UTF-8" ), mb_strtoupper( $suchstring, "UTF-8" ) ) !== false )
|
|
{
|
|
$wertemenge[ ] = $element;
|
|
continue;
|
|
}
|
|
if ( strpos( mb_strtoupper( $element[ "alpha_25" ], "UTF-8" ), mb_strtoupper( $suchstring, "UTF-8" ) ) !== false )
|
|
{
|
|
$wertemenge[ ] = $element;
|
|
continue;
|
|
}
|
|
if ( strpos( mb_strtoupper( $element[ "alpha_26" ], "UTF-8" ), mb_strtoupper( $suchstring, "UTF-8" ) ) !== false )
|
|
{
|
|
$wertemenge[ ] = $element;
|
|
continue;
|
|
}
|
|
if ( strpos( mb_strtoupper( $element[ "alpha_27" ], "UTF-8" ), mb_strtoupper( $suchstring, "UTF-8" ) ) !== false )
|
|
{
|
|
$wertemenge[ ] = $element;
|
|
continue;
|
|
}
|
|
if ( strpos( mb_strtoupper( $element[ "alpha_28" ], "UTF-8" ), mb_strtoupper( $suchstring, "UTF-8" ) ) !== false )
|
|
{
|
|
$wertemenge[ ] = $element;
|
|
continue;
|
|
}
|
|
if ( strpos( mb_strtoupper( $element[ "alpha_29" ], "UTF-8" ), mb_strtoupper( $suchstring, "UTF-8" ) ) !== false )
|
|
{
|
|
$wertemenge[ ] = $element;
|
|
continue;
|
|
}
|
|
if ( strpos( mb_strtoupper( $element[ "alpha_30" ], "UTF-8" ), mb_strtoupper( $suchstring, "UTF-8" ) ) !== false )
|
|
{
|
|
$wertemenge[ ] = $element;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
$rc = count( $wertemenge );
|
|
$meldung = "Liefere ".$rc." Elemente der Wertemenge >".$kuerzel."<.";
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_2[ 0 ];
|
|
$meldung = "Es ist ein Fehler aufgetreten: '".$ok_2[ 1 ]."'.";
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = $ok_1[ 1 ];
|
|
}
|
|
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.suche_wertemengen_element: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung, $wertemenge );
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function liefere_systemparameter_kategorien( $mandant_name )
|
|
{
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
$kategorien = array();
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
$STATEMENT = "select distinct kategorie from ca_konfig where mandant_id = ".$ok_1[ 0 ]." order by kategorie";
|
|
|
|
//xlog( 4, $STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] >= 0 )
|
|
{
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
foreach( $ergebnis[ 1 ] as $zeile )
|
|
{
|
|
$kategorien[ ] = $zeile[ "kategorie" ];
|
|
}
|
|
|
|
$rc = count( $kategorien );
|
|
$meldung = "Es werden ".$rc." Elemente geliefert.";
|
|
}
|
|
else
|
|
{
|
|
$rc = 0;
|
|
$meldung = "Es wurden keine Konfigurations-Kategorien gefunden. Erstaunlicherweise.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ergebnis[ 0 ];
|
|
$meldung = $ergebnis[ 1 ];
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = $ok_1[ 1 ];
|
|
}
|
|
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.liefere_systemparameter_kategorien: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung, $kategorien );
|
|
}
|
|
|
|
function liefere_einstellungen_anhand_kategorie( $mandant_name, $kategorie )
|
|
{
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
$einstellungen = array();
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
if ( strlen( $kategorie ) > 0 )
|
|
{
|
|
$STATEMENT = "select distinct einstellung from ca_konfig where mandant_id = ".$ok_1[ 0 ]." and kategorie = '".$kategorie."' order by einstellung";
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] >= 0 )
|
|
{
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
foreach ( $ergebnis[ 1 ] as $zeile )
|
|
{
|
|
$einstellungen[ ] = $zeile[ "einstellung" ];
|
|
}
|
|
$rc = count( $einstellungen );
|
|
$meldung = "Liefere ".$rc." Elemente (Mandant: ".$mandant_name.", Kategorie: ".$kategorie.").";
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = 0;
|
|
$meldung = "Es wurden höchst erstaunlicherweise keine Parameter in der Kategorie ".$kategorie." gefunden (Mandant: ".$mandant_name.").";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ergebnis[ 0 ];
|
|
$meldung = $ergebnis[ 1 ];
|
|
}
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = -2;
|
|
$meldung = "Es wurde keine Kategorie angegeben.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = $ok_1[ 1 ];
|
|
}
|
|
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.liefere_systemparameter_anhand_kategorie: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung, $einstellungen );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function erzeuge_kalender( $mandant_name, $monat, $jahr, $benutzer_anmeldename, $liefere_6_zeilen = false )
|
|
{
|
|
/*
|
|
Liefert eine HTML-Tabelle mit einem Monat
|
|
|
|
Aufruf: $monat = "5" => Mai
|
|
$jahr = 2010
|
|
$liefere_6_zeilen => Wenn man mehrere von dieser Funktion generierte Kalender nebeneinander anzeigen will, sollte man immer 6 Wochen liefern lassen, notfalls also auch eine Leerwoche (=> true).
|
|
Andernfalls liegen die Wochen nicht direkt nebeneinander. Wenn man die Kalender übereinander anzeigen will, kann das weggelassen werden (also false).
|
|
*/
|
|
|
|
$style_fuer_alle_zellen = "width:35px; height:15px; text-align:center;font-size:80%;";
|
|
|
|
$style_ueberschrift = "background-color:#cccccc;text-align:center;font-size:90%;";
|
|
$style_th = "font-size:80%;";
|
|
|
|
$style_wochentag = "background-color:#cccccc;";
|
|
$style_wochenend = "background-color:#9999ff;";
|
|
|
|
$style_heute = "background-color:#00aa00;";
|
|
|
|
// strtotime("10 September 2000")
|
|
// liefert einen timestamp
|
|
|
|
switch ( $monat )
|
|
{
|
|
case "1" :
|
|
$monat_engl = "January";
|
|
$monat_de = "Januar";
|
|
break;
|
|
case "2" :
|
|
$monat_engl = "February";
|
|
$monat_de = "Februar";
|
|
break;
|
|
case "3" :
|
|
$monat_engl = "March";
|
|
$monat_de = "März";
|
|
break;
|
|
case "4" :
|
|
$monat_engl = "April";
|
|
$monat_de = "April";
|
|
break;
|
|
case "5" :
|
|
$monat_engl = "May";
|
|
$monat_de = "Mai";
|
|
break;
|
|
case "6" :
|
|
$monat_engl = "June";
|
|
$monat_de = "Juni";
|
|
break;
|
|
case "7" :
|
|
$monat_engl = "July";
|
|
$monat_de = "Juli";
|
|
break;
|
|
case "8" :
|
|
$monat_engl = "August";
|
|
$monat_de = "August";
|
|
break;
|
|
case "9" :
|
|
$monat_engl = "September";
|
|
$monat_de = "September";
|
|
break;
|
|
case "10" :
|
|
$monat_engl = "October";
|
|
$monat_de = "Oktober";
|
|
break;
|
|
case "11" :
|
|
$monat_engl = "November";
|
|
$monat_de = "November";
|
|
break;
|
|
case "12" :
|
|
$monat_engl = "December";
|
|
$monat_de = "Dezember";
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
$erster_tag_timestamp = strtotime( "01 ".$monat_engl." ".$jahr );
|
|
|
|
$erster_tag_wochentag = date( "N", $erster_tag_timestamp );
|
|
|
|
$letzter_tag = date( "t", $erster_tag_timestamp );
|
|
|
|
$letzter_tag_timestamp = strtotime( $letzter_tag." ".$monat_engl." ".$jahr );
|
|
|
|
$letzter_tag_wochentag = date( "N", $letzter_tag_timestamp );
|
|
|
|
|
|
$html = "<table border=\"0\" style=\"\" ><tr><th style=\"".$style_fuer_alle_zellen.$style_th."\">Mo</th><th style=\"".$style_fuer_alle_zellen.$style_th."\">Di</th><th style=\"".$style_fuer_alle_zellen.$style_th."\">Mi</th><th style=\"".$style_fuer_alle_zellen.$style_th."\">Do</th><th style=\"".$style_fuer_alle_zellen.$style_th."\">Fr</th><th style=\"".$style_fuer_alle_zellen.$style_th."\">Sa</th><th style=\"".$style_fuer_alle_zellen.$style_th."\">So</th style=\"".$style_th.$style_fuer_alle_zellen."\"></tr><tr>";
|
|
|
|
$i = 1;
|
|
$tag = 1;
|
|
$wochennr = 0;
|
|
|
|
// Einfügen von leeren Tabellenfeldern
|
|
while( $i < $erster_tag_wochentag )
|
|
{
|
|
$html = $html."<td style=\"".$style_fuer_alle_zellen."\"> </td>";
|
|
$i++;
|
|
}
|
|
|
|
// mach die Woche voll
|
|
for ( $j = $i; $j <= 7; $j++ )
|
|
{
|
|
|
|
$akt_tag = gmmktime( 0, 0, 0, $monat, $tag, $jahr );
|
|
$heute = gmmktime( 0, 0, 0, date( "m" ), date( "d" ), date( "Y" ) );
|
|
|
|
if ( ( date( "N", $akt_tag ) == 6 ) or ( date( "N", $akt_tag ) == 7 ) )
|
|
{
|
|
$style = $style_wochenend;
|
|
}
|
|
else
|
|
{
|
|
$style = $style_wochentag;
|
|
}
|
|
|
|
if ( $akt_tag == $heute )
|
|
{
|
|
$style = $style_heute;
|
|
}
|
|
|
|
$html = $html."<td style=\"".$style_fuer_alle_zellen.$style."\">".$tag."</td>";
|
|
$tag = bcadd( $tag, 1, 0 );
|
|
}
|
|
$wochennr = bcadd( $wochennr, 1, 0 );
|
|
$html = $html."</tr>";
|
|
|
|
|
|
$k = 1;
|
|
while( $tag <= $letzter_tag )
|
|
{
|
|
// wir bauen ne woche und fügen sie dann hinzu
|
|
$akt_tag = gmmktime( 0, 0, 0, $monat, $tag, $jahr );
|
|
$heute = gmmktime( 0, 0, 0, date( "m" ), date( "d" ), date( "Y" ) );
|
|
|
|
if ( ( date( "N", $akt_tag ) == 6 ) or ( date( "N", $akt_tag ) == 7 ) )
|
|
{
|
|
$style = $style_wochenend;
|
|
}
|
|
else
|
|
{
|
|
$style = $style_wochentag;
|
|
}
|
|
|
|
if ( $akt_tag == $heute )
|
|
{
|
|
$style = $style_heute;
|
|
}
|
|
|
|
//$html = $html."<td style=\"".$style."\">".$tag."</td>";
|
|
|
|
|
|
$woche = $woche."<td style=\"".$style_fuer_alle_zellen.$style."\">".$tag."</td>";
|
|
if ( $k == 7 )
|
|
{
|
|
$k = 0;
|
|
$woche = "<tr>".$woche."</tr>";
|
|
$html = $html.$woche;
|
|
$woche = "";
|
|
$letzter_hinzugefuegter_tag = $tag;
|
|
$wochennr = bcadd( $wochennr, 1, 0 );
|
|
}
|
|
|
|
$tag = bcadd( $tag, 1, 0 );
|
|
$k = bcadd( $k, 1, 0 );
|
|
}
|
|
|
|
// Es fehlt noch die letzte Woche - es wurde zwar über alle Tage iteriert, aber die letzten weil $k <> 7 nicht mehr hinzugefügt
|
|
$html = $html."<tr>";
|
|
|
|
$r = 1;
|
|
|
|
$tag = bcadd( $letzter_hinzugefuegter_tag, 1, 0 );
|
|
|
|
while( $tag <= $letzter_tag )
|
|
{
|
|
$akt_tag = gmmktime( 0, 0, 0, $monat, $tag, $jahr );
|
|
$heute = gmmktime( 0, 0, 0, date( "m" ), date( "d" ), date( "Y" ) );
|
|
|
|
if ( ( date( "N", $akt_tag ) == 6 ) or ( date( "N", $akt_tag ) == 7 ) )
|
|
{
|
|
$style = $style_wochenend;
|
|
}
|
|
else
|
|
{
|
|
$style = $style_wochentag;
|
|
}
|
|
|
|
if ( $akt_tag == $heute )
|
|
{
|
|
$style = $style_heute;
|
|
}
|
|
|
|
$html = $html."<td style=\"".$style_fuer_alle_zellen.$style."\">".$tag."</td>";
|
|
$r = bcadd( $r, 1, 0 );
|
|
$tag = bcadd( $tag, 1, 0 );
|
|
|
|
}
|
|
|
|
$wochennr = bcadd( $wochennr, 1, 0 );
|
|
|
|
while( $r <= 7 )
|
|
{
|
|
$html = $html."<td style=\"".$style_fuer_alle_zellen."\"> </td>";
|
|
$r = bcadd( $r, 1, 0 );
|
|
}
|
|
|
|
$html = $html."</tr>";
|
|
//xlog( 5, "wochennummer: ".$wochennr );
|
|
if ( ( $wochennr < 6 ) and ( $liefere_6_zeilen == "true" ) )
|
|
{
|
|
$html = $html."<tr><td style=\"".$style_fuer_alle_zellen."\"> </td><td style=\"".$style_fuer_alle_zellen."\"> </td><td style=\"".$style_fuer_alle_zellen."\"> </td><td style=\"".$style_fuer_alle_zellen."\"> </td><td style=\"".$style_fuer_alle_zellen."\"> </td><td style=\"".$style_fuer_alle_zellen."\"> </td><td style=\"".$style_fuer_alle_zellen."\"> </td></tr>";
|
|
}
|
|
|
|
$html = $html."</table>";
|
|
|
|
$html = "<table><tr><td style=\"".$style_ueberschrift."\">".$monat_de." ".$jahr."</td></tr><tr><td>".$html."</td></tr></table>";
|
|
|
|
|
|
//xlog( 4, $html );
|
|
|
|
xlog( 4, "__wfl.erzeuge_kalender: Liefere Kalender für den Monat ".$monat."/".$jahr."." );
|
|
|
|
return $html;
|
|
|
|
}
|
|
|
|
function berechne_zeitspanne( $anzahl_sekunden )
|
|
{
|
|
$ts = "";
|
|
|
|
|
|
$tage = bcdiv( $anzahl_sekunden, 86400, 0 );
|
|
|
|
if ( $tage >= 1 )
|
|
{
|
|
if ( $tage > 1 )
|
|
{
|
|
$ts = $ts.bcsub( $tage, 0, 0 )." Tage";
|
|
}
|
|
else
|
|
{
|
|
$ts = $ts.bcsub( $tage, 0, 0 )." Tag";
|
|
}
|
|
}
|
|
|
|
$anzahl_sekunden = bcsub( $anzahl_sekunden, bcmul( $tage, 86400 ) );
|
|
|
|
$stunden = bcdiv( $anzahl_sekunden, 3600, 0 );
|
|
|
|
if ( $stunden >= 1 )
|
|
{
|
|
if ( $stunden > 1 )
|
|
{
|
|
if ( strlen( $ts ) > 0 )
|
|
{
|
|
$ts = $ts.", ".bcsub( $stunden, 0, 0 )." Stunden";
|
|
}
|
|
else
|
|
{
|
|
$ts = bcsub( $stunden, 0, 0 )." Stunden";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( strlen( $ts ) > 0 )
|
|
{
|
|
$ts = $ts.", ".bcsub( $stunden, 0, 0 )." Stunde";
|
|
}
|
|
else
|
|
{
|
|
$ts = bcsub( $stunden, 0, 0 )." Stunde";
|
|
}
|
|
}
|
|
}
|
|
|
|
$anzahl_sekunden = bcsub( $anzahl_sekunden, bcmul( $stunden, 3600 ) );
|
|
|
|
$minuten = bcdiv( $anzahl_sekunden, 60, 0 );
|
|
|
|
|
|
if ( bccomp( $minuten, 1 ) >= 1)
|
|
{
|
|
if ( $minuten > 1 )
|
|
{
|
|
if ( strlen( $ts ) > 0 )
|
|
{
|
|
$ts = $ts.", ".bcsub( $minuten, 0, 0 )." Minuten";
|
|
|
|
}
|
|
else
|
|
{
|
|
$ts = bcsub( $minuten, 0, 0 )." Minuten";
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( strlen( $ts ) > 0 )
|
|
{
|
|
$ts = $ts.", ".bcsub( $minuten, 0, 0 )." Minute";
|
|
|
|
}
|
|
else
|
|
{
|
|
$ts = bcsub( $minuten, 0, 0 )." Minute";
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
$anzahl_sekunden = bcsub( $anzahl_sekunden, bcmul( $minuten, 60, 0 ) );
|
|
|
|
$sekunden = $anzahl_sekunden;
|
|
|
|
if ( $sekunden >= 1 )
|
|
{
|
|
if ( $sekunden > 1 )
|
|
{
|
|
if ( strlen( $ts ) > 0 )
|
|
{
|
|
$ts = $ts.", ".bcsub( $sekunden, 0, 0 )." Sekunden";
|
|
|
|
}
|
|
else
|
|
{
|
|
$ts = bcsub( $sekunden, 0, 0 )." Sekunden";
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( strlen( $ts ) > 0 )
|
|
{
|
|
$ts = $ts.", ".bcsub( $sekunden, 0, 0 )." Sekunde";
|
|
|
|
}
|
|
else
|
|
{
|
|
$ts = bcsub( $sekunden, 0, 0 )." Sekunde";
|
|
|
|
}
|
|
}
|
|
}
|
|
if ( strlen( $ts ) == 0 )
|
|
{
|
|
$ts = "0 Sekunden";
|
|
}
|
|
|
|
|
|
return $ts;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
Notizen
|
|
*/
|
|
|
|
function notiz_anlegen( $mandant_name, $element, $element_typ, $notiz_typ, $notiz_inhalt )
|
|
{
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
$connection = mysqli_connect( "localhost", "ca_db", "ca_db", "ca_system" );
|
|
|
|
$flag_setzen = false;
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
switch( strtolower( $element_typ ) )
|
|
{
|
|
case "b":
|
|
// Benutzer
|
|
$ok_2 = existiert_benutzer( $mandant_name, $element );
|
|
|
|
if ( $ok_2[ 0 ] > 0 )
|
|
{
|
|
$element_id = $ok_2[ 0 ];
|
|
$text = "zum Benutzer";
|
|
}
|
|
else
|
|
{
|
|
$rc = -3;
|
|
$meldung = "Der angegebene Benutzer ".$element." existiert nicht im Mandanten ".$mandant_name.".";
|
|
}
|
|
break;
|
|
case "g":
|
|
// Gruppe
|
|
$ok_2 = existiert_gruppe( $mandant_name, $element );
|
|
|
|
if ( $ok_2[ 0 ] > 0 )
|
|
{
|
|
$element_id = $ok_2[ 0 ];
|
|
$text = "zur Gruppe";
|
|
}
|
|
else
|
|
{
|
|
$rc = -3;
|
|
$meldung = "Die angegebene Gruppe ".$element." existiert nicht im Mandanten ".$mandant_name.".";
|
|
}
|
|
break;
|
|
case "d":
|
|
// Dokument
|
|
$element_id = $element;
|
|
$text = "zum Dokument";
|
|
$flag_setzen = true;
|
|
break;
|
|
case "j":
|
|
// Dokument
|
|
$element_id = $element;
|
|
$text = "zum Job";
|
|
break;
|
|
default:
|
|
$rc = -2;
|
|
$meldung = "Es wurde kein korrekter Element-Typ angegeben.";
|
|
break;
|
|
}
|
|
|
|
|
|
|
|
if ( strlen( $meldung ) == 0 )
|
|
{
|
|
$notiz_typ = strtolower( $notiz_typ );
|
|
if ( ( $notiz_typ == "system" ) or ( $notiz_typ == "normal" ) )
|
|
{
|
|
if ( $_SESSION[ "benutzer_anmeldename" ] == "superuser" )
|
|
{
|
|
$ersteller = existiert_benutzer( "Standard", $_SESSION[ "benutzer_anmeldename" ] );
|
|
}
|
|
else
|
|
{
|
|
$ersteller = existiert_benutzer( $mandant_name, $_SESSION[ "benutzer_anmeldename" ] );
|
|
}
|
|
|
|
|
|
if ( $ersteller[ 0 ] > 0 )
|
|
{
|
|
$STATEMENT = "insert into ca_notiz ( element_typ, element_id, notiz_typ, notiz_inhalt, ersteller_benutzer_id, notiz_zeitstempel ) values ( '".mysqli_real_escape_string( $connection, $element_typ )."', ".mysqli_real_escape_string( $connection, $element_id ).", '".mysqli_real_escape_string( $connection, $notiz_typ )."', '".mysqli_real_escape_string( $connection, $notiz_inhalt )."', ".mysqli_real_escape_string( $connection, $ersteller[ 0 ] ).", '".time()."' ) ";
|
|
|
|
xlog( 6, $STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
if ( $flag_setzen )
|
|
{
|
|
$STATEMENT = "update ca_dok_ablage set n_flag = '1' where dok_id = ".$element_id." and mandant_id = ".$ok_1[ 0 ];
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
}
|
|
$rc = $ergebnis[ 0 ];
|
|
$meldung = "Es wurde eine Notiz ".$text." ".$element." angelegt.";
|
|
}
|
|
else
|
|
{
|
|
$rc = -6;
|
|
$meldung = "Es ist ein Fehler aufgetreten: '".$ergebnis[ 1 ]."'.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -5;
|
|
$meldung = "Der angegebene Benutzer existiert nicht.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -4;
|
|
$meldung = "Es wurde ein ungültiger Notiz-Typ angegeben.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Meldung und RC sind schon gesetzt
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = $ok_1[ 1 ];
|
|
}
|
|
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
mysqli_close( $connection );
|
|
|
|
xlog( $level, "__wfl.erzeuge_notiz: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung );
|
|
}
|
|
|
|
function notiz_an_benutzer_anlegen( $mandant_name, $benutzer_anmeldename, $notiz_inhalt )
|
|
{
|
|
return notiz_anlegen( $mandant_name, $benutzer_anmeldename, "b", "normal", $notiz_inhalt );
|
|
}
|
|
|
|
function notiz_an_gruppe_anlegen( $mandant_name, $gruppen_name, $notiz_inhalt )
|
|
{
|
|
return notiz_anlegen( $mandant_name, $gruppen_name, "g", "normal", $notiz_inhalt );
|
|
}
|
|
|
|
function notiz_an_dokument_anlegen( $mandant_name, $dok_id, $notiz_inhalt )
|
|
{
|
|
return notiz_anlegen( $mandant_name, $dok_id, "d", "normal", $notiz_inhalt );
|
|
}
|
|
|
|
function systemnotiz_an_benutzer_anlegen( $mandant_name, $benutzer_anmeldename, $notiz_inhalt )
|
|
{
|
|
return notiz_anlegen( $mandant_name, $benutzer_anmeldename, "b", "system", $notiz_inhalt );
|
|
}
|
|
|
|
function systemnotiz_an_gruppe_anlegen( $mandant_name, $gruppen_name, $notiz_inhalt )
|
|
{
|
|
return notiz_anlegen( $mandant_name, $gruppen_name, "g", "system", $notiz_inhalt );
|
|
}
|
|
|
|
function systemnotiz_an_dokument_anlegen( $mandant_name, $dok_id, $notiz_inhalt )
|
|
{
|
|
return notiz_anlegen( $mandant_name, $dok_id, "d", "system", $notiz_inhalt );
|
|
}
|
|
|
|
function notiz_an_job_anlegen( $mandant_name, $job_id, $notiz_inhalt )
|
|
{
|
|
return notiz_anlegen( $mandant_name, $job_id, "j", "normal", $notiz_inhalt );
|
|
}
|
|
|
|
function liefere_notizen( $mandant_name, $element_typ, $element, $notiz_typ )
|
|
{
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
switch( strtolower( $element_typ ) )
|
|
{
|
|
case "b":
|
|
// Benutzer
|
|
$ok_2 = existiert_benutzer( $mandant_name, $element );
|
|
|
|
if ( $ok_2[ 0 ] > 0 )
|
|
{
|
|
$element_id = $ok_2[ 0 ];
|
|
$text = "zum Benutzer";
|
|
}
|
|
else
|
|
{
|
|
$rc = -3;
|
|
$meldung = "Der angegebene Benutzer ".$element." existiert nicht im Mandanten ".$mandant_name.".";
|
|
}
|
|
break;
|
|
case "g":
|
|
// Gruppe
|
|
$ok_2 = existiert_gruppe( $mandant_name, $element );
|
|
|
|
if ( $ok_2[ 0 ] > 0 )
|
|
{
|
|
$element_id = $ok_2[ 0 ];
|
|
$text = "zur Gruppe";
|
|
}
|
|
else
|
|
{
|
|
$rc = -3;
|
|
$meldung = "Die angegebene Gruppe ".$element." existiert nicht im Mandanten ".$mandant_name.".";
|
|
}
|
|
break;
|
|
case "d":
|
|
// Dokument
|
|
$element_id = $element;
|
|
$text = "zum Dokument";
|
|
break;
|
|
default:
|
|
$rc = -2;
|
|
$meldung = "Es wurde kein korrekter Element-Typ angegeben.";
|
|
break;
|
|
}
|
|
|
|
|
|
|
|
if ( strlen( $meldung ) == 0 )
|
|
{
|
|
$notiz_typ = strtolower( $notiz_typ );
|
|
if ( ( $notiz_typ == "system" ) or ( $notiz_typ == "normal" ) or ( $notiz_typ == "" ) )
|
|
{
|
|
if ( ( $notiz_typ == "system" ) or ( $notiz_typ == "normal" ) )
|
|
{
|
|
$STATEMENT_ERW = " and notiz_typ = '".$notiz_typ."' ";
|
|
}
|
|
else
|
|
{
|
|
$STATEMENT_ERW = "";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$STATEMENT_ERW = "";
|
|
}
|
|
|
|
$STATEMENT = "select n.notiz_inhalt, n.notiz_typ, n.notiz_zeitstempel, b.benutzer_anmeldename from ca_notiz n, ca_benutzer b where b.benutzer_id = n.ersteller_benutzer_id and element_id = ".$element_id." and element_typ = '".$element_typ."' ".$STATEMENT_ERW." order by notiz_zeitstempel desc";
|
|
|
|
//xlog( 4, $STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] >= 0 )
|
|
{
|
|
$rc = $ergebnis[ 0 ];
|
|
$meldung = "Liefere ".$rc." Notizen ".$text." ".$element.".";
|
|
$ausgabe = $ergebnis[ 1 ];
|
|
if ( ! is_array( $ausgabe ) )
|
|
{
|
|
$ausgabe = array();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -1;
|
|
$meldung = "Es ist ein Fehler aufgetreten: '".$ergebnis[ 1 ]."'.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Meldung und RC sind schon gesetzt
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = $ok_1[ 1 ];
|
|
}
|
|
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.liefere_notizen: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung, $ausgabe );
|
|
}
|
|
|
|
function liefere_notizen_an_benutzer( $mandant_name, $benutzer_anmeldename, $notiz_typ = "" )
|
|
{
|
|
return liefere_notizen( $mandant_name, "b", $benutzer_anmeldename, $notiz_typ );
|
|
}
|
|
|
|
function liefere_notizen_an_gruppe( $mandant_name, $gruppen_name, $notiz_typ = "" )
|
|
{
|
|
return liefere_notizen( $mandant_name, "g", $gruppen_name, $notiz_typ );
|
|
}
|
|
|
|
function liefere_notizen_an_dokument( $mandant_name, $dok_id, $notiz_typ = "" )
|
|
{
|
|
return liefere_notizen( $mandant_name, "d", $dok_id, $notiz_typ );
|
|
}
|
|
|
|
function liefere_notizen_an_element_als_string( $mandant_name, $element_typ, $element, $notiz_typ = "" )
|
|
{
|
|
$ergebnis = liefere_notizen( $mandant_name, $element_typ, $element, $notiz_typ );
|
|
|
|
$ausgabe = "";
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
foreach( $ergebnis[ 2 ] as $notiz )
|
|
{
|
|
// n.notiz_inhalt, n.notiz_typ, n.notiz_zeitstempel, b.benutzer_anmeldename
|
|
|
|
if ( $benutz <> $notiz[ "benutzer_anmeldename" ] )
|
|
{
|
|
$benutzer = liefere_benutzerinformationen( $mandant_name, $notiz[ "benutzer_anmeldename" ] );
|
|
}
|
|
|
|
$benutz = $notiz[ "benutzer_anmeldename" ];
|
|
|
|
if ( ( strlen( $benutzer[ 2 ][ "benutzer_vorname" ] ) == 0 ) and ( strlen( $benutzer[ 2 ][ "benutzer_nachname" ] ) == 0 ) )
|
|
{
|
|
$name = $benutzer[ 2 ][ "benutzer_anmeldename" ];
|
|
}
|
|
else
|
|
{
|
|
$name = $benutzer[ 2 ][ "benutzer_vorname" ]." ".$benutzer[ 2 ][ "benutzer_nachname" ];
|
|
}
|
|
|
|
$ausgabe = $ausgabe."Notiz von ".$name.", erstellt am ".date( "d.m.Y H:i", $notiz[ "notiz_zeitstempel" ] )." Uhr:<br />".$notiz[ "notiz_inhalt" ]."<br />--------------------------<br />";
|
|
|
|
}
|
|
$rc = $ergebnis[ 0 ];
|
|
$meldung = $ergebnis[ 1 ];
|
|
}
|
|
else
|
|
{
|
|
$rc = 0;
|
|
$meldung = "Es wurden keine Notizen gefunden.";
|
|
$ausgabe = $meldung;
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.liefere_notizen_an_benutzer_als_string: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung, $ausgabe );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function welche_module_sind_in_mandant_installiert( $mandant_name ) // depricated
|
|
{
|
|
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
/*
|
|
alpha_01 => Modulkürzel
|
|
alpha_02 => Modulname
|
|
alpha_03 => Moduldatei
|
|
|
|
*/
|
|
$STATEMENT = "select alpha_01, alpha_02, alpha_03 from ca_mandant_informationen where typ = 'modul' and status = 'aktiv' and mandant_id = ".$ok_1[ 0 ];
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
$module = $ergebnis[ 1 ];
|
|
}
|
|
else
|
|
{
|
|
$module = array();
|
|
}
|
|
|
|
$rc = count( $module );
|
|
$meldung = "Liefere ".$rc." Module für den Mandanten ".$mandant_name.".";
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = $ok_1[ 1 ];
|
|
}
|
|
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.welche_module_sind_in_mandant_installiert: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung, $module );
|
|
}
|
|
|
|
function welche_module_sind_nicht_in_mandant_installiert( $mandant_name ) // depricated
|
|
{
|
|
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
$_alle_module = liefere_wertemenge_elemente( "Standard", "_installierte_module" );
|
|
|
|
$_installierte_module = welche_module_sind_in_mandant_installiert( $mandant_name );
|
|
|
|
$ergebnis = array();
|
|
|
|
foreach ( $_alle_module[ 2 ] as $verfuegbares_modul )
|
|
{
|
|
|
|
$gefunden = false;
|
|
foreach( $_installierte_module[ 2 ] as $installiertes_modul )
|
|
{
|
|
|
|
if ( $verfuegbares_modul[ "alpha_01" ] == $installiertes_modul[ "alpha_03" ] )
|
|
{
|
|
$gefunden = true;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
$gefunden = false;
|
|
}
|
|
}
|
|
|
|
if ( $gefunden == false )
|
|
{
|
|
$ergebnis[] = $verfuegbares_modul[ "alpha_01" ];
|
|
}
|
|
}
|
|
$rc = count( $ergebnis );
|
|
$meldung = "Liefere ".$rc." Module, die nicht im Mandanten ".$mandant_name." installiert sind.";
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = $ok_1[ 1 ];
|
|
}
|
|
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
|
|
xlog( $level, "__wfl.welche_module_sind_nicht_in_mandant_installiert: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung, $ergebnis );
|
|
}
|
|
|
|
function installiere_modul( $mandant_name, $neues_modul ) // depricated
|
|
{
|
|
$exekutor = $_SESSION[ "benutzer_anmeldename" ];
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
if ( strlen( $neues_modul ) > 0 )
|
|
{
|
|
$module = liefere_wertemenge_elemente( "Standard", "_installierte_module" );
|
|
|
|
foreach ( $module[ 2 ] as $modul )
|
|
{
|
|
if ( $modul[ "alpha_01" ] == $neues_modul )
|
|
{
|
|
$dateipfad = $modul[ "alpha_02" ];
|
|
}
|
|
}
|
|
|
|
include( $dateipfad.$neues_modul );
|
|
|
|
|
|
$STATEMENT = "insert into ca_mandant_informationen ( mandant_id, typ, status, alpha_01, alpha_02, alpha_03, alpha_04 ) values ( ".$ok_1[ 0 ].", 'modul', 'aktiv', '".$modulkuerzel."', '".$modulname."', '".$neues_modul."', '".$modulstart_php."' )";
|
|
|
|
xdb( $STATEMENT );
|
|
|
|
foreach( $modul_konfiguration as $element )
|
|
{
|
|
//erstelle_konfig( $mandant_name, $parameter, $kategorie, $wert = "", $wertemenge = "", $beschreibung = "" )
|
|
erstelle_konfig( $mandant_name, $element[ "einstellung" ], modulkuerzel, $element[ "wert" ], $element[ "wertemenge" ], $element[ "beschreibung" ] );
|
|
}
|
|
|
|
foreach( $modul_wertemengen as $element )
|
|
{
|
|
//wertemenge_anlegen( $mandant_name, $kuerzel, $typ, $konfig, $bezeichnung, $kategorie = "system", $beschreibung = "", $feld_bezeichnungen = array(), $werte = array() )
|
|
wertemenge_anlegen( $mandant_name, $element[ "kuerzel" ], $element[ "typ" ], $element[ "konfig" ], $element[ "bezeichnung" ], modulkuerzel, $element[ "beschreibung" ], $element[ "felder" ] );
|
|
}
|
|
|
|
foreach( $modul_wertemengen_elemente as $element )
|
|
{
|
|
|
|
foreach( $element[ 1 ] as $wertemengen_element )
|
|
{
|
|
|
|
wertemengen_element_hinzufuegen( $mandant_name, $element[ "kuerzel" ], $wertemengen_element );
|
|
|
|
/*
|
|
element[ "alpha_01" ] = "wert";
|
|
element[ "alpha_02" ] = "wert";
|
|
*/
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
$rc = -1;
|
|
$meldung = "Das Modul ".$neues_modul." wurde im Mandanten ".$mandant_name." installiert.";
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = -1;
|
|
$meldung = "Es wurde kein Modul angegeben.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = $ok_1[ 1 ];
|
|
}
|
|
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.installiere_modul: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung );
|
|
}
|
|
|
|
function deinstalliere_modul( $mandant_name, $modul ) // depricated
|
|
{
|
|
$exekutor = $_SESSION[ "benutzer_anmeldename" ];
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
if ( strlen( $modul ) > 0 )
|
|
{
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = -1;
|
|
$meldung = "Es wurde kein Modul angegeben.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = $ok_1[ 1 ];
|
|
}
|
|
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.installiere_modul: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung );
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function variable_recherche( $mandant_name, $dokart_kuerzel, $benutzer_anmeldename, $stichwoerter, $sortierung=array(), $anzahl_treffer = 250 )
|
|
{
|
|
/******************
|
|
BESCHREIBUNG_____Diese Funktion liefert eine Menge an Dokumenten (Datensätzen als Array), die mit dem Stichwort verknüpft sind, dh. in bestimmten Feldern vorkommen.
|
|
RETURNS_____Erfolgsfall: array( ( integer ) Returncode (Anzahl der gefundenen Dokumente), Meldung, Ausgabe ) Fehlerfall: array( ( integer ) Returncode, ( string ) Meldung )
|
|
******************/
|
|
|
|
// $dokument_holen ist mit Einführung der Depots obsolet. Die Angabe wird ignoriert.
|
|
$dokument_holen = false;
|
|
|
|
/******************************
|
|
// $benutzer_anmeldename ist der Benutzer, der die Recherche ausführt bzw. für den festgestellt werden soll, welche Dokumente er sieht.
|
|
//
|
|
******************************/
|
|
|
|
|
|
|
|
/******************************
|
|
// Die Stichwörter sind die Recherchekriterien, nach denen gesucht wird
|
|
// $stichwoerter muß folgendermaßen zusammengebaut sein:
|
|
//
|
|
// array( array( "feld"=>"alpha_01", "operator"=>"EQUAL", "wert"=>"Schnepfenweg" ), array( "feld"=>"alpha_02", "operator"=>"NOT_EQUAL", "wert"=>"Wallenhorst" ), ... )
|
|
//
|
|
// Erlaubte Operatoren sind:
|
|
//
|
|
// EQUAL
|
|
// NOT_EQUAL
|
|
// GREATER
|
|
// GREATER_OR_EQUAL
|
|
// SMALLER
|
|
// SMALLER_OR_EQUAL
|
|
// LIKE (nur alphanumerische Felder, also alpha_xx)
|
|
//
|
|
//
|
|
//
|
|
// Als $feld sind auch andere Dinge erlaubt:
|
|
//
|
|
// Dokument-ID oder Kennung (dok_id)
|
|
// Volltext (volltext)
|
|
// Archivierungsdatum (archivierungsdatum)
|
|
//
|
|
// Beispiel: array( "feld"=>"archivierungsdatum", "operator"=>"GREATER_OR_EQUAL", "wert"=>"12.11.2013" )
|
|
//
|
|
******************************/
|
|
|
|
|
|
|
|
|
|
|
|
/******************************
|
|
// Die Sortierung der Trefferliste wird über das Array $sortierung folgendermaßen angegeben:
|
|
//
|
|
// $sortierung[ $feld ] = $order
|
|
//
|
|
// Das Array darf beliebig viele Elemente enthalten (und auch leer sein).
|
|
//
|
|
// $feld darf ein Datenbankfeld sein, also etwa "alpha_01", "alpha_34" oder "datum_02".
|
|
//
|
|
// $order darf entweder "asc" (aufsteigend) oder "desc" (absteigend) sein.
|
|
******************************/
|
|
|
|
|
|
/******************************
|
|
// $anzahl_treffer gibt vor, wieviele Treffer geliefert werden sollen. Die Angabe "0" (Null) steht für "alle".
|
|
//
|
|
******************************/
|
|
|
|
|
|
|
|
|
|
/******************************
|
|
//
|
|
// Die Rückgabe sieht folgendermaßen aus:
|
|
//
|
|
// array( array( "alpha_01"=>"Dieter", "alpha_02"=>"Meier", "alpha_03"=>"hallo", [ ... ], "dok_id"=>9432 ), array( "alpha_01"=>"Klaus", "alpha_02"=>"Schmidt", "alpha_03"=>"Du Da!", "dok_id"=>9433 ), ... )
|
|
******************************/
|
|
|
|
|
|
|
|
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
|
|
$ok_2 = existiert_benutzer( $mandant_name, $benutzer_anmeldename );
|
|
|
|
if ( $ok_2[ 0 ] > 0 )
|
|
{
|
|
|
|
if ( is_array( $stichwoerter ) and count( $stichwoerter ) > 0 )
|
|
{
|
|
if ( $dokument_holen == true )
|
|
{
|
|
$dok_hol = ", a.dokument dokument ";
|
|
}
|
|
else
|
|
{
|
|
$dok_hol = "";
|
|
}
|
|
|
|
|
|
$funcname = "func_".$ok_1[ 0 ]."_pre_recherche_1";
|
|
|
|
if ( function_exists( $funcname ) )
|
|
{
|
|
$erg = $funcname( $dokart_kuerzel, $stichwoerter );
|
|
|
|
$dokart_kuerzel = $erg[ 2 ];
|
|
$stichwoerter = $erg[ 3 ];
|
|
}
|
|
else
|
|
{
|
|
$erg[ 0 ] == 0;
|
|
}
|
|
|
|
|
|
// Zuerst bauen wir uns mal ein Statement zusammen:
|
|
|
|
if ( $dokart_kuerzel != "SCHABLONE" )
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
if ( $erg[ 0 ] == 0 )
|
|
{
|
|
// Akten-/Dokumentartbezogene Suche
|
|
// Besorge die Informationen über die Dokumentart
|
|
$dokart = liefere_dokartinformationen( $mandant_name, $dokart_kuerzel );
|
|
|
|
$select = "select ";
|
|
$where = " a.dokart_kuerzel = '".$dokart_kuerzel."' and a.mandant_id = ".$ok_1[ 0 ]." and i.dok_id = a.dok_id ";
|
|
|
|
$archdatum_gefunden = 0;
|
|
$volltext_gefunden = false;
|
|
|
|
|
|
|
|
// Zusammenbau des Select-Statements
|
|
foreach ( $dokart[ 2 ][ "attribute" ] as $attribut )
|
|
{
|
|
if ( substr( $attribut[ "attrib_typ" ], 0, 2 ) != "p_" )
|
|
{
|
|
$select = $select." i.".$attribut[ "attrib_db_spalte" ]." ".$attribut[ "attrib_db_spalte" ].",";
|
|
}
|
|
|
|
foreach ( $stichwoerter as $attrib_array )
|
|
{
|
|
//xlog( 5, "substr ".substr( $attribut[ "attrib_typ" ], 0, 2 ) );
|
|
|
|
//xlog( 5, json_encode( $attrib_array ) );
|
|
|
|
if ( ( $attrib_array[ "feld" ] == $attribut[ "attrib_db_spalte" ] ) and ( strlen( $attrib_array[ "wert" ] ) > 0 ) )
|
|
{
|
|
if ( substr( $attribut[ "attrib_typ" ], 0, 2 ) != "p_" )
|
|
{
|
|
|
|
// Die Bedingungen werden UND-verknüpft.
|
|
|
|
|
|
|
|
$t = substr( $attribut[ "attrib_typ" ], 0, 2 );
|
|
|
|
$wert = $attrib_array[ "wert" ];
|
|
|
|
switch ( $t )
|
|
{
|
|
case "al":
|
|
break;
|
|
case "nu":
|
|
break;
|
|
case "da":
|
|
$wert = datum2mysql( $wert );
|
|
break;
|
|
case "ge":
|
|
break;
|
|
|
|
}
|
|
|
|
$prozent = "";
|
|
switch ( $attrib_array[ "operator" ] )
|
|
{
|
|
case "EQUAL":
|
|
$verknuepfung = " = ";
|
|
break;
|
|
case "NOT_EQUAL":
|
|
$verknuepfung = " <> ";
|
|
break;
|
|
case "GREATER":
|
|
$verknuepfung = " > ";
|
|
break;
|
|
case "GREATER_OR_EQUAL":
|
|
$verknuepfung = " >= ";
|
|
break;
|
|
case "SMALLER":
|
|
$verknuepfung = " < ";
|
|
break;
|
|
case "SMALLER_OR_EQUAL":
|
|
$verknuepfung = " <= ";
|
|
break;
|
|
case "LIKE":
|
|
$verknuepfung = " like ";
|
|
$prozent = "";
|
|
break;
|
|
default:
|
|
$verknuepfung = " = ";
|
|
break;
|
|
}
|
|
|
|
$wert = str_replace( "*", "%", $wert );
|
|
$wert = str_replace( "?", "_", $wert );
|
|
|
|
|
|
$where = $where." and i.".$attribut[ "attrib_db_spalte" ]." ".$verknuepfung." '".$prozent.$wert.$prozent."'";
|
|
}
|
|
else
|
|
{
|
|
|
|
switch ( $attrib_array[ "operator" ] )
|
|
{
|
|
case "EQUAL":
|
|
$verknuepfung = " = ";
|
|
break;
|
|
case "NOT_EQUAL":
|
|
$verknuepfung = " <> ";
|
|
break;
|
|
case "GREATER":
|
|
$verknuepfung = " > ";
|
|
break;
|
|
case "GREATER_OR_EQUAL":
|
|
$verknuepfung = " >= ";
|
|
break;
|
|
case "SMALLER":
|
|
$verknuepfung = " < ";
|
|
break;
|
|
case "SMALLER_OR_EQUAL":
|
|
$verknuepfung = " <= ";
|
|
break;
|
|
default:
|
|
$verknuepfung = " = ";
|
|
break;
|
|
}
|
|
|
|
$where_p = $where_p." and ( i.dok_id in (select dok_id from ca_posdaten where dok_id in ( select dok_id from ca_dok_ablage where dokart_kuerzel = '".$dokart_kuerzel."' ) and ".$attribut[ "attrib_db_spalte" ]." ".$verknuepfung." '".$attrib_array[ "wert" ]."' ) ) ";
|
|
|
|
}
|
|
}
|
|
|
|
|
|
if ( ( $attrib_array[ "feld" ] == "archivierungsdatum" ) and ( strlen( $attrib_array[ "wert" ] ) > 0 ) and $archdatum_gefunden < 2 )
|
|
{
|
|
$archdatum_gefunden++;
|
|
|
|
$archdat = strtotime( $attrib_array[ "wert" ] );
|
|
|
|
switch ( $attrib_array[ "operator" ] )
|
|
{
|
|
case "EQUAL":
|
|
$verknuepfung = " = ";
|
|
break;
|
|
case "NOT_EQUAL":
|
|
$verknuepfung = " <> ";
|
|
break;
|
|
case "GREATER":
|
|
$verknuepfung = " > ";
|
|
break;
|
|
case "GREATER_OR_EQUAL":
|
|
$verknuepfung = " >= ";
|
|
break;
|
|
case "SMALLER":
|
|
$verknuepfung = " < ";
|
|
$archdat = $archdat + 86400;
|
|
break;
|
|
case "SMALLER_OR_EQUAL":
|
|
$verknuepfung = " <= ";
|
|
$archdat = $archdat + 86400;
|
|
break;
|
|
default:
|
|
$verknuepfung = " = ";
|
|
break;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
$where = $where." and a.archivierungsdatum ".$verknuepfung." '".$archdat."'";
|
|
}
|
|
|
|
|
|
if ( ( $attrib_array[ "feld" ] == "volltext" ) and ( strlen( $attrib_array[ "wert" ] ) > 0 ) and $volltext_gefunden == false )
|
|
{
|
|
$volltext_gefunden = true;
|
|
|
|
$vollwert = explode( " ", $attrib_array[ "wert" ] );
|
|
|
|
$wortwhere = "";
|
|
|
|
foreach( $vollwert as $einzelwort )
|
|
{
|
|
$wortwhere = $wortwhere."'".$einzelwort."', ";
|
|
}
|
|
|
|
$wortwhere = substr( $wortwhere, 0, strlen( $wortwhere ) -2 );
|
|
|
|
// typ = 1 => Volltextwort
|
|
// typ = 5 => Tag
|
|
// ist hier aber nicht wichtig. ;-/
|
|
|
|
$where = $where." and i.dok_id in ( select dok_id from ca_wort where wort in ( ".$wortwhere." ) ) ";
|
|
|
|
}
|
|
|
|
|
|
if ( ( $attrib_array[ "feld" ] == "dok_id" ) and ( strlen( $attrib_array[ "wert" ] ) > 0 ) )
|
|
{
|
|
if ( is_numeric( $attrib_array[ "wert" ] ) )
|
|
{
|
|
// es wurde eine Dokument-ID angegeben
|
|
$where = $where." and i.dok_id = ".$attrib_array[ "wert" ];
|
|
|
|
}
|
|
else
|
|
{
|
|
// es wurde eine Kennung angegeben
|
|
$where = $where." and a.kennung = '".$attrib_array[ "wert" ]."'";
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
$select = $select." a.archivierungsdatum archivierungsdatum, i.dok_id dok_id, a.kennung kennung, a.a_flag a_flag, a.v_flag v_flag, a.j_flag j_flag, a.n_flag n_flag, a.dokart_kuerzel dokart_kuerzel, a.mandant_id mandant_id, c.md5 md5, c.mime_type mime_type, a.eigentuemer eigentuemer, a.aktueller_besitzer aktueller_besitzer, a.sperr_status sperr_status, a.sperr_beginn sperr_beginn, a.sperr_benutzer sperr_benutzer, a.system_flags system_flags, c.ursprungs_dateiname ursprungs_dateiname, c.groesse groesse ".$dok_hol;
|
|
$where = $where." and c.dok_id = a.dok_id and c.version = a.d_version and a.status in ( 'offen' ) and c.erw = 0 ";
|
|
|
|
$order_by = "";
|
|
if ( ( count( $sortierung ) > 0 ) and ( is_array( $sortierung ) ) )
|
|
{
|
|
$order_by = " order by ";
|
|
foreach( $sortierung as $feld=>$order )
|
|
{
|
|
$order_by = $order_by." ".$feld." ".$order.", ";
|
|
}
|
|
$order_by = substr( $order_by, 0, -2 );
|
|
}
|
|
else
|
|
{
|
|
$order_by = " order by i.dok_id desc ";
|
|
}
|
|
|
|
$STATEMENT = $select." from ca_index i, ca_dok_ablage a, ca_dok_datei c where ( ".$where." ) ".$where_p.$order_by;
|
|
}
|
|
else
|
|
{
|
|
$ergebnisarr = array();
|
|
$rc = -15;
|
|
$meldung = "Fehler in kundenspezifischer Einsprungfunktion / pre_recherche_1:".$meldung_pr1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Akten-/Dokumentartübergreifende Suche
|
|
// hier ist nur Volltext / Tag / Importdatum / Dokument-ID-Suche möglich.
|
|
|
|
|
|
|
|
/*
|
|
xlog( 1, json_encode( $stichwoerter ) );
|
|
|
|
[
|
|
{"feld":"alpha_01","operator":"EQUAL","wert":"w34w2w"},
|
|
{"feld":"dok_id","operator":"EQUAL","wert":""},
|
|
{"feld":"archivierungsdatum","operator":"GREATER_OR_EQUAL","wert":"03.06.2015"},
|
|
{"feld":"archivierungsdatum","operator":"SMALLER_OR_EQUAL","wert":"18.06.2015"}
|
|
]
|
|
*/
|
|
|
|
//$suchbegriff =
|
|
if ( $erg[ 0 ] == 0 )
|
|
{
|
|
|
|
$awhere = ""; // Attribut
|
|
$dwhere = ""; // Archivierungsdatum
|
|
$iwhere = ""; // Dok-ID / Kennung
|
|
|
|
foreach ( $stichwoerter as $attrib_array )
|
|
{
|
|
//xlog( 4, json_encode( $attrib_array ) );
|
|
if ( ( $attrib_array[ "feld" ] == "archivierungsdatum" ) and ( strlen( $attrib_array[ "wert" ] ) > 0 ) and $archdatum_gefunden < 2 )
|
|
{
|
|
$archdatum_gefunden++;
|
|
|
|
switch ( $attrib_array[ "operator" ] )
|
|
{
|
|
case "EQUAL":
|
|
$verknuepfung = " = ";
|
|
break;
|
|
case "NOT_EQUAL":
|
|
$verknuepfung = " <> ";
|
|
break;
|
|
case "GREATER":
|
|
$verknuepfung = " > ";
|
|
break;
|
|
case "GREATER_OR_EQUAL":
|
|
$verknuepfung = " >= ";
|
|
break;
|
|
case "SMALLER":
|
|
$verknuepfung = " < ";
|
|
break;
|
|
case "SMALLER_OR_EQUAL":
|
|
$verknuepfung = " <= ";
|
|
break;
|
|
case "LIKE":
|
|
$verknuepfung = " like ";
|
|
$prozent = "";
|
|
break;
|
|
default:
|
|
$verknuepfung = " = ";
|
|
break;
|
|
}
|
|
|
|
$archdat = strtotime( $attrib_array[ "wert" ] );
|
|
|
|
if ( strlen( $dwhere ) > 0 )
|
|
{
|
|
$and = " and ";
|
|
}
|
|
else
|
|
{
|
|
$and = "";
|
|
}
|
|
|
|
$dwhere = $dwhere.$and." a.archivierungsdatum ".$verknuepfung." '".$archdat."'";
|
|
}
|
|
|
|
if ( ( $attrib_array[ "feld" ] == "alpha_01" ) and ( strlen( $attrib_array[ "wert" ] ) > 0 ) )
|
|
{
|
|
switch ( $attrib_array[ "operator" ] )
|
|
{
|
|
case "EQUAL":
|
|
$verknuepfung = " = ";
|
|
|
|
break;
|
|
case "NOT_EQUAL":
|
|
$verknuepfung = " <> ";
|
|
break;
|
|
case "GREATER":
|
|
$verknuepfung = " > ";
|
|
break;
|
|
case "GREATER_OR_EQUAL":
|
|
$verknuepfung = " >= ";
|
|
break;
|
|
case "SMALLER":
|
|
$verknuepfung = " < ";
|
|
break;
|
|
case "SMALLER_OR_EQUAL":
|
|
$verknuepfung = " <= ";
|
|
break;
|
|
case "LIKE":
|
|
$verknuepfung = " like ";
|
|
$prozent = "";
|
|
break;
|
|
default:
|
|
$verknuepfung = " = ";
|
|
break;
|
|
}
|
|
|
|
|
|
|
|
$wert = trim( $attrib_array[ "wert" ] );
|
|
//xlog( 4, "wert ".$wert );
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
$felder = array( "alpha_01", "alpha_02", "alpha_03", "alpha_04", "alpha_05", "alpha_06", "alpha_07", "alpha_08", "alpha_09", "alpha_10", "alpha_11", "alpha_12", "alpha_13", "alpha_14", "alpha_15", "alpha_16", "alpha_17", "alpha_18", "alpha_19", "alpha_20", "alpha_21", "alpha_22", "alpha_23", "alpha_24", "alpha_25", "alpha_26", "alpha_27", "alpha_28", "alpha_29", "alpha_30" );
|
|
|
|
// werden nicht berücksichtigt:
|
|
//"num_01", "num_02", "num_03", "num_04", "num_05", "num_06", "num_07", "num_08", "num_09", "num_10",
|
|
//, "geld_01", "geld_02", "geld_03", "geld_04", "geld_05", "geld_06", "geld_07", "geld_08", "geld_09", "geld_10"
|
|
//, "datum_01", "datum_02", "datum_03", "datum_04", "datum_05", "datum_06", "datum_07", "datum_08", "datum_09", "datum_10"
|
|
/*
|
|
|
|
|
|
$werte = explode( " ", $wert );
|
|
|
|
// Es werden nur die ersten drei Suchbegriffe verwendet
|
|
$w[] = $werte[ 0 ];
|
|
$w[] = $werte[ 1 ];
|
|
$w[] = $werte[ 2 ];
|
|
|
|
foreach ( $w as $element )
|
|
{
|
|
if ( strlen( $element ) > 0 )
|
|
{
|
|
$element = str_replace( "*", "%", $element );
|
|
$element = str_replace( "?", "_", $element );
|
|
|
|
foreach ( $felder as $feld )
|
|
{
|
|
$f_typ = substr( $feld, 0, 2 );
|
|
|
|
switch( $f_typ )
|
|
{
|
|
case "al":
|
|
case "da":
|
|
$awhere = $awhere." i.".$feld." ".$verknuepfung." '".$element."' or ";
|
|
break;
|
|
case "nu":
|
|
case "ge":
|
|
//$awhere = $awhere." ".$feld." ".$verknuepfung." ".$element." or ";
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
*/
|
|
foreach ( $felder as $feld )
|
|
{
|
|
$awhere = $awhere." i.".$feld." like '%".$wert."%' or ";
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
//xlog( 5, json_encode( $attrib_array ));
|
|
if ( ( $attrib_array[ "feld" ] == "dok_id" ) and ( strlen( $attrib_array[ "wert" ] ) > 0 ) )
|
|
{
|
|
if ( is_numeric( $attrib_array[ "wert" ] ) )
|
|
{
|
|
// es wurde eine Dokument-ID angegeben
|
|
$iwhere = $iwhere." i.dok_id = ".$attrib_array[ "wert" ];
|
|
|
|
}
|
|
else
|
|
{
|
|
// es wurde eine Kennung angegeben
|
|
$iwhere = $iwhere." a.kennung = '".$attrib_array[ "wert" ]."'";
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( strlen( $dwhere ) > 0 )
|
|
{
|
|
$dwhere = " and ( ".$dwhere." ) ";
|
|
|
|
}
|
|
|
|
if ( strlen( $awhere ) > 0 )
|
|
{
|
|
$awhere = " and ( ".substr( $awhere, 0, -3 )." ) ";
|
|
|
|
}
|
|
|
|
if ( strlen( $iwhere ) > 0 )
|
|
{
|
|
$iwhere = " and ( ".$iwhere." ) ";
|
|
|
|
}
|
|
//xlog( 3, $dwhere );
|
|
//xlog( 3, $awhere );
|
|
|
|
/////// Jetzt noch die Benutzerrechte applizieren:
|
|
$ergebnis = welche_dokaktenarten_darf_benutzer_lesen( $mandant_name, $benutzer_anmeldename );
|
|
|
|
$rwhere = "";
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
foreach( $ergebnis[ 1 ] as $dokuart )
|
|
{
|
|
if ( $dokuart != "SCHABLONE" )
|
|
{
|
|
$rwhere = $rwhere."'".$dokuart."', ";
|
|
}
|
|
}
|
|
$rwhere = substr( $rwhere, 0, -2 );
|
|
}
|
|
|
|
if ( strlen( $rwhere ) == 0 )
|
|
{
|
|
$rwhere = "''";
|
|
}
|
|
|
|
$rwhere = " and a.dokart_kuerzel in ( ".$rwhere." )";
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
$STATEMENT = "select i.alpha_01, i.alpha_02, i.alpha_03, i.alpha_04, i.alpha_05, i.alpha_06, i.alpha_07, i.alpha_08, i.alpha_09, i.alpha_10, i.alpha_11, i.alpha_12, i.alpha_13, i.alpha_14, i.alpha_15, i.alpha_16, i.alpha_17, i.alpha_18, i.alpha_19, i.alpha_20, i.alpha_21, i.alpha_22, i.alpha_23, i.alpha_24, i.alpha_25, i.alpha_26, i.alpha_27, i.alpha_28, i.alpha_29, i.alpha_30, i.datum_01, i.datum_02, i.datum_03, i.datum_04, i.datum_05, i.datum_06, i.datum_07, i.datum_08, i.datum_09, i.datum_10, i.num_01, i.num_02, i.num_03, i.num_04, i.num_05, i.num_06, i.num_07, i.num_08, i.num_09, i.num_10, i.geld_01, i.geld_02, i.geld_03, i.geld_04, i.geld_05, i.geld_06, i.geld_07, i.geld_08, i.geld_09, i.geld_10, a.archivierungsdatum archivierungsdatum, i.dok_id dok_id, a.kennung kennung, a.a_flag a_flag, a.v_flag v_flag, a.j_flag j_flag, a.n_flag n_flag, a.dokart_kuerzel dokart_kuerzel, a.mandant_id mandant_id, c.md5 md5, c.mime_type mime_type, a.eigentuemer eigentuemer, a.aktueller_besitzer aktueller_besitzer, a.sperr_status sperr_status, a.sperr_beginn sperr_beginn, a.sperr_benutzer sperr_benutzer, a.titel titel, a.titel_lang titell_lang, a.system_flags system_flags, c.ursprungs_dateiname ursprungs_dateiname, c.groesse groesse from ca_index i, ca_dok_ablage a, ca_dok_datei c where (a.mandant_id = ".$ok_1[ 0 ].") and ( c.dok_id = a.dok_id and i.dok_id = c.dok_id and c.version = a.d_version and a.status in ( 'offen' ) and c.erw = 0 ) ".$dwhere." ".$awhere." ".$iwhere." ".$rwhere." order by a.dokart_kuerzel ";
|
|
|
|
//xlog( 1, $STATEMENT );
|
|
|
|
/*
|
|
$archdatum_gefunden = 0;
|
|
$volltext_gefunden = false;
|
|
|
|
$where = "";
|
|
|
|
foreach ( $stichwoerter as $attrib_array )
|
|
{
|
|
if ( ( $attrib_array[ "feld" ] == "archivierungsdatum" ) and ( strlen( $attrib_array[ "wert" ] ) > 0 ) and $archdatum_gefunden < 2 )
|
|
{
|
|
$archdatum_gefunden++;
|
|
|
|
switch ( $attrib_array[ "operator" ] )
|
|
{
|
|
case "EQUAL":
|
|
$verknuepfung = " = ";
|
|
break;
|
|
case "NOT_EQUAL":
|
|
$verknuepfung = " <> ";
|
|
break;
|
|
case "GREATER":
|
|
$verknuepfung = " > ";
|
|
break;
|
|
case "GREATER_OR_EQUAL":
|
|
$verknuepfung = " >= ";
|
|
break;
|
|
case "SMALLER":
|
|
$verknuepfung = " < ";
|
|
break;
|
|
case "SMALLER_OR_EQUAL":
|
|
$verknuepfung = " <= ";
|
|
break;
|
|
default:
|
|
$verknuepfung = " = ";
|
|
break;
|
|
}
|
|
|
|
$archdat = strtotime( $attrib_array[ "wert" ] );
|
|
|
|
$where = $where." and a.archivierungsdatum ".$verknuepfung." '".$archdat."'";
|
|
}
|
|
|
|
if ( ( $attrib_array[ "feld" ] == "volltext" ) and ( strlen( $attrib_array[ "wert" ] ) > 0 ) and $volltext_gefunden == false )
|
|
{
|
|
$volltext_gefunden = true;
|
|
|
|
$vollwert = explode( " ", $attrib_array[ "wert" ] );
|
|
|
|
$wortwhere = "";
|
|
|
|
foreach( $vollwert as $einzelwort )
|
|
{
|
|
$wortwhere = $wortwhere."'".$einzelwort."', ";
|
|
}
|
|
|
|
$wortwhere = substr( $wortwhere, 0, strlen( $wortwhere ) -2 );
|
|
|
|
// typ = 1 => Volltextwort
|
|
// typ = 5 => Tag
|
|
// ist hier aber nicht wichtig. ;-/
|
|
|
|
$where = $where." and i.dok_id in ( select dok_id from ca_wort where wort in ( ".$wortwhere." ) ) ";
|
|
|
|
}
|
|
|
|
}
|
|
// a.md5 md5,
|
|
$select = "select a.archivierungsdatum archivierungsdatum, i.dok_id dok_id, a.kennung kennung, a.dokart_kuerzel dokart_kuerzel, d.dokart_name dokart_name, a.mandant_id mandant_id, a.mime_type mime_type, a.eigentuemer eigentuemer, a.aktueller_besitzer aktueller_besitzer, a.sperr_status sperr_status, a.sperr_beginn sperr_beginn, a.sperr_benutzer sperr_benutzer, a.system_flags system_flags, a.ursprungs_dateiname ursprungs_dateiname ".$dok_hol;
|
|
$from = " from ca_index i, ca_dok_ablage a where ";
|
|
$where = " a.dokart_kuerzel = '".$dokart_kuerzel."' and a.mandant_id = ".$ok_1[ 0 ]." and i.dok_id = a.dok_id ".$where;
|
|
|
|
$STATEMENT = $select.$from.$where;
|
|
|
|
*/
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
$ergebnisarr = array();
|
|
$rc = -15;
|
|
$meldung = "Fehler in kundenspezifischer Einsprungfunktion / pre_recherche_1:".$meldung_pr1;
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
//$select = substr( $select, 0, strlen( $select ) - 2 )." ";
|
|
|
|
if ( $anzahl_treffer > 0 )
|
|
{
|
|
$STATEMENT = $STATEMENT." limit 0, ".$anzahl_treffer;
|
|
}
|
|
|
|
xlog( 1, $STATEMENT );
|
|
|
|
if ( $rc == -15 )
|
|
{
|
|
$ergebnis[ 0 ] = $rc;
|
|
$ergebnis[ 1 ] = $meldung;
|
|
}
|
|
else
|
|
{
|
|
$ergebnis = xdb( $STATEMENT );
|
|
}
|
|
|
|
if ( $ergebnis[ 0 ] == 0 )
|
|
{
|
|
$rc = 0;
|
|
$ergebnisarr = array();
|
|
$meldung = "Es wurden keine Dokumente zur Suchanfrage gefunden.";
|
|
}
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
$rc = $ergebnis[ 0 ];
|
|
//$ergebnisarr = $ergebnis[ 1 ];
|
|
foreach ( $ergebnis[ 1 ] as $treffer )
|
|
{
|
|
foreach ( $treffer as $schluessel => $wert )
|
|
{
|
|
$typ = explode( "_", $schluessel );
|
|
$typ = $typ[ 0 ];
|
|
|
|
switch ( $typ )
|
|
{
|
|
case "num":
|
|
$wert = trim( $wert, "0" );
|
|
$wert = trim( $wert, "," );
|
|
if ( $wert <> "" )
|
|
{
|
|
$zeile[ $schluessel ] = str_replace( ".", ",", $wert );
|
|
}
|
|
else
|
|
{
|
|
$zeile[ $schluessel ] = "";
|
|
}
|
|
break;
|
|
case "geld":
|
|
$wert = trim( $wert, "0" );
|
|
$wert = trim( $wert, "," );
|
|
if ( ( $wert <> "" ) && ( $wert <> "." ) )
|
|
{
|
|
$wert = number_format( $wert , 2 , ',' , '' );
|
|
|
|
$zeile[ $schluessel ] = str_replace( ".", ",", $wert );
|
|
}
|
|
else
|
|
{
|
|
$zeile[ $schluessel ] = "";
|
|
}
|
|
break;
|
|
case "archivierungsdatum":
|
|
$zeile[ $schluessel ] = date( "d.m.Y H:i", $wert );
|
|
//xlog( 3, "archivierungsdatum ".$zeile[ $schluessel ] );
|
|
break;
|
|
case "datum":
|
|
$zeile[ $schluessel ] = mysql2datum( $wert );
|
|
break;
|
|
case "alpha":
|
|
default:
|
|
$zeile[ $schluessel ] = $wert;
|
|
break;
|
|
}
|
|
|
|
//xlog( 3, "typ ".$typ );
|
|
|
|
}
|
|
|
|
$funcname = "func_".$ok_1[ 0 ]."_post_recherche_1";
|
|
|
|
if ( function_exists( $funcname ) )
|
|
{
|
|
$erg = $funcname( $dokart_kuerzel, $zeile );
|
|
}
|
|
else
|
|
{
|
|
$erg[ 0 ] = 0;
|
|
$erg[ 1 ] = $zeile;
|
|
}
|
|
|
|
|
|
if ( $erg[ 0 ] == 0 )
|
|
{
|
|
$ergebnisarr[] = $erg[ 1 ];
|
|
}
|
|
}
|
|
|
|
//xlog( 4, " ergebnisarr ".json_encode( $ergebnisarr ) );
|
|
|
|
$meldung = "Liefere ".$rc." Dokumente zur Suchanfrage.";
|
|
}
|
|
|
|
if ( $ergebnis[ 0 ] < 0 )
|
|
{
|
|
$rc = $ergebnis[ 0 ];
|
|
$ergebnisarr = array();
|
|
$meldung = "Es ist ein Fehler aufgetreten: ".$ergebnis[ 1 ];
|
|
}
|
|
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = -1;
|
|
$meldung = "Es wurden keine Such-Stichwörter angegeben.";
|
|
}
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = $benutzer_ok[ 0 ];
|
|
$meldung = $benutzer_ok[ 1 ];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = $ok_1[ 1 ];
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.variable_recherche: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung, $ergebnisarr );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function liefere_dokumentinformationen( $mandant_name, $dok_id )
|
|
{
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
if ( strlen( $dok_id ) > 0 )
|
|
{
|
|
//$STATEMENT = "select i.alpha_01, i.alpha_02, i.alpha_03, i.alpha_04, i.alpha_05, i.alpha_06, i.alpha_07, i.alpha_08, i.alpha_09, i.alpha_10, i.alpha_11, i.alpha_12, i.alpha_13, i.alpha_14, i.alpha_15, i.alpha_16, i.alpha_17, i.alpha_18, i.alpha_19, i.alpha_20, i.alpha_21, i.alpha_22, i.alpha_23, i.alpha_24, i.alpha_25, i.alpha_26, i.alpha_27, i.alpha_28, i.alpha_29, i.alpha_30, i.num_01, i.num_02, i.num_03, i.num_04, i.num_05, i.datum_01, i.datum_02, i.datum_03, i.datum_04, i.datum_05, i.geld_01, i.geld_02, i.geld_03, i.geld_04, i.geld_05, i.text_01, a.dokart_kuerzel, a.depot, a.abl_verfahren, a.groesse, a.md5, a.mime_type, a.archivierungsdatum, a.sperr_status, a.sperr_beginn, a.sperr_benutzer, a.system_flags, a.ursprungs_dateiname, b.benutzer_anmeldename eigentuemer, d.benutzer_anmeldename aktueller_besitzer from ca_index i, ca_dok_ablage a, ca_benutzer b, ca_benutzer d where i.dok_id = ".$dok_id." and a.dok_id = ".$dok_id." and i.dok_id = a.dok_id and a.eigentuemer = b.benutzer_id and a.aktueller_besitzer = d.benutzer_id";
|
|
|
|
$STATEMENT = "select i.alpha_01, i.alpha_02, i.alpha_03, i.alpha_04, i.alpha_05, i.alpha_06, i.alpha_07, i.alpha_08, i.alpha_09, i.alpha_10, i.alpha_11, i.alpha_12, i.alpha_13, i.alpha_14, i.alpha_15, i.alpha_16, i.alpha_17, i.alpha_18, i.alpha_19, i.alpha_20, i.alpha_21, i.alpha_22, i.alpha_23, i.alpha_24, i.alpha_25, i.alpha_26, i.alpha_27, i.alpha_28, i.alpha_29, i.alpha_30, i.num_01, i.num_02, i.num_03, i.num_04, i.num_05, i.datum_01, i.datum_02, i.datum_03, i.datum_04, i.datum_05, i.geld_01, i.geld_02, i.geld_03, i.geld_04, i.geld_05, i.text_01, a.kennung, a.dokart_kuerzel, a.depot, c.abl_verfahren, c.groesse, c.md5, c.mime_type, a.archivierungsdatum, a.sperr_status, a.sperr_beginn, a.sperr_benutzer, a.a_flag, a.v_flag, a.n_flag, a.j_flag, a.w_flag, a.titel, a.titel_lang, a.system_flags, a.d_version, a.k_version k_version, c.ursprungs_dateiname, b.benutzer_anmeldename eigentuemer, d.benutzer_anmeldename aktueller_besitzer from ca_index i, ca_dok_datei c, ca_dok_ablage a, ca_benutzer b, ca_benutzer d where i.dok_id = ".$dok_id." and a.dok_id = ".$dok_id." and i.dok_id = a.dok_id and a.eigentuemer = b.benutzer_id and a.aktueller_besitzer = d.benutzer_id and i.dok_id = c.dok_id and a.d_version = c.version";
|
|
|
|
//xlog( 1, $STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
$ergebnis_arr = array();
|
|
|
|
//xlog(5, json_encode( $ergebnis ) );
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
$dokart = liefere_dokartinformationen( $mandant_name, $ergebnis[ 1 ][ 0 ][ "dokart_kuerzel" ] );
|
|
|
|
$titel = "";
|
|
|
|
foreach( $dokart[ 2 ][ "attribute" ] as $attribut )
|
|
{
|
|
/*
|
|
if ( ( $attribut[ "attrib_titel" ] == true ) && ( strlen( $ergebnis[ 1 ][ 0 ][ $attribut[ "attrib_db_spalte" ] ] ) > 0 ) )
|
|
{
|
|
$titel = $titel.$ergebnis[ 1 ][ 0 ][ $attribut[ "attrib_db_spalte" ] ]." | ";
|
|
}
|
|
*/
|
|
|
|
switch( $attribut[ "attrib_typ" ] )
|
|
{
|
|
case "alpha":
|
|
case "text":
|
|
$ergebnis_arr[ $attribut[ "attrib_db_spalte" ] ] = $ergebnis[ 1 ][ 0 ][ $attribut[ "attrib_db_spalte" ] ];
|
|
break;
|
|
case "num":
|
|
$wert = trim( $ergebnis[ 1 ][ 0 ][ $attribut[ "attrib_db_spalte" ] ], "0" );
|
|
|
|
$attrib_laenge = $attribut[ "attrib_laenge" ];
|
|
$attrib_einheit = $attribut[ "attrib_einheit" ];
|
|
|
|
if ( strlen( $attrib_einheit ) > 0 )
|
|
{
|
|
$attrib_einheit = " ".$attrib_einheit;
|
|
}
|
|
|
|
if ( $attribut[ "attrib_laenge" ] != "" )
|
|
{
|
|
$attrib_laenge = $attribut[ "attrib_laenge" ];
|
|
}
|
|
|
|
$wert = str_replace( ",", ".", $wert );
|
|
|
|
$wert = number_format( (float) $wert, $attrib_laenge, ",", "." );
|
|
$ergebnis_arr[ $attribut[ "attrib_db_spalte" ] ] = $wert;
|
|
break;
|
|
case "geld":
|
|
$ergebnis_arr[ $attribut[ "attrib_db_spalte" ] ] = str_replace( ".", ",", $ergebnis[ 1 ][ 0 ][ $attribut[ "attrib_db_spalte" ] ] );
|
|
break;
|
|
case "datum":
|
|
$ergebnis_arr[ $attribut[ "attrib_db_spalte" ] ] = mysql2datum( $ergebnis[ 1 ][ 0 ][ $attribut[ "attrib_db_spalte" ] ] );
|
|
break;
|
|
case "p_alpha":
|
|
case "p_datum":
|
|
case "p_num":
|
|
case "p_geld":
|
|
$p_arr[] = $attribut[ "attrib_db_spalte" ];
|
|
$p_liste = $p_liste." ".$attribut[ "attrib_db_spalte" ].", ";
|
|
break;
|
|
}
|
|
|
|
$ergebnis_arr[ "Name_".$attribut[ "attrib_db_spalte" ] ] = $attribut[ "attrib_name" ];
|
|
}
|
|
|
|
//$titel = substr( $titel, 0, -3 );
|
|
|
|
$ergebnis_arr[ "dokart_kuerzel" ] = $ergebnis[ 1 ][ 0 ][ "dokart_kuerzel" ];
|
|
$ergebnis_arr[ "depot" ] = $ergebnis[ 1 ][ 0 ][ "depot" ];
|
|
$ergebnis_arr[ "abl_verfahren" ] = $ergebnis[ 1 ][ 0 ][ "abl_verfahren" ];
|
|
$ergebnis_arr[ "groesse" ] = $ergebnis[ 1 ][ 0 ][ "groesse" ];
|
|
$ergebnis_arr[ "md5" ] = $ergebnis[ 1 ][ 0 ][ "md5" ];
|
|
$ergebnis_arr[ "mime_type" ] = $ergebnis[ 1 ][ 0 ][ "mime_type" ];
|
|
$ergebnis_arr[ "d_version" ] = $ergebnis[ 1 ][ 0 ][ "d_version" ];
|
|
$ergebnis_arr[ "k_version" ] = $ergebnis[ 1 ][ 0 ][ "k_version" ];
|
|
$ergebnis_arr[ "kennung" ] = $ergebnis[ 1 ][ 0 ][ "kennung" ];
|
|
$ergebnis_arr[ "archivierungsdatum" ] = $ergebnis[ 1 ][ 0 ][ "archivierungsdatum" ];
|
|
$ergebnis_arr[ "sperr_status" ] = $ergebnis[ 1 ][ 0 ][ "sperr_status" ];
|
|
$ergebnis_arr[ "sperr_beginn" ] = $ergebnis[ 1 ][ 0 ][ "sperr_beginn" ];
|
|
$ergebnis_arr[ "sperr_benutzer" ] = $ergebnis[ 1 ][ 0 ][ "sperr_benutzer" ];
|
|
$ergebnis_arr[ "system_flags" ] = $ergebnis[ 1 ][ 0 ][ "system_flags" ];
|
|
$ergebnis_arr[ "ursprungs_dateiname" ] = $ergebnis[ 1 ][ 0 ][ "ursprungs_dateiname" ];
|
|
$ergebnis_arr[ "eigentuemer" ] = $ergebnis[ 1 ][ 0 ][ "eigentuemer" ];
|
|
$ergebnis_arr[ "aktueller_besitzer" ] = $ergebnis[ 1 ][ 0 ][ "aktueller_besitzer" ];
|
|
$ergebnis_arr[ "in_akte" ] = $ergebnis[ 1 ][ 0 ][ "a_flag" ];
|
|
$ergebnis_arr[ "notizen_vorhanden" ] = $ergebnis[ 1 ][ 0 ][ "n_flag" ];
|
|
$ergebnis_arr[ "weitere_versionen" ] = $ergebnis[ 1 ][ 0 ][ "v_flag" ];
|
|
$ergebnis_arr[ "pic_resize" ] = $ergebnis[ 1 ][ 0 ][ "j_flag" ];
|
|
$ergebnis_arr[ "workflow" ] = $ergebnis[ 1 ][ 0 ][ "w_flag" ];
|
|
|
|
$ergebnis_arr[ "titel" ] = $ergebnis[ 1 ][ 0 ][ "titel" ];;
|
|
$ergebnis_arr[ "titel_lang" ] = $ergebnis[ 1 ][ 0 ][ "titel_lang" ];;
|
|
$ergebnis_arr[ "dokart_typ" ] = $dokart[ 2 ][ "dokart_typ" ];
|
|
$ergebnis_arr[ "dok_id" ] = $dok_id;
|
|
$ergebnis_arr[ "dokart" ] = $dokart[ 2 ];
|
|
$ergebnis_arr[ "attribute" ] = $dokart[ 2 ][ "attribute" ];
|
|
|
|
|
|
$STATEMENT = "select ".$p_liste." dok_id from ca_posdaten where dok_id = ".$dok_id;
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
$mehrfachattribute = array();
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
$i = 0;
|
|
foreach( $ergebnis[ 1 ] as $trefferzeile )
|
|
{
|
|
$i++;
|
|
$zeile = array();
|
|
foreach( $trefferzeile as $feld=>$wert )
|
|
{
|
|
//xlog( 4, $i." Feld ".$feld." Wert ".$wert );
|
|
|
|
$f = explode( "_", $feld );
|
|
|
|
$f = $f[ 0 ]."_".$f[ 1 ];
|
|
|
|
switch ( $f )
|
|
{
|
|
case "p_alpha":
|
|
case "p_num":
|
|
case "p_geld":
|
|
$zeile[ $feld ] = $wert;
|
|
break;
|
|
case "p_datum":
|
|
$zeile[ $feld ] = mysql2datum( $wert );
|
|
break;
|
|
}
|
|
|
|
}
|
|
$mehrfachattribute[] = $zeile;
|
|
}
|
|
}
|
|
|
|
$ergebnis_arr[ "mehrfachattribute" ] = $mehrfachattribute;
|
|
|
|
$rc = $dok_id;
|
|
$meldung = "Liefere Informationen über Dokument ".$dok_id." im Mandanten ".$mandant_name.".";
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = -10;
|
|
$meldung = "Es ist ein Fehler aufgetreten: ".$ergebnis[ 1 ];
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = -2;
|
|
$meldung = "Es wurde keine Dokument-ID angegeben.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = $ok_1[ 1 ];
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.liefere_dokumentinformationen: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung, $ergebnis_arr );
|
|
}
|
|
|
|
function liefere_dokumentinformationen_multi( $mandant_name, $dok_ids, $dokart = "" )
|
|
{
|
|
//
|
|
// $dokart muss als Ergebnis der Funktion liefere_dokartinformationen() übergeben werden
|
|
// Die Funktion geht davon aus, dass die übergebenen dok_ids alle zu einer dokart gehören
|
|
// Ist das nicht der Fall, sind die Ergebnisse wahrscheinlich seltsam (nicht getestet).
|
|
//
|
|
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
if ( ( is_array( $dok_ids ) ) and ( count( $dok_ids ) > 0 ) )
|
|
{
|
|
//$STATEMENT = "select i.alpha_01, i.alpha_02, i.alpha_03, i.alpha_04, i.alpha_05, i.alpha_06, i.alpha_07, i.alpha_08, i.alpha_09, i.alpha_10, i.alpha_11, i.alpha_12, i.alpha_13, i.alpha_14, i.alpha_15, i.alpha_16, i.alpha_17, i.alpha_18, i.alpha_19, i.alpha_20, i.alpha_21, i.alpha_22, i.alpha_23, i.alpha_24, i.alpha_25, i.alpha_26, i.alpha_27, i.alpha_28, i.alpha_29, i.alpha_30, i.num_01, i.num_02, i.num_03, i.num_04, i.num_05, i.datum_01, i.datum_02, i.datum_03, i.datum_04, i.datum_05, i.geld_01, i.geld_02, i.geld_03, i.geld_04, i.geld_05, i.text_01, a.dokart_kuerzel, a.depot, a.abl_verfahren, a.groesse, a.md5, a.mime_type, a.archivierungsdatum, a.sperr_status, a.sperr_beginn, a.sperr_benutzer, a.system_flags, a.ursprungs_dateiname, b.benutzer_anmeldename eigentuemer, d.benutzer_anmeldename aktueller_besitzer from ca_index i, ca_dok_ablage a, ca_benutzer b, ca_benutzer d where i.dok_id = ".$dok_id." and a.dok_id = ".$dok_id." and i.dok_id = a.dok_id and a.eigentuemer = b.benutzer_id and a.aktueller_besitzer = d.benutzer_id";
|
|
|
|
$where = " ( ";
|
|
|
|
//xlog( 4, json_encode( $dok_ids ) );
|
|
|
|
$z = 0;
|
|
|
|
foreach ( $dok_ids as $dok_id )
|
|
{
|
|
$where = $where." ".$dok_id.", ";
|
|
$z++;
|
|
if ( $z >= 10000 )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
$where = substr( $where, 0, -2)." ) ";
|
|
|
|
$STATEMENT = "select i.dok_id, i.alpha_01, i.alpha_02, i.alpha_03, i.alpha_04, i.alpha_05, i.alpha_06, i.alpha_07, i.alpha_08, i.alpha_09, i.alpha_10, i.alpha_11, i.alpha_12, i.alpha_13, i.alpha_14, i.alpha_15, i.alpha_16, i.alpha_17, i.alpha_18, i.alpha_19, i.alpha_20, i.alpha_21, i.alpha_22, i.alpha_23, i.alpha_24, i.alpha_25, i.alpha_26, i.alpha_27, i.alpha_28, i.alpha_29, i.alpha_30, i.num_01, i.num_02, i.num_03, i.num_04, i.num_05, i.datum_01, i.datum_02, i.datum_03, i.datum_04, i.datum_05, i.geld_01, i.geld_02, i.geld_03, i.geld_04, i.geld_05, i.text_01, a.kennung, a.dokart_kuerzel, a.depot, c.abl_verfahren, c.groesse, c.md5, c.mime_type, a.archivierungsdatum, a.sperr_status, a.sperr_beginn, a.sperr_benutzer, a.a_flag, a.v_flag, a.n_flag, a.j_flag, a.system_flags, a.titel, a.titel_lang, a.d_version, a.k_version k_version, c.ursprungs_dateiname, b.benutzer_anmeldename eigentuemer, d.benutzer_anmeldename aktueller_besitzer, o.dokart_name from ca_index i, ca_dok_datei c, ca_dok_ablage a, ca_benutzer b, ca_benutzer d, ca_dokart o where i.dok_id in ".$where." and a.dok_id in ".$where." and i.dok_id = a.dok_id and a.eigentuemer = b.benutzer_id and a.aktueller_besitzer = d.benutzer_id and i.dok_id = c.dok_id and a.d_version = c.version and c.erw = 0 and o.dokart_kuerzel = a.dokart_kuerzel and o.mandant_id = ".$ok_1[ 0 ]." and a.mandant_id = ".$ok_1[ 0 ];
|
|
|
|
//xlog( 1, $STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
$ergebnis_arr = array();
|
|
|
|
//xlog(5, json_encode( $ergebnis ) );
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
if ( ! is_array( $dokart ) )
|
|
{
|
|
$dokart = liefere_dokartinformationen( $mandant_name, $ergebnis[ 1 ][ 0 ][ "dokart_kuerzel" ] );
|
|
}
|
|
|
|
$trefferbande = array();
|
|
|
|
foreach ( $ergebnis[ 1 ] as $treffer )
|
|
{
|
|
|
|
//$titel = "";
|
|
|
|
foreach( $dokart[ 2 ][ "attribute" ] as $attribut )
|
|
{
|
|
|
|
|
|
|
|
switch( $attribut[ "attrib_typ" ] )
|
|
{
|
|
case "alpha":
|
|
$ergebnis_arr[ $attribut[ "attrib_db_spalte" ] ] = $treffer[ $attribut[ "attrib_db_spalte" ] ];
|
|
break;
|
|
case "num":
|
|
$attrib_laenge = $attribut[ "attrib_laenge" ];
|
|
$attrib_einheit = $attribut[ "attrib_einheit" ];
|
|
|
|
if ( strlen( $attrib_einheit ) > 0 )
|
|
{
|
|
$attrib_einheit = " ".$attrib_einheit;
|
|
}
|
|
|
|
$wert = number_format( (float) $treffer[ $attribut[ "attrib_db_spalte" ] ], $attrib_laenge, ",", "." );
|
|
|
|
$ergebnis_arr[ $attribut[ "attrib_db_spalte" ] ] = $wert.$attrib_einheit;
|
|
break;
|
|
case "geld":
|
|
$ergebnis_arr[ $attribut[ "attrib_db_spalte" ] ] = str_replace( ".", ",", $treffer[ $attribut[ "attrib_db_spalte" ] ] );
|
|
break;
|
|
case "datum":
|
|
$ergebnis_arr[ $attribut[ "attrib_db_spalte" ] ] = mysql2datum( $treffer[ $attribut[ "attrib_db_spalte" ] ] );
|
|
break;
|
|
}
|
|
|
|
$ergebnis_arr[ "Name_".$attribut[ "attrib_db_spalte" ] ] = $attribut[ "attrib_name" ];
|
|
}
|
|
|
|
//$titel = substr( $titel, 0, -3 );
|
|
|
|
$ergebnis_arr[ "dokart_kuerzel" ] = $treffer[ "dokart_kuerzel" ];
|
|
$ergebnis_arr[ "dokart_name" ] = $treffer[ "dokart_name" ];
|
|
$ergebnis_arr[ "depot" ] = $treffer[ "depot" ];
|
|
$ergebnis_arr[ "abl_verfahren" ] = $treffer[ "abl_verfahren" ];
|
|
$ergebnis_arr[ "groesse" ] = $treffer[ "groesse" ];
|
|
$ergebnis_arr[ "md5" ] = $treffer[ "md5" ];
|
|
$ergebnis_arr[ "mime_type" ] = $treffer[ "mime_type" ];
|
|
$ergebnis_arr[ "d_version" ] = $treffer[ "d_version" ];
|
|
$ergebnis_arr[ "k_version" ] = $treffer[ "k_version" ];
|
|
$ergebnis_arr[ "kennung" ] = $treffer[ "kennung" ];
|
|
$ergebnis_arr[ "archivierungsdatum" ] = $treffer[ "archivierungsdatum" ];
|
|
$ergebnis_arr[ "sperr_status" ] = $treffer[ "sperr_status" ];
|
|
$ergebnis_arr[ "sperr_beginn" ] = $treffer[ "sperr_beginn" ];
|
|
$ergebnis_arr[ "sperr_benutzer" ] = $treffer[ "sperr_benutzer" ];
|
|
$ergebnis_arr[ "system_flags" ] = $treffer[ "system_flags" ];
|
|
$ergebnis_arr[ "ursprungs_dateiname" ] = $treffer[ "ursprungs_dateiname" ];
|
|
$ergebnis_arr[ "eigentuemer" ] = $treffer[ "eigentuemer" ];
|
|
$ergebnis_arr[ "aktueller_besitzer" ] = $treffer[ "aktueller_besitzer" ];
|
|
$ergebnis_arr[ "in_akte" ] = $treffer[ "a_flag" ];
|
|
$ergebnis_arr[ "a_flag" ] = $treffer[ "a_flag" ];
|
|
$ergebnis_arr[ "notizen_vorhanden" ] = $treffer[ "n_flag" ];
|
|
$ergebnis_arr[ "n_flag" ] = $treffer[ "n_flag" ];
|
|
$ergebnis_arr[ "weitere_versionen" ] = $treffer[ "v_flag" ];
|
|
$ergebnis_arr[ "v_flag" ] = $treffer[ "v_flag" ];
|
|
$ergebnis_arr[ "pic_resize" ] = $treffer[ "j_flag" ];
|
|
$ergebnis_arr[ "j_flag" ] = $treffer[ "j_flag" ];
|
|
$ergebnis_arr[ "dokart_typ" ] = $dokart[ 2 ][ "dokart_typ" ];
|
|
$ergebnis_arr[ "titel" ] = $treffer[ "titel" ];
|
|
$ergebnis_arr[ "titel_lang" ] = $treffer[ "titel_lang" ];
|
|
$ergebnis_arr[ "dok_id" ] = $treffer[ "dok_id" ];
|
|
|
|
$trefferbande[ ] = $ergebnis_arr;
|
|
}
|
|
$rc = $dok_id;
|
|
$meldung = "Liefere Informationen über ".count( $dok_ids )." Dokumente im Mandanten ".$mandant_name.".";
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = -10;
|
|
$meldung = "Es ist ein Fehler aufgetreten: ".$ergebnis[ 1 ];
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = -2;
|
|
$meldung = "Es wurde keine Dokument-ID angegeben.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = $ok_1[ 1 ];
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.liefere_dokumentinformationen_multi: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung, $trefferbande );
|
|
}
|
|
|
|
function in_welcher_dokart_sind_dokumente( $mandant_name, $dok_ids )
|
|
{
|
|
/*
|
|
|
|
|
|
*/
|
|
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
if ( ( is_array( $dok_ids ) ) and ( count( $dok_ids ) > 0 ) )
|
|
{
|
|
//$STATEMENT = "select i.alpha_01, i.alpha_02, i.alpha_03, i.alpha_04, i.alpha_05, i.alpha_06, i.alpha_07, i.alpha_08, i.alpha_09, i.alpha_10, i.alpha_11, i.alpha_12, i.alpha_13, i.alpha_14, i.alpha_15, i.alpha_16, i.alpha_17, i.alpha_18, i.alpha_19, i.alpha_20, i.alpha_21, i.alpha_22, i.alpha_23, i.alpha_24, i.alpha_25, i.alpha_26, i.alpha_27, i.alpha_28, i.alpha_29, i.alpha_30, i.num_01, i.num_02, i.num_03, i.num_04, i.num_05, i.datum_01, i.datum_02, i.datum_03, i.datum_04, i.datum_05, i.geld_01, i.geld_02, i.geld_03, i.geld_04, i.geld_05, i.text_01, a.dokart_kuerzel, a.depot, a.abl_verfahren, a.groesse, a.md5, a.mime_type, a.archivierungsdatum, a.sperr_status, a.sperr_beginn, a.sperr_benutzer, a.system_flags, a.ursprungs_dateiname, b.benutzer_anmeldename eigentuemer, d.benutzer_anmeldename aktueller_besitzer from ca_index i, ca_dok_ablage a, ca_benutzer b, ca_benutzer d where i.dok_id = ".$dok_id." and a.dok_id = ".$dok_id." and i.dok_id = a.dok_id and a.eigentuemer = b.benutzer_id and a.aktueller_besitzer = d.benutzer_id";
|
|
|
|
$where = " ( ";
|
|
|
|
//xlog( 4, json_encode( $dok_ids ) );
|
|
|
|
$z = 0;
|
|
|
|
foreach ( $dok_ids as $dok_id )
|
|
{
|
|
$where = $where." ".$dok_id.", ";
|
|
$z++;
|
|
if ( $z >= 10000 )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
$where = substr( $where, 0, -2)." ) ";
|
|
|
|
$STATEMENT = "select ab.dok_id, ab.dokart_kuerzel from ca_dok_ablage ab where dok_id in ".$where." order by ab.dokart_kuerzel";
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
xlog( 5, $ergebnis[ 0 ] );
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
|
|
$dokart = "dummydokumentart_laengeralserlaubt";
|
|
|
|
$trefferbande = array();
|
|
|
|
foreach( $ergebnis[ 1 ] as $treffer )
|
|
{
|
|
if ( $dokart != $treffer[ "dokart_kuerzel" ] )
|
|
{
|
|
if ( $dokart != "dummydokumentart_laengeralserlaubt" )
|
|
{
|
|
$trefferbande[ $dokart ] = $treffersammlung;
|
|
}
|
|
$treffersammlung = array();
|
|
$dokart = $treffer[ "dokart_kuerzel" ];
|
|
}
|
|
$treffersammlung[] = $treffer[ "dok_id" ];
|
|
}
|
|
|
|
$rc = count( $trefferbande );
|
|
$meldung = "Liefere ".$rc." Dokumentarten mit den entsprechenden Dokumenten.";
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
$trefferbande = array();
|
|
$rc = -1;
|
|
$meldung = "Es ist ein Fehler aufgetreten: ".$ergebnis[ 1 ];
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$trefferbande = array();
|
|
$rc = -2;
|
|
$meldung = "Es wurde keine gültige Dokument-ID-Liste übergeben.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = $ok_1[ 1 ];
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.in_welcher_dokart_sind_dokumente: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung, $trefferbande );
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function import( $mandant_name, $dokart_kuerzel, $kennung, $attribute, $mehrfachattribute = array(), $dokument_binary = "", $optionen = array() )
|
|
{
|
|
/******************
|
|
BESCHREIBUNG_____Mit dieser Funktion werden Dokumente importiert. Achtung: Die Funktion ist (noch) nicht transaktionssicher!
|
|
RETURNS_____Erfolgsfall: array( (integer) Returncode (erzeugte Dokument-ID), (string) Meldung, (array) Liste der erzeugten Positions-IDs )
|
|
******************/
|
|
|
|
//$optionen ist ein Array, welches folgendes enthalten kann: mime_typ, ursprungs_dateiname, fremdsystem_1, fremdsystem_2, fremdsystem_3, fremdsystem_4, fremdsystem_5
|
|
/****************************************************
|
|
|
|
Mit dieser Funktion soll die eigentliche Übernahme erfolgen.
|
|
|
|
****************************************************
|
|
|
|
$attribute ist ein Array, welches folgenden Aufbau haben muß:
|
|
import( $mandant_name, $dokart_kuerzel, $kennung, $attribute, $mehrfachattribute, $dokument_binary, $optionen )
|
|
array( alpha_01 => "Wert", alpha_02 => "Wert", alpha_03 => "Wert", ..., num_01 => Zahl, num_02 => Zahl, num_03 => Zahl, ..., datum_01 => "TT.MM.YYYY", datum_02 => "TT.MM.YYYY", ..., geld_01 = "123,45",
|
|
geld_02 => "234,56", geld_03 => "456,78", ...)
|
|
|
|
****************************************************
|
|
|
|
$mehrfachattribute hat folgenden Aufbau:
|
|
|
|
array( array( p_alpha_01 => "Wert", p_alpha_02 = "Wert", ...), array( p_alpha_01 => "Wert", p_alpha_02 = "Wert"...), array( p_alpha_01 => "Wert", p_alpha_02 => "Wert", ...))
|
|
|
|
Nicht ganz einfach, aber was ist schon einfach ???
|
|
|
|
Diese Funktion erzeugt mehrere Inserts in die passenden Tabellen.
|
|
|
|
****************************************************
|
|
|
|
Optionale Parameter sind die Attribute sowie das Dokument-Binary. Werden beide weggelassen, wird ein Insert mit dem Pflichtfeld dok_typ in die Tabelle ca_index erzeugt.
|
|
|
|
Zurückgegeben wird ein Array aus der erzeugten dok_id und einer Meldung (bei Fehler ein negativer Wert anstelle der dok_id zusammen mit einer Meldung), außerdem die ggf. erzeugten Positions-IDs.
|
|
|
|
****************************************************
|
|
|
|
|
|
****************************************************
|
|
|
|
$optionen[ "ursprungs_dateiname" ] = $dokument_meta[ "file" ][ "name" ];
|
|
$optionen[ "mime_type" ] = $dokument_meta[ "file" ][ "type" ];
|
|
$optionen[ "dateigroesse" ] = $dokument_meta[ "file" ][ "size" ];
|
|
$optionen[ "datei_erw_typ" ] = "";
|
|
|
|
Falls datei_erw_typ == "1" ist, handelt es sich um ein Dokument, welches eine vom Job-Typ pic_resize erstellt worden ist und auf einem bereits im System bestehenden Dokument basiert. Daher muss dann
|
|
eine Kennung angegeben sein.
|
|
|
|
Man könnte auch sagen: ob datei_erw_typ angegeben ist, ist nur relevant, wenn eine Kennung angegeben wurde.
|
|
|
|
Dokumente, bei denen datei_erw_typ == "gesetzt" ist, können im Moment nicht in der Datenbank abgelegt werden, d.h. der Ablageversuch in einem entsprechenden Depot wird mit einem Fehler quittiert.
|
|
|
|
****************************************************/
|
|
|
|
|
|
$dokart_kuerzel = mb_strtoupper( $dokart_kuerzel );
|
|
$connection = mysqli_connect( "localhost", "ca_db", "ca_db", "ca_system" );
|
|
|
|
$kennung = trim( $kennung );
|
|
//xlog(1, "kennung ".$kennung );
|
|
|
|
//$optionen = array();
|
|
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
|
|
$ok_2 = existiert_benutzer( $mandant_name, $_SESSION[ "benutzer_anmeldename" ] );
|
|
|
|
if ( $ok_2[ 0 ] > 0 )
|
|
{
|
|
|
|
if ( strlen( $dokument_binary ) > 0 )
|
|
{
|
|
$md5_bin = md5( $dokument_binary );
|
|
|
|
$optionen[ "md5" ] = $md5_bin;
|
|
|
|
// Prüfen, ob das Dokument bereits existiert
|
|
|
|
$pruefe_auf_doppelte_dokumente = liefere_konfig( $mandant_name, "pruefe_auf_doppelte_dokumente" );
|
|
|
|
if ( $pruefe_auf_doppelte_dokumente == "ja" )
|
|
{
|
|
$STATEMENT = "select dok_id, version from ca_dok_datei where md5 = '".$md5_bin."' and mandant_id = ".$ok_1[ 0 ];
|
|
|
|
//xlog( 4, $STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
}
|
|
else
|
|
{
|
|
$ergebnis[ 0 ] = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$ergebnis[ 0 ] = 0;
|
|
}
|
|
|
|
|
|
if ( $ergebnis[ 0 ] == 0 )
|
|
{
|
|
|
|
// Das Dokumentbinary existiert noch nicht (in diesem Mandanten).
|
|
|
|
|
|
|
|
if ( strlen( $kennung ) != 0 )
|
|
{
|
|
|
|
// Prüfen, ob Dokument bereits existiert, ansonsten anlegen mit angegebener Kennung
|
|
|
|
$STATEMENT = "select count(*) anzahl from ca_dok_ablage where kennung = '".$kennung."' and mandant_id = ".$ok_1[ 0 ];
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
|
|
|
|
if ( $ergebnis[ 1 ][ 0 ][ "anzahl" ] > 0 )
|
|
{
|
|
$dokument_gibt_es = true;
|
|
}
|
|
else
|
|
{
|
|
$dokument_gibt_es = false;
|
|
}
|
|
|
|
//xlog( 1, "dokument gibt es >".$dokument_gibt_es."<" );
|
|
|
|
}
|
|
|
|
$dokartinfo = liefere_dokartinformationen( $mandant_name, $dokart_kuerzel );
|
|
|
|
if ( $dokartinfo[ 0 ] > 0 )
|
|
{
|
|
if ( ( strlen( $kennung ) == 0 ) || ( ! $dokument_gibt_es ) )
|
|
{
|
|
if ( strlen( $kennung ) == 0 )
|
|
{
|
|
$kennung = strtoupper( "k".liefere_zufaelligen_string( ) );
|
|
}
|
|
//xlog( 1, "hier angekommen");
|
|
// zuerst mal den Insert basteln
|
|
|
|
$felder = "";
|
|
$werte = "";
|
|
$feld_wert_arr = array();
|
|
|
|
// Felder checken
|
|
|
|
|
|
//xlog( 1, $dokartinfo[ 2 ][ "dokart_typ" ]." >".$optionen[ "mime_typ" ]."<" );
|
|
if ( ( $dokartinfo[ 2 ][ "dokart_typ" ] == "A" ) && ( $optionen[ "mime_type" ] == "" ) )
|
|
{
|
|
$optionen[ "mime_type" ] = "text/akte";
|
|
}
|
|
//xlog( 1, $dokartinfo[ 2 ][ "dokart_typ" ]." >".$optionen[ "mime_typ" ]."<" );
|
|
|
|
$fehler = false;
|
|
|
|
|
|
//////////////////////////////////////////
|
|
// Kundenspezifische Einsprungsfunktion
|
|
// pre_import_1
|
|
//////////////////////////////////////////
|
|
$funcname = "func_".$ok_1[ 0 ]."_pre_import_1";
|
|
|
|
if ( function_exists( $funcname ) )
|
|
{
|
|
$erg_1 = $funcname( $dokart_kuerzel, $kennung, $attribute, $mehrfachattribute, $optionen );
|
|
|
|
//return array( $rc, $dokart_kuerzel, $kennung, $attribute, $mehrfachattribute, $optionen );
|
|
|
|
$rc = $erg_1[ 0 ];
|
|
$dokart_kuerzel = $erg_1[ 1 ];
|
|
$kennung = $erg_1[ 2 ];
|
|
$attribute = $erg_1[ 3 ];
|
|
$mehrfachattribute = $erg_1[ 4 ];
|
|
$optionen = $erg_1[ 5 ];
|
|
}
|
|
else
|
|
{
|
|
$rc == 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if ( $rc == 0 )
|
|
{
|
|
|
|
foreach( $dokartinfo[ 2 ][ "attribute" ] as $attribut )
|
|
{
|
|
$attributwert = $attribute[ $attribut[ "attrib_db_spalte" ] ];
|
|
|
|
|
|
|
|
|
|
|
|
if ( ( $attribut[ "attrib_pflicht" ] == true ) && ( strlen( $attributwert ) == 0 ) )
|
|
{
|
|
// Fehler - Pflichtfeld ist nicht angegeben!
|
|
$meldung = "Das Pflichtfeld ".$attribut[ "attrib_name" ]." (".$attribut[ "attrib_db_spalte" ].") wurde nicht angegeben.";
|
|
$fehler = true;
|
|
break;
|
|
}
|
|
|
|
if ( ( mb_strtoupper( $attribut[ "attrib_typ" ] ) == "NUM" ) || ( mb_strtoupper( $attribut[ "attrib_typ" ] ) == "GELD" ) )
|
|
{
|
|
// besteht der Feldinhalt nur aus Zahlen und Punkt/Komma? Ansonsten Fehler.
|
|
|
|
if ( mb_strtoupper( $attributwert ) != "@FILESIZE" )
|
|
{
|
|
|
|
if ( mb_strtoupper( $attribut[ "attrib_typ" ] ) == "NUM" )
|
|
{
|
|
$dummy = "numerische ";
|
|
}
|
|
else
|
|
{
|
|
$dummy = "Geld-";
|
|
}
|
|
|
|
$regex = preg_match( "/[\!\"\§\$\%\&\\\ \?\:\;\/\(\)\=\*\#\'\{\}\[\]\~\|\_a-zA-Z]/", $attributwert );
|
|
|
|
if ( $regex > 0 )
|
|
{
|
|
$meldung = "Das ".$dummy."Feld ".$attribut[ "attrib_name" ]." (".$attribut[ "attrib_db_spalte" ].") wurde nicht korrekt gefüllt (Wert: >".$attributwert."<).";
|
|
$fehler = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
if ( mb_strtoupper( $attribut[ "attrib_typ" ] ) == "DATUM" )
|
|
{
|
|
// besteht der Feldinhalt nur aus Zahlen und Punkt? Ansonsten Fehler.
|
|
$regex = preg_match( "/[\!\"\§\$\%\&\\\ \?\:\;\/\(\)\=\*\#\'\{\}\[\]\~\|\_\,a-zA-Z]/", $attributwert );
|
|
|
|
if ( $regex > 0 )
|
|
{
|
|
$meldung = "Das Datumsfeld ".$attribut[ "attrib_name" ]." (".$attribut[ "attrib_db_spalte" ].") wurde nicht korrekt gefüllt (Wert: >".$attributwert."<).";
|
|
$fehler = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if ( $fehler == false )
|
|
{
|
|
//////////////////////////////////////////
|
|
// Kundenspezifische Einsprungsfunktion
|
|
// pre_import_2
|
|
//////////////////////////////////////////
|
|
$funcname = "func_".$ok_1[ 0 ]."_pre_import_2";
|
|
|
|
if ( function_exists( $funcname ) )
|
|
{
|
|
$erg_1 = $funcname( $dokart_kuerzel, $kennung, $attribute, $mehrfachattribute, $optionen );
|
|
|
|
//return array( $rc, $dokart_kuerzel, $kennung, $attribute, $mehrfachattribute, $optionen );
|
|
|
|
$rc = $erg_1[ 0 ];
|
|
$dokart_kuerzel = $erg_1[ 1 ];
|
|
$kennung = $erg_1[ 2 ];
|
|
$attribute = $erg_1[ 3 ];
|
|
$mehrfachattribute = $erg_1[ 4 ];
|
|
$optionen = $erg_1[ 5 ];
|
|
}
|
|
else
|
|
{
|
|
$rc == 0;
|
|
|
|
}
|
|
|
|
|
|
if ( $rc == 0 )
|
|
{
|
|
if ( ( is_array( $attribute ) ) and ( count( $attribute ) > 0 ) )
|
|
{
|
|
foreach( $attribute as $attribut => $wert )
|
|
{
|
|
//$felder = $felder.$attribut.", ";
|
|
|
|
|
|
if ( ( strtolower( substr( $attribut, 0, 3 ) ) == "num" ) || ( strtolower( substr( $attribut, 0, 3 ) ) == "gel" ) )
|
|
{
|
|
if ( mb_strtoupper( $wert ) == "@FILESIZE" )
|
|
{
|
|
$wert_passend = $optionen[ "dateigroesse" ];
|
|
}
|
|
else
|
|
{
|
|
$wert_passend = str_replace( ",", ".", $wert );
|
|
}
|
|
}
|
|
|
|
|
|
if ( strtolower( substr( $attribut, 0, 5 ) ) == "alpha" )
|
|
{
|
|
switch ( mb_strtoupper( $wert ) )
|
|
{
|
|
case "@FILENAME":
|
|
$wert_passend = $optionen[ "ursprungs_dateiname" ];
|
|
break;
|
|
case "@FILESIZE":
|
|
$wert_passend = $optionen[ "dateigroesse" ];
|
|
break;
|
|
case "@MIMETYPE":
|
|
$wert_passend = $optionen[ "mime_type" ];
|
|
break;
|
|
default:
|
|
$wert_passend = $wert;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( strtolower( substr( $attribut, 0, 4 ) ) == "text" )
|
|
{
|
|
$wert_passend = $wert;
|
|
}
|
|
|
|
if ( strtolower( substr( $attribut, 0, 5 ) ) == "datum" )
|
|
{
|
|
$wert_passend = $wert;
|
|
}
|
|
|
|
foreach( $dokartinfo[ 2 ][ "attribute" ] as $a )
|
|
{
|
|
if ( $a[ "attrib_db_spalte" ] == $attribut )
|
|
{
|
|
if ( ( $a[ "attrib_titel" ] == true ) && ( strlen( $wert_passend ) > 0 ) )
|
|
{
|
|
$titel = $titel.$wert_passend." | ";
|
|
}
|
|
}
|
|
}
|
|
|
|
//$werte = $werte."'".mysqli_real_escape_string( $connection, $wert_passend )."', ";
|
|
$feld_wert_arr[ $attribut ] = mysqli_real_escape_string( $connection, $wert_passend );
|
|
}
|
|
///$STATEMENT = "insert into ca_index ( ".substr( $felder, 0, strlen( $felder ) - 2 ).") values ( ".substr( $werte, 0, strlen( $werte ) - 2 ).");";
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////
|
|
// Kundenspezifische Einsprungsfunktion
|
|
// pre_import_2
|
|
//////////////////////////////////////////
|
|
$funcname = "func_".$ok_1[ 0 ]."_pre_import_3";
|
|
|
|
if ( function_exists( $funcname ) )
|
|
{
|
|
$erg_1 = $funcname( $dokart_kuerzel, $kennung, $feld_wert_arr, $mehrfachattribute, $optionen );
|
|
|
|
//return array( $rc, $dokart_kuerzel, $kennung, $attribute, $mehrfachattribute, $optionen );
|
|
|
|
$rc = $erg_1[ 0 ];
|
|
$dokart_kuerzel = $erg_1[ 1 ];
|
|
$kennung = $erg_1[ 2 ];
|
|
$feld_wert_arr = $erg_1[ 3 ];
|
|
$mehrfachattribute = $erg_1[ 4 ];
|
|
$optionen = $erg_1[ 5 ];
|
|
}
|
|
else
|
|
{
|
|
$rc == 0;
|
|
}
|
|
|
|
|
|
|
|
if ( $rc == 0 )
|
|
{
|
|
|
|
|
|
|
|
///////////////////////////
|
|
// Hier wird ein Statement gebastelt.
|
|
|
|
$felder = "";
|
|
$werte = "";
|
|
|
|
foreach ( $feld_wert_arr as $key => $value )
|
|
{
|
|
if ( strtolower( substr( $key, 0, 5 ) ) == "datum" )
|
|
{
|
|
$value = datum2mysql( $value );
|
|
}
|
|
|
|
$felder = $felder.$key.", ";
|
|
$werte = $werte."'".mysqli_real_escape_string( $connection, $value )."'".", ";
|
|
}
|
|
|
|
$STATEMENT = "insert into ca_index ( ".substr( $felder, 0, strlen( $felder ) - 2 ).") values ( ".substr( $werte, 0, strlen( $werte ) - 2 ).");";
|
|
|
|
|
|
|
|
///////////////////////////
|
|
|
|
//xlog(1, $STATEMENT );
|
|
|
|
$dok_id = xdb( $STATEMENT );
|
|
|
|
if ( bccomp( $dok_id[ 0 ], 0, 0 ) > 0 )
|
|
{
|
|
$dok_id = $dok_id[ 0 ];
|
|
|
|
$zeitstempel = time();
|
|
|
|
$optionen[ "zeitstempel" ] = $zeitstempel;
|
|
$optionen[ "neues_dokument" ] = true;
|
|
|
|
// Erzeugen des Versionseintrags
|
|
|
|
if ( strlen( $felder ) > 0 )
|
|
{
|
|
$felder = ", ".substr( $felder, 0, strlen( $felder ) - 2 );
|
|
$werte = ", ".substr( $werte, 0, strlen( $werte ) - 2 );
|
|
}
|
|
|
|
|
|
|
|
$VER_STATEMENT = "insert into ca_index_history ( dok_id, aktualisierungs_zeitpunkt, aktualisierungs_benutzer, version ".$felder.") values ( ".$dok_id.", '".$zeitstempel."', '".$_SESSION[ "benutzer_anmeldename" ]."', 1 ".$werte.");";
|
|
|
|
//xlog( 1, $VER_STATEMENT );
|
|
|
|
$ergebnis = xdb( $VER_STATEMENT );
|
|
|
|
// Importieren des Dokuments
|
|
$system_flags = liefere_anzahl_zeichen( 200, "0" );
|
|
|
|
if ( strlen( $titel ) > 0 )
|
|
{
|
|
$titel = substr( $titel, 0, -3 );
|
|
$titel_lang = "(".$dokartinfo[ 2 ][ "dokart_name" ].") ".$titel;
|
|
}
|
|
else
|
|
{
|
|
$titel = ""; //"Dokument-ID ".$dok_id;
|
|
}
|
|
|
|
|
|
$STATEMENT = "insert into ca_dok_ablage ( dok_id, mandant_id, kennung, dokart_kuerzel, system_flags, sperr_status, sperr_benutzer, sperr_beginn, eigentuemer, aktueller_besitzer, archivierungsdatum, a_flag, v_flag, n_flag, status, k_version, j_flag, titel, titel_lang ) values ( ".$dok_id.", ".$ok_1[ 0 ].", '".mysqli_real_escape_string( $connection, $kennung )."', '".mysqli_real_escape_string( $connection, $dokart_kuerzel )."', '".$system_flags."', '".mysqli_real_escape_string( $connection, $sperr_status )."', '".mysqli_real_escape_string( $connection, $sperr_benutzer )."', '".$sperr_beginn."', '".$ok_2[ 0 ]."', '".$ok_2[ 0 ]."', '".$zeitstempel."', '0', '0', '0', 'offen', 1, 0, '".mysqli_real_escape_string( $connection, $titel )."', '".mysqli_real_escape_string( $connection, $titel_lang )."' )";
|
|
|
|
|
|
$ergebnis_2 = xdb( $STATEMENT );
|
|
|
|
|
|
|
|
if ( bccomp( $ergebnis_2[ 0 ], 0, 0 ) == 0 )
|
|
{
|
|
// Mehrfachattribute
|
|
//array( array( p_alpha_01 => "Wert", p_alpha_02 = "Wert", ...), array( p_alpha_01 => "Wert", p_alpha_02 = "Wert"...), array( p_alpha_01 => "Wert", p_alpha_02 => "Wert", ...))
|
|
|
|
$lege_dok_ab = lege_dokument_in_depot_ab( $mandant_name, $dokartinfo[ 2 ][ "dokart_depot" ], $dok_id, "", $dokument_binary, $optionen );
|
|
|
|
if ( $lege_dok_ab[ 0 ] == 1 )
|
|
{
|
|
if ( ( is_array( $mehrfachattribute) ) and ( count( $mehrfachattribute ) > 0 ) )
|
|
{
|
|
$pos_ids = array();
|
|
$pos_ids_text = "";
|
|
|
|
foreach( $mehrfachattribute as $attributzeile )
|
|
{
|
|
$p_felder = "";
|
|
$p_werte = "";
|
|
if ( count( $attributzeile ) > 0 )
|
|
{
|
|
foreach( $attributzeile as $attribut => $wert )
|
|
{
|
|
$p_felder = $p_felder.$attribut.", ";
|
|
|
|
$attr_typ = substr( $attribut, 2, 4 );
|
|
|
|
switch ( $attr_typ )
|
|
{
|
|
case "datu":
|
|
//userlog(5, "Datum ".$wert )
|
|
$wert_passend_pos = datum2mysql( $wert );
|
|
break;
|
|
case "geld":
|
|
$wert_passend_pos = str_replace( ",", ".", $wert );
|
|
break;
|
|
case "alph":
|
|
$wert_passend_pos = $wert;
|
|
break;
|
|
case "num_":
|
|
$wert_passend_pos = str_replace( ",", ".", $wert );
|
|
break;
|
|
}
|
|
$p_werte = $p_werte."'".mysqli_real_escape_string( $connection, $wert_passend_pos )."', ";
|
|
}
|
|
$STATEMENT = "insert into ca_posdaten ( dok_id, ".substr( $p_felder, 0, strlen( $p_felder ) - 2 ).") values (".$dok_id.", ".substr( $p_werte, 0, strlen( $p_werte ) - 2 )." );";
|
|
|
|
//xlog( 5, $STATEMENT );
|
|
|
|
$ergebnis_3 = xdb( $STATEMENT );
|
|
|
|
$pos_ids[] = $ergebnis_3[ 0 ];
|
|
|
|
$STATEMENT = "insert into ca_posdaten_history ( aktualisierungs_zeitpunkt, aktualisierungs_benutzer, version, pos_id, dok_id, ".substr( $p_felder, 0, strlen( $p_felder ) - 2 ).") values ( '".$zeitstempel."', '".$_SESSION[ "benutzer_anmeldename" ]."', 1, ".$ergebnis_3[ 0 ].", ".$dok_id.", ".substr( $p_werte, 0, strlen( $p_werte ) - 2 )." );";
|
|
|
|
xdb( $STATEMENT );
|
|
|
|
if ( strlen( $pos_ids_text ) == 0 )
|
|
{
|
|
$pos_ids_text = "( ".$ergebnis_3[ 0 ];
|
|
}
|
|
else
|
|
{
|
|
$pos_ids_text = $pos_ids_text." | ".$ergebnis_3[ 0 ];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
xlog( 3, "__wfl.import: leere Positionszeile ignoriert (Dokument-ID ".$dok_id.").");
|
|
}
|
|
}
|
|
}
|
|
$pos_ids_text = $pos_ids_text." )";
|
|
|
|
if ( count( $pos_ids ) > 0 )
|
|
{
|
|
$pos_text = "Erzeugte Positions-IDs (".count($pos_ids)."): ".$pos_ids_text;
|
|
}
|
|
else
|
|
{
|
|
$pos_text = "Es wurden keine Positionszeilen erzeugt.";
|
|
}
|
|
|
|
/// Jobs erzeugen ?
|
|
|
|
$ergebnis = liefere_wertemenge_elemente( $mandant_name, "job" );
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
foreach ( $ergebnis[ 2 ] as $element )
|
|
{
|
|
if ( $element[ "alpha_02" ] == $dokart_kuerzel )
|
|
{
|
|
//function job_anlegen( $mandant_name, $element, $job_typ, $parameter_1 = "", $parameter_2 = "", $parameter_3 = "", $parameter_4 = "", $parameter_5 = "", $element_typ = "d" )
|
|
$erg = job_anlegen( $mandant_name, $dok_id, $element[ "alpha_01" ], $element[ "alpha_03" ], $element[ "alpha_04" ], $element[ "alpha_05" ], $element[ "alpha_06" ], $element[ "alpha_07" ] );
|
|
|
|
$jobs_ausfuehren = liefere_konfig( $mandant_name, "jobs_nach_import_ausfuehren" );
|
|
|
|
if ( $jobs_ausfuehren == "" )
|
|
{
|
|
$k = erstelle_konfig( $mandant_name, "jobs_nach_import_ausfuehren", "system", "nein", "janein", "Sollen die Jobs für ein importiertes Dokument direkt nach Import des Dokuments oder irgendwann später durchgeführt werden?" );
|
|
$jobs_ausfuehren = "nein";
|
|
}
|
|
|
|
if ( $jobs_ausfuehren == "ja" )
|
|
{
|
|
$jd = job_durchfuehren( $mandant_name, $erg[ 0 ] );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////
|
|
// Kundenspezifische Einsprungsfunktion
|
|
// post_import_1
|
|
//////////////////////////////////////////
|
|
$funcname = "func_".$ok_1[ 0 ]."_post_import_1";
|
|
|
|
if ( function_exists( $funcname ) )
|
|
{
|
|
$rc = $funcname( $dok_id, $dokart_kuerzel, $kennung, $attribute, $mehrfachattribute, $optionen );
|
|
|
|
//return array( $rc, $dokart_kuerzel, $kennung, $attribute, $mehrfachattribute, $optionen );
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc == 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
if ( $rc <> 0 )
|
|
{
|
|
$erg_1 = loesche_dokument( $mandant_name, $dok_id, true );
|
|
$meldung = "Das Dokument ".$dok_id." wurde importiert und aufgrund eines Fehlers in einer kundenspezifischen Einsprungsfunktion / post_import_1 direkt wieder gelöscht.";
|
|
$rc = -24;
|
|
}
|
|
else
|
|
{
|
|
|
|
|
|
|
|
|
|
$meldung = "Erzeugte Dokument-ID ".$dok_id." - ".$pos_text;
|
|
$rc = $dok_id;
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Import rückgängig machen
|
|
$STATEMENT = "delete from ca_index where dok_id = ".$dok_id;
|
|
xdb( $STATEMENT );
|
|
$STATEMENT = "delete from ca_dok_ablage where dok_id = ".$dok_id;
|
|
xdb( $STATEMENT );
|
|
|
|
$rc = -12;
|
|
$meldung = $lege_dok_ab[ 1 ]." Das Dokument wurde nicht importiert.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$meldung = "Es ist ein Fehler beim Erstellen des Datensatzes in der Tabelle ca_ablage aufgetreten: '".$ergebnis_2[ 1 ]."'.";
|
|
//xlog(2, "__wfl.import: ".$meldung." (".$ergebnis_2[ 1 ].")" );
|
|
//xlog(2, "__wfl.import: ".$STATEMENT );
|
|
$rc = -3;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$meldung = "Es ist ein Fehler beim Erstellen des Datensatzes in der Tabelle cfla_index aufgetreten: '".$dok_id[ 1 ]."'.";
|
|
//xlog(2, "__wfl.import: ".$meldung." (".$dok_id[ 1 ].")" );
|
|
//xlog(2, "__wfl.import: ".$STATEMENT );
|
|
$rc = -2;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -23;
|
|
$meldung = "Fehler in Kundenspezifischer Einsprungsfunktion / pre_import_3";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -22;
|
|
$meldung = "Fehler in Kundenspezifischer Einsprungsfunktion / pre_import_2";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -3;
|
|
// $meldung wird im Fehler gesetzt (z. B. Pflichtfeld nicht gefüllt).
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -21;
|
|
$meldung = "Fehler in Kundenspezifischer Einsprungsfunktion / pre_import_1";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Neue Version anlegen
|
|
|
|
|
|
$lege_dok_ab = lege_dokument_in_depot_ab( $mandant_name, $dokartinfo[ 2 ][ "dokart_depot" ], "", $kennung, $dokument_binary, $optionen );
|
|
|
|
if ( $lege_dok_ab[ 0 ] == 1 )
|
|
{
|
|
$rc = $lege_dok_ab[ 3 ];
|
|
$meldung = "Es wurde eine neue Dateiversion ".$lege_dok_ab[ 2 ]." des Dokuments mit der Dok-ID ".$lege_dok_ab[ 3 ]." erzeugt.";
|
|
}
|
|
else
|
|
{
|
|
$rc = $lege_dok_ab[ 0 ];
|
|
$meldung = $lege_dok_ab[ 1 ];
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $dokartinfo[ 0 ];
|
|
$meldung = $dokartinfo[ 1 ];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -17;
|
|
$meldung = "Das Dokumentbinary existiert bereits mit der Dokument-ID ".$ergebnis[ 1 ][ 0 ][ "dok_id" ]." / Version ".$ergebnis[ 1 ][ 0 ][ "version" ]." in diesem Mandanten.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -2;
|
|
$meldung = "Der angemeldete Benutzer existiert nicht im System.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -1;
|
|
$meldung = "Der angemeldete Mandant existiert nicht im System.";
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.import: RC ".$rc.": ".$meldung );
|
|
|
|
if ( $rc > 0 )
|
|
{
|
|
$wfl = liefere_workflows( $mandant_name );
|
|
|
|
if ( $wfl[ 0 ] > 0 )
|
|
{
|
|
foreach( $wfl[ 2 ] as $w )
|
|
{
|
|
if ( ( $w[ "dokart_kuerzel" ] == $dokart_kuerzel ) && ( $w[ "start_art" ] == "Import eines Dokuments" ) )
|
|
{
|
|
$s = starte_workflow( $mandant_name, $w[ "workflow_name" ], $rc );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
mysqli_close( $connection );
|
|
|
|
return array( $rc, $meldung, $pos_ids );
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function job_anlegen( $mandant_name, $element, $job_typ, $parameter_1 = "", $parameter_2 = "", $parameter_3 = "", $parameter_4 = "", $parameter_5 = "", $element_typ = "d" )
|
|
{
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
$connection = mysqli_connect( "localhost", "ca_db", "ca_db", "ca_system" );
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
if ( strlen( $element ) > 0 )
|
|
{
|
|
if ( strlen( $job_typ ) > 0 )
|
|
{
|
|
$element_typ = mb_strtolower( $element_typ );
|
|
|
|
$STATEMENT = "select job_id from ca_jobs where mandant_id = ".$ok_1[ 0 ]." and element = '".$element."' and job_typ = '".$job_typ."'";
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] == 0 )
|
|
{
|
|
|
|
$STATEMENT = "insert into ca_jobs ( mandant_id, element, job_typ, job_status, element_typ, angelegt_ts, p1, p2, p3, p4, p5 ) values ( ".$ok_1[ 0 ].", '".mysqli_real_escape_string( $connection, $element )."', '".mysqli_real_escape_string( $connection, $job_typ )."', 'NEU', '".mysqli_real_escape_string( $connection, $element_typ )."', '".time()."', '".$parameter_1."', '".$parameter_2."', '".$parameter_3."', '".$parameter_4."', '".$parameter_5."' )";
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
$rc = $ergebnis[ 0 ];
|
|
$meldung = "Der Job ".$rc." (".$element." / ".$job_typ.") wurde angelegt.";
|
|
}
|
|
else
|
|
{
|
|
$rc = -4;
|
|
$meldung = "Es gab einen Fehler beim Anlegen des Jobs (Element >".$element."<).";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ergebnis[ 1 ][ 0 ][ "job_id" ];
|
|
$meldung = "Der Job (".$element_typ." ".$element." / ".$job_typ.") existiert bereits mit der ID ".$ergebnis[ 1 ][ 0 ][ "job_id" ].".";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -3;
|
|
$meldung = "Es wurde kein Job-Typ angegeben.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -2;
|
|
$meldung = "Es wurde kein Element angegeben.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -1;
|
|
$meldung = "Der angemeldete Mandant existiert nicht im System.";
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
mysqli_close( $connection );
|
|
|
|
xlog( $level, "__wfl.job_anlegen: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung );
|
|
}
|
|
|
|
function job_status_setzen( $mandant_name, $element, $job_typ, $status, $element_typ = "d" )
|
|
{
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
$connection = mysqli_connect( "localhost", "ca_db", "ca_db", "ca_system" );
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
if ( strlen( $element ) > 0 )
|
|
{
|
|
if ( strlen( $job_typ ) > 0 )
|
|
{
|
|
if ( strlen( $status ) > 0 )
|
|
{
|
|
$element_typ = mb_strtolower( $element_typ );
|
|
|
|
$STATEMENT = "select job_id from ca_jobs where mandant_id = ".$ok_1[ 0 ]." and element = '".mysqli_real_escape_string( $connection, $element )."' and job_typ = '".mysqli_real_escape_string( $connection, $job_typ )."' and element_typ = '".mysqli_real_escape_string( $connection, $element_typ )."'";
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] == 1 )
|
|
{
|
|
$ti = time();
|
|
if ( strtoupper( $status ) == "FERTIG" )
|
|
{
|
|
$abgeschlossen = ", abgeschlossen_ts = '".$ti."' ";
|
|
}
|
|
else
|
|
{
|
|
$abgeschlossen = "";
|
|
}
|
|
|
|
$STATEMENT = "update ca_jobs set job_status = '".mysqli_real_escape_string( $connection, $status )."', letzte_bearbeitung_ts = '".$ti."' ".$abgeschlossen." where job_id = ".$ergebnis[ 1 ][ 0 ][ "job_id" ] ;
|
|
|
|
//xlog( 5, $STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
//xlog( 1, json_encode( $ergebnis ) );
|
|
|
|
if ( $ergebnis[ 0 ] == 0 )
|
|
{
|
|
$rc = $ergebnis[ 0 ];
|
|
$meldung = "Der Job ".$element." (".$element." / ".$job_typ.") wurde aktualisiert.";
|
|
}
|
|
else
|
|
{
|
|
$rc = -5;
|
|
$meldung = "Es gab einen Fehler beim Aktualisieren des Jobs (Element >".$element."<).";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -7;
|
|
$meldung = "Es wurde entweder keiner oder zuviele (mehr als einer) Jobs gefunden (".$ergebnis[ 0 ].").";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -4;
|
|
$meldung = "Es wurde kein Status angegeben.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -3;
|
|
$meldung = "Es wurde kein Job-Typ angegeben.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -2;
|
|
$meldung = "Es wurde kein Element angegeben.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -1;
|
|
$meldung = "Der angemeldete Mandant existiert nicht im System.";
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
mysqli_close( $connection );
|
|
|
|
xlog( $level, "__wfl.job_status_setzen: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung );
|
|
}
|
|
|
|
function job_loeschen( $mandant_name, $job_id )
|
|
{
|
|
// Hier muss nicht nur der Eintrag in ca_jobs gelöscht, sondern auch die Notizen gelöscht werden.
|
|
|
|
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
if ( strlen( $job_id ) > 0 )
|
|
{
|
|
$STATEMENT = "delete from ca_notiz where element_id = '".$job_id."' and element_typ = 'j' and element_id in ( select job_id from ca_jobs where mandant_id = ".$ok_1[ 0 ]." and element = ".$job_id." )";
|
|
|
|
//xlog( 3, $STATEMENT );
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
$STATEMENT = "delete from ca_jobs where mandant_id = ".$ok_1[ 0 ]." and job_id = '".$job_id."' ";
|
|
//xlog( 3, $STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
$rc = 1;
|
|
$meldung = "Der Job ".$job_id." wurde gelöscht.";
|
|
}
|
|
else
|
|
{
|
|
$rc = -2;
|
|
$meldung = "Es wurde keine Job-ID angegeben.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -1;
|
|
$meldung = "Der angemeldete Mandant existiert nicht im System.";
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.job_loeschen: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung );
|
|
}
|
|
|
|
function job_durchfuehren( $mandant_name, $job_id )
|
|
{
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
if ( strlen( $job_id ) > 0 )
|
|
{
|
|
$STATEMENT = "select element, element_typ, job_typ, job_status, p1, p2, p3, p4, p5 from ca_jobs where mandant_id = ".$ok_1[ 0 ]." and job_id = ".$job_id;
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] == 1 )
|
|
{
|
|
$element = $ergebnis[ 1 ][ 0 ][ "element" ];
|
|
$element_typ = $ergebnis[ 1 ][ 0 ][ "element_typ" ];
|
|
$job_typ = $ergebnis[ 1 ][ 0 ][ "job_typ" ];
|
|
$job_status = $ergebnis[ 1 ][ 0 ][ "job_status" ];
|
|
$p1 = $ergebnis[ 1 ][ 0 ][ "p1" ];
|
|
$p2 = $ergebnis[ 1 ][ 0 ][ "p2" ];
|
|
$p3 = $ergebnis[ 1 ][ 0 ][ "p3" ];
|
|
$p4 = $ergebnis[ 1 ][ 0 ][ "p4" ];
|
|
$p5 = $ergebnis[ 1 ][ 0 ][ "p5" ];
|
|
|
|
if ( $job_status == "NEU" )
|
|
{
|
|
switch ( $element_typ )
|
|
{
|
|
case "d":
|
|
switch ( $job_typ )
|
|
{
|
|
case "AKTE":
|
|
|
|
$aktenplan = liefere_wertemenge_elemente( $mandant_name, "aktplan" );
|
|
$dok = liefere_dokumentinformationen( $mandant_name, $element );
|
|
|
|
$dokart = $dok[ 2 ][ "dokart_kuerzel" ];
|
|
|
|
if ( $aktenplan[ 0 ] > 0 )
|
|
{
|
|
foreach( $aktenplan[ 2 ] as $schluessel_1 => $akten_konfiguration )
|
|
{
|
|
if ( $akten_konfiguration[ "alpha_02" ] == $dokart )
|
|
{
|
|
$oberes_element_dokart = $akten_konfiguration[ "alpha_01" ];
|
|
$erkennungs_attr = $akten_konfiguration[ "alpha_03" ];
|
|
$vererb_attr = $akten_konfiguration[ "alpha_04" ];
|
|
|
|
// feststellen, ob es bereits eine passende Akte gibt
|
|
$erkennungs_attr = explode( "|", $erkennungs_attr );
|
|
|
|
|
|
$stichwoerter = array();
|
|
$import_kenndaten = array();
|
|
|
|
|
|
foreach( $erkennungs_attr as $attribut )
|
|
{
|
|
$stichwoerter[ ] = array( "feld"=>$attribut, "operator"=>"EQUAL", "wert"=>$dok[ 2 ][ $attribut ] );
|
|
$import_kenndaten[ $attribut ] = $dok[ 2 ][ $attribut ];
|
|
//xlog( 5, json_encode( $import_kenndaten ) );
|
|
}
|
|
|
|
|
|
|
|
|
|
$ergebnis = variable_recherche( $mandant_name, $oberes_element_dokart, "ca_system", $stichwoerter );
|
|
|
|
if ( $ergebnis[ 0 ] == 0 )
|
|
{
|
|
// Akte muss angelegt und verknüpft werden
|
|
|
|
//import( $mandant_name, $dokart_kuerzel, $kennung, $attribute, $mehrfachattribute, $dokument_binary, $optionen )
|
|
//array( alpha_01 => "Wert", alpha_02 => "Wert", alpha_03 => "Wert", ..., num_01 => Zahl, num_02 => Zahl, num_03 => Zahl, ..., datum_01 => "TT.MM.YYYY", datum_02 => "TT.MM.YYYY", ..., geld_01 = "123,45", geld_02 => "234,56", geld_03 => "456,78", ...)
|
|
|
|
|
|
if ( strlen( $vererb_attr ) > 0 )
|
|
{
|
|
$vererb_attr = explode( "|", $vererb_attr );
|
|
foreach( $vererb_attr as $attribut )
|
|
{
|
|
$import_kenndaten[ $attribut ] = $dok[ 2 ][ $attribut ];
|
|
}
|
|
}
|
|
|
|
//xlog( 5, json_encode( $import_kenndaten ) );
|
|
// function import( $mandant_name, $dokart_kuerzel, $kennung, $attribute, $mehrfachattribute, $dokument_binary, $optionen )
|
|
$dok_id = import( $mandant_name, $oberes_element_dokart, "", $import_kenndaten, "", "", array() );
|
|
|
|
if ( $dok_id[ 0 ] > 0 )
|
|
{
|
|
$dok_id = $dok_id[ 0 ];
|
|
|
|
$ergebnis = verknuepfe_dok_mit_dok( $dok_id, $element );
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
$rc = 1;
|
|
$meldung = "Das übergeordnete Dokument wurde angelegt (ID ".$dok_id.", Dokart ".$oberes_element_dokart.") und das untergeordnete Dokument wurde darin verknüpft.";
|
|
}
|
|
else
|
|
{
|
|
$rc = -1;
|
|
$meldung = "Beim Verknüpfen der Dokumente ist ein Fehler aufgetreten: ".$ergebnis[ 1 ];
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = -2;
|
|
$meldung = "Es ist ein Fehler beim Anlegen des übergeordneten Dokuments aufgetreten: ".$dok_id[ 1 ];
|
|
}
|
|
|
|
|
|
}
|
|
else if ( $ergebnis[ 0 ] == 1 )
|
|
{
|
|
// Akte muss verknüpft werden an jedes gefundene Element (i.d.R. Akte)
|
|
|
|
$rc = 0;
|
|
foreach ( $ergebnis[ 2 ] as $treffer )
|
|
{
|
|
//xlog( 5, $treffer[ "dok_id" ] );
|
|
$ergebnis = verknuepfe_dok_mit_dok( $treffer[ "dok_id" ], $element );
|
|
|
|
if ( $ergebnis < 0 )
|
|
{
|
|
$rc = -1;
|
|
$meldung = "Beim Verknüpfen der Dokumente ist ein Fehler aufgetreten: ".$ergebnis[ 1 ];
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
$rc++;
|
|
}
|
|
|
|
}
|
|
|
|
if ( $rc > 0 )
|
|
{
|
|
$rc = 1;
|
|
$meldung = "Das untergeordnete Dokument wurde mit ".$rc." übergeordneten Dokumenten verknüpft.";
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
// Fehler
|
|
$rc = -31;
|
|
$meldung = "Es ist ein Fehler aufgetreten: ".$ergebnis[ 1 ];
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
case "PIC_RESIZE":
|
|
|
|
$dok = liefere_dokumentinformationen( $mandant_name, $element );
|
|
|
|
$mime = $dok[ 2 ][ "mime_type" ];
|
|
$kennung = $dok[ 2 ][ "kennung" ];
|
|
$dokart = $dok[ 2 ][ "dokart_kuerzel" ];
|
|
|
|
if ( ( $mime == "image/jpeg" ) || ( $mime == "image/gif" ) || ( $mime == "image/png" ) )
|
|
{
|
|
if ( strlen( $p1 ) == 0 )
|
|
{
|
|
$p1 = 0;
|
|
}
|
|
|
|
if ( strlen( $p2 ) == 0 )
|
|
{
|
|
$p2 = 0;
|
|
}
|
|
|
|
if ( strlen( $p3 ) == 0 )
|
|
{
|
|
$p3 = 100;
|
|
}
|
|
|
|
if ( bcadd( $p1, $p2 ) == 0 )
|
|
{
|
|
$rc = -32;
|
|
$meldung = "Die Parametrisierung fehlt.";
|
|
}
|
|
else
|
|
{
|
|
// Die Parameter p1 und p2 sind als Maximal-Höhe bzw. -Breite eines Bildes zu sehen
|
|
// Folglich nimmt man die Höhe und berechnet die neue Breite
|
|
// Ist selbige breiter als p2, nimmt man die Breite und berechnet daraufhin die neue Höhe
|
|
// Diese sollte dann auf jeden Fall kleiner sein als die alte Höhe.
|
|
|
|
// q.e.d. ;-)
|
|
|
|
$ergebnis = liefere_dokumentbinary( $mandant_name, "ca_system", $element );
|
|
|
|
$k = getimagesizefromstring ( $ergebnis[ 2 ] );
|
|
|
|
$bildbreite_original = $k[0];
|
|
$bildhoehe_original = $k[1];
|
|
|
|
unset( $k );
|
|
|
|
$k = imagecreatefromstring( $ergebnis[ 2 ] );
|
|
|
|
// $ratio = x / y
|
|
$ratio = $bildbreite_original / $bildhoehe_original;
|
|
|
|
$max_hoehe = $p1;
|
|
$max_breite = $p2;
|
|
|
|
//xlog(1, $max_hoehe ." ". $max_breite );
|
|
|
|
|
|
$neue_hoehe = $p1;
|
|
$neue_breite = $max_hoehe * $ratio;
|
|
|
|
//xlog(1, $neue_breite ." ". $neue_hoehe );
|
|
|
|
|
|
//xlog(1, $neue_breite ." ". $max_breite );
|
|
|
|
if ( ( $neue_breite > $max_breite ) && ( $max_breite > 0 ) )
|
|
{
|
|
$ratio = $bildhoehe_original / $bildbreite_original;
|
|
$neue_breite = $p2;
|
|
$neue_hoehe = $neue_breite * $ratio;
|
|
}
|
|
//xlog(1, $neue_breite ." ". $neue_hoehe );
|
|
|
|
|
|
$image_p = imagecreatetruecolor( $neue_breite, $neue_hoehe );
|
|
|
|
imagecopyresampled( $image_p, $k, 0, 0, 0, 0, $neue_breite, $neue_hoehe, $bildbreite_original, $bildhoehe_original );
|
|
|
|
unset( $k );
|
|
|
|
$sysimppfad = liefere_konfig( $mandant_name, "import_ordner" );
|
|
$ts = time();
|
|
|
|
$dateipfad = $sysimppfad.DIRECTORY_SEPARATOR.$ts."_".$kennung;
|
|
$idx_inhalt = "kennung = '".$kennung."'\ndokart = '".$dokart."'\nerw = '1'\n";
|
|
$jfile = file_put_contents( $dateipfad.".idx", $idx_inhalt );
|
|
|
|
|
|
//xlog( 5, "jfile = >".$jfile."<" );
|
|
//xlog( 5, "Dateipfad ".$dateipfad );
|
|
|
|
switch( $mime )
|
|
{
|
|
case "image/jpeg":
|
|
imagejpeg( $image_p, $dateipfad.".jpg", $p3 );
|
|
break;
|
|
case "image/gif":
|
|
imagegif( $image_p, $dateipfad.".gif", $p3 );
|
|
break;
|
|
case "image/png":
|
|
imagepng( $image_p, $dateipfad.".png", $p3 );
|
|
break;
|
|
}
|
|
|
|
$rc = 1;
|
|
$meldung = "Der Job ".$element." wurde erledigt.";
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -31;
|
|
$meldung = "Das Dokument-Binary zu Dok-ID ".$element." ist keines der unterstützten Bildformate (JPEG, GIF, PNG).";
|
|
}
|
|
break;
|
|
default:
|
|
$rc = -11;
|
|
$meldung = "Der Job-Typ ".$job_typ." ist unbekannt.";
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
$rc = -5;
|
|
$meldung = "Der Elementtyp ".$element_typ." ist unbekannt.";
|
|
break;
|
|
}
|
|
if ( $rc > 0 )
|
|
{
|
|
$ergebnis = job_status_setzen( $mandant_name, $element, $job_typ, "FERTIG" );
|
|
}
|
|
else
|
|
{
|
|
$ergebnis = job_status_setzen( $mandant_name, $element, $job_typ, "FEHLER" );
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -6;
|
|
$meldung = "Der Job ".$job_id." hat nicht den Status 'NEU', sondern '".$job_status."'. Daher wird er nicht bearbeitet.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -3;
|
|
$meldung = "Der angegebene Job ".$job_id." wurde im Mandanten ".$mandant_name." nicht gefunden oder es ist ein Fehler aufgetreten >".$ergebnis[ 1 ]."<.";
|
|
}
|
|
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = -2;
|
|
$meldung = "Es wurde keine Job-ID angegeben.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -1;
|
|
$meldung = "Der angemeldete Mandant existiert nicht im System.";
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.job_durchfuehren: RC ".$rc.": ".$meldung );
|
|
|
|
return array( $rc, $meldung );
|
|
}
|
|
|
|
function liefere_jobs( $mandant_name, $status = "" )
|
|
{
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
$ergebnis_arr = array();
|
|
|
|
if ( strlen( $status ) > 0 )
|
|
{
|
|
$status_sql = "and job_status = '".strtoupper( $status )."' ";
|
|
|
|
}
|
|
|
|
$STATEMENT = "select mandant_id, element, element_typ, job_id, job_typ, job_status, p1, p2, p3, p4, p5, angelegt_ts, letzte_bearbeitung_ts, abgeschlossen_ts from ca_jobs where mandant_id = ".$ok_1[ 0 ]." ".$status_sql." order by job_status, element asc ";
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
$ergebnis_arr = $ergebnis[ 1 ];
|
|
$rc = $ergebnis[ 0 ];
|
|
$meldung = "Liefere Informationen über ".$rc." Jobs.";
|
|
}
|
|
else
|
|
{
|
|
$rc = 0;
|
|
$meldung = "Es wurden keine Jobs gefunden.";
|
|
}
|
|
}
|
|
|
|
return array( $rc, $meldung, $ergebnis_arr );
|
|
}
|
|
|
|
function liefere_job( $mandant_name, $element, $element_typ )
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function verknuepfe_dokumente_variabel( $ober_dok_id, $unter_dok_id, $ober_pos_id = "", $unter_pos_id = "" )
|
|
{
|
|
|
|
$aktueller_mandant = $_SESSION[ "mandant_name" ];
|
|
$ok = existiert_mandant( $aktueller_mandant );
|
|
|
|
if ( $ok[ 0 ] > 0 )
|
|
{
|
|
|
|
$e1 = existiert_dokument( $aktueller_mandant, $ober_dok_id );
|
|
$e2 = existiert_dokument( $aktueller_mandant, $unter_dok_id );
|
|
|
|
if ( ( $e1[ 0 ] > 0 ) and ( $e2[ 0 ] > 0 ) )
|
|
{
|
|
|
|
if ( strlen ( $ober_pos_id ) > 0 )
|
|
{
|
|
$values_1 = ", '".$ober_pos_id."'";
|
|
$dokpos_1 = $ober_dok_id."/".$ober_pos_id;
|
|
$where_1 = " = '".$ober_pos_id."'";
|
|
}
|
|
else
|
|
{
|
|
$values_1 = ", null";
|
|
$dokpos_1 = $ober_dok_id."/-";
|
|
$where_1 = " is null ";
|
|
|
|
}
|
|
|
|
if ( strlen ( $unter_pos_id ) > 0 )
|
|
{
|
|
$values_2 = ", '".$unter_pos_id."'";
|
|
$dokpos_2 = $unter_dok_id."/".$unter_pos_id;
|
|
$where_2 = " = '".$unter_pos_id."'";
|
|
}
|
|
else
|
|
{
|
|
$values_2 = ", null";
|
|
$dokpos_2 = $unter_dok_id."/-";
|
|
$where_2 = " is null ";
|
|
}
|
|
|
|
|
|
$STATEMENT = "select count(*) calbers from ca_bezug where dok_id_1 = '".$ober_dok_id."' and dok_id_2 = '".$unter_dok_id."' and pos_id_1 ".$where_1." and pos_id_2 ".$where_2;
|
|
|
|
//xlog( 4, $STATEMENT );
|
|
|
|
$count = xdb( $STATEMENT );
|
|
|
|
|
|
switch ( $count[ 1 ][ 0 ][ "calbers" ] )
|
|
{
|
|
case "0":
|
|
$STATEMENT = "insert into ca_bezug ( dok_id_1, dok_id_2, pos_id_1, pos_id_2 ) values ( '".$ober_dok_id."', '".$unter_dok_id."' ".$values_1.$values_2." ) ";
|
|
|
|
$erg = xdb( $STATEMENT );
|
|
|
|
if ( $erg[ 0 ] <> 0 )
|
|
{
|
|
$rc = -3;
|
|
$meldung = "Es gab einen Fehler beim Verknüpfen der Dokumente: '".$erg[ 1 ]."'";
|
|
}
|
|
else
|
|
{
|
|
$STATEMENT = "update ca_dok_ablage set a_flag = '1' where dok_id = ".$ober_dok_id." and mandant_id = ".$ok[ 0 ];
|
|
$ergebnis = xdb( $STATEMENT );
|
|
$STATEMENT = "update ca_dok_ablage set a_flag = '1' where dok_id = ".$unter_dok_id." and mandant_id = ".$ok[ 0 ];
|
|
$ergebnis = xdb( $STATEMENT );
|
|
$rc = 1;
|
|
$meldung = "Die Dokumente (dok_id/pos_id) ".$dokpos_1." und ".$dokpos_2." wurden miteinander verknüpft.";
|
|
}
|
|
break;
|
|
case "1":
|
|
$rc = 2;
|
|
$meldung = "Die Dokumente (dok_id/pos_id) ".$dokpos_1." und ".$dokpos_2." sind bereits miteinander verknüpft.";
|
|
break;
|
|
default:
|
|
$rc = -4;
|
|
$meldung = "Es ist unbekannt, ob die Dokumente (dok_id/pos_id) ".$dokpos_1." und ".$dokpos_2." bereits miteinander verknüpft sind (DEBUG: >".$count."<)";
|
|
break;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = -2;
|
|
$meldung = "Eines der beiden Dokumente (".$ober_dok_id.", ".$unter_dok_id.") existiert nicht im Mandanten ".$aktueller_mandant.".";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok[ 0 ];
|
|
$meldung = $ok[ 1 ];
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.verknuepfe_dokumente_variabel: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung );
|
|
}
|
|
|
|
function verknuepfe_dok_mit_dok( $ober_dok_id, $unter_dok_id )
|
|
{
|
|
return verknuepfe_dokumente_variabel( $ober_dok_id, $unter_dok_id );
|
|
}
|
|
|
|
function verknuepfe_dok_mit_dok_pos( $ober_dok_id, $unter_dok_id, $unter_pos_id )
|
|
{
|
|
return verknuepfe_dokumente_variabel( $ober_dok_id, $unter_dok_id, $unter_pos_id );
|
|
}
|
|
|
|
function verknuepfe_dok_pos_mit_dok_pos( $ober_dok_id, $unter_dok_id )
|
|
{
|
|
return verknuepfe_dokumente_variabel($ober_dok_id, $unter_dok_id, $ober_pos_id, $unter_pos_id );
|
|
}
|
|
|
|
function loesche_verknuepfung( $ober_dok_id, $unter_dok_id )
|
|
{
|
|
$aktueller_mandant = $_SESSION[ "mandant_name" ];
|
|
$ok = existiert_mandant( $aktueller_mandant );
|
|
|
|
if ( $ok[ 0 ] > 0 )
|
|
{
|
|
|
|
$e1 = existiert_dokument( $aktueller_mandant, $ober_dok_id );
|
|
$e2 = existiert_dokument( $aktueller_mandant, $unter_dok_id );
|
|
|
|
if ( ( $e1[ 0 ] > 0 ) and ( $e2[ 0 ] > 0 ) )
|
|
{
|
|
$STATEMENT = "delete from ca_bezug where dok_id_1 = ".$ober_dok_id." and dok_id_2 = ".$unter_dok_id;
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] == 0 )
|
|
{
|
|
$rc = 0;
|
|
$meldung = "Die Verknüpfung zwischen den Dokumenten ".$ober_dok_id." und ".$unter_dok_id." wurde gelöscht.";
|
|
}
|
|
else
|
|
{
|
|
$rc = -4;
|
|
$meldung = "Es ist ein Fehler aufgetreten: ".$ergebnis[ 1 ];
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = -2;
|
|
$meldung = "Eines der beiden Dokumente (".$ober_dok_id.", ".$unter_dok_id.") existiert nicht im Mandanten ".$aktueller_mandant.".";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok[ 0 ];
|
|
$meldung = $ok[ 1 ];
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.loesche_verknuepfung: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung );
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function liefere_verknuepfte_dokumente( $mandant_name, $dokument_id )
|
|
{
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
$e = existiert_dokument( $mandant_name, $dokument_id );
|
|
|
|
if ( $e[ 0 ] > 0 )
|
|
{
|
|
$dokument_ids = array();
|
|
|
|
//$STATEMENT = "select dok_id_2 dok_id, 'unter' ou from ca_bezug where dok_id_1 = ".$dokument_id." union select dok_id_1 dok_id, 'ober' ou from ca_bezug where dok_id_2 = ".$dokument_id;
|
|
$STATEMENT = "select be.dok_id_2 dok_id, 'unter' ou, da.titel, da.titel_lang, dd.mime_type, da.dokart_kuerzel, kk.dokart_name from ca_bezug be, ca_dokart kk, ca_dok_ablage da, ca_dok_datei dd where be.dok_id_1 = ".$dokument_id." and be.dok_id_2 = da.dok_id and be.dok_id_2 = dd.dok_id and da.d_version = dd.version and dd.erw = 0 and da.dokart_kuerzel = kk.dokart_kuerzel union select be.dok_id_1 dok_id, 'ober' ou, da.titel, da.titel_lang, dd.mime_type, da.dokart_kuerzel, kk.dokart_name from ca_bezug be, ca_dokart kk, ca_dok_ablage da, ca_dok_datei dd where be.dok_id_2 = ".$dokument_id." and be.dok_id_1 = da.dok_id and be.dok_id_1 = dd.dok_id and da.d_version = dd.version and dd.erw = 0 and da.dokart_kuerzel = kk.dokart_kuerzel union select da.dok_id dok_id, 'gleich' ou, da.titel, da.titel_lang, dd.mime_type, da.dokart_kuerzel, kk.dokart_name from ca_dokart kk, ca_dok_ablage da, ca_dok_datei dd where da.dok_id = ".$dokument_id." and da.dok_id = dd.dok_id and da.d_version = dd.version and dd.erw = 0 and da.dokart_kuerzel = kk.dokart_kuerzel order by dok_id desc ";
|
|
|
|
//xlog( 5, $STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
$oben = array();
|
|
$unten = array();
|
|
$oben_einfach[] = array();
|
|
$unten_einfach[] = array();
|
|
|
|
foreach( $ergebnis[ 1 ] as $element )
|
|
{
|
|
$dokument_ids[] = $element[ "dok_id" ];
|
|
$dok_id_full[] = array( "dok_id" => $element[ "dok_id" ], "ou" => $element[ "ou" ], "titel" => $element[ "titel" ], "mime_type" => $element[ "mime_type" ], "dokart_kuerzel" => $element[ "dokart_kuerzel" ], "dokart_name" => $element[ "dokart_name" ], "titel_lang" => $element[ "titel_lang" ] );
|
|
|
|
switch ( $element[ "ou" ] )
|
|
{
|
|
case "ober":
|
|
$oben[] = array( "dok_id" => $element[ "dok_id" ], "ou" => $element[ "ou" ], "titel" => $element[ "titel" ], "mime_type" => $element[ "mime_type" ], "dokart_kuerzel" => $element[ "dokart_kuerzel" ], "dokart_name" => $element[ "dokart_name" ], "titel_lang" => $element[ "titel_lang" ] );
|
|
$oben_einfach[] = $element[ "dok_id" ];
|
|
break;
|
|
case "unter":
|
|
//$unten[] = $element[ "dok_id" ];
|
|
$unten[] = array( "dok_id" => $element[ "dok_id" ], "ou" => $element[ "ou" ], "titel" => $element[ "titel" ], "mime_type" => $element[ "mime_type" ], "dokart_kuerzel" => $element[ "dokart_kuerzel" ], "dokart_name" => $element[ "dokart_name" ], "titel_lang" => $element[ "titel_lang" ] );
|
|
$unten_einfach[] = $element[ "dok_id" ];
|
|
break;
|
|
case "gleich":
|
|
$gleich = array( "dok_id" => $element[ "dok_id" ], "ou" => $element[ "ou" ], "titel" => $element[ "titel" ], "mime_type" => $element[ "mime_type" ], "dokart_kuerzel" => $element[ "dokart_kuerzel" ], "dokart_name" => $element[ "dokart_name" ], "titel_lang" => $element[ "titel_lang" ] );
|
|
}
|
|
|
|
}
|
|
$rc = count( $dokument_ids );
|
|
$meldung = "Liefere ".$rc." verknüpfte Dokumente zur Dokument-ID ".$dokument_id.".";
|
|
}
|
|
else
|
|
{
|
|
$rc = 0;
|
|
$meldung = "Zu Dokument ".$dokument_id." wurden keine verknüpften Dokumente gefunden.";
|
|
}
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = $e[ 0 ];
|
|
$meldung = $e[ 1 ];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = $ok_1[ 1 ];
|
|
}
|
|
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.liefere_verknuepfte_dokumente: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung, $dokument_ids, $dok_id_full, $oben, $unten, $gleich, $oben_einfach, $unten_einfach );
|
|
|
|
}
|
|
|
|
function liefere_verknuepfte_dokumente_menge( $mandant_name, $dok_ids )
|
|
{
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
$dokument_ids = array();
|
|
|
|
$liste = "( ";
|
|
|
|
foreach( $dok_ids as $dok_id )
|
|
{
|
|
$liste = $liste.$dok_id.", ";
|
|
}
|
|
$liste = substr( $liste, 0, -2 )." )";
|
|
|
|
$STATEMENT = "select dok_id_1 dok_id from ca_bezug where dok_id_1 in ".$liste." union select dok_id_2 dok_id from ca_bezug where dok_id_2 in ".$liste;
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
foreach( $ergebnis[ 1 ] as $element )
|
|
{
|
|
$dokument_ids[] = $element[ "dok_id" ];
|
|
}
|
|
$rc = count( $dokument_ids );
|
|
$meldung = "Liefere ".$rc." verknüpfte Dokumente zur Dokument-ID ".$dokument_id.".";
|
|
}
|
|
else
|
|
{
|
|
$rc = 0;
|
|
$meldung = "Zu Dokument ".$dokument_id." wurden keine verknüpften Dokumente gefunden.";
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = $ok_1[ 1 ];
|
|
}
|
|
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.liefere_verknuepfte_dokumente_menge: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung, $dokument_ids );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function import_lauf( $mandant_name )
|
|
{
|
|
$ok_1 = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok_1[ 0 ] > 0 )
|
|
{
|
|
$abzugreifende_verzeichnisse = liefere_wertemenge_elemente( $mandant_name, "imp_par" );
|
|
|
|
$dateiimporte_ok = 0;
|
|
$dateiimporte_nicht_ok = 0;
|
|
|
|
$sysimppfad = liefere_konfig( $mandant_name, "import_ordner" );
|
|
|
|
$abzugreifende_verzeichnisse[ 2 ][ ] = array( "alpha_01"=>$sysimppfad, "alpha_02"=>"JPG", "alpha_03"=>"" );
|
|
$abzugreifende_verzeichnisse[ 2 ][ ] = array( "alpha_01"=>$sysimppfad, "alpha_02"=>"GIF", "alpha_03"=>"" );
|
|
$abzugreifende_verzeichnisse[ 2 ][ ] = array( "alpha_01"=>$sysimppfad, "alpha_02"=>"PNG", "alpha_03"=>"" );
|
|
$abzugreifende_verzeichnisse[ 2 ][ ] = array( "alpha_01"=>$sysimppfad, "alpha_02"=>"PDF", "alpha_03"=>"" );
|
|
$abzugreifende_verzeichnisse[ 2 ][ ] = array( "alpha_01"=>$sysimppfad, "alpha_02"=>"AKTE", "alpha_03"=>"" );
|
|
|
|
foreach ( $abzugreifende_verzeichnisse[ 2 ] as $konfiguration )
|
|
{
|
|
|
|
/*
|
|
|
|
es müssen folgende Informationen gesammelt werden:
|
|
|
|
|
|
import( $mandant_name, $dokart_kuerzel, $kennung, $attribute, $mehrfachattribute, $dokument_binary, $optionen )
|
|
|
|
|
|
$attribute ist ein Array, welches folgenden Aufbau haben muß:
|
|
|
|
array( alpha_01 => "Wert", alpha_02 => "Wert", alpha_03 => "Wert", ..., num_01 => Zahl, num_02 => Zahl, num_03 => Zahl, ..., datum_01 => "TT.MM.YYYY", datum_02 => "TT.MM.YYYY", ..., geld_01 = "123,45", geld_02 => "234,56", geld_03 => "456,78", ...)
|
|
|
|
$optionen[ "ursprungs_dateiname" ] = $dokument_meta[ "file" ][ "name" ];
|
|
$optionen[ "mime_type" ] = $dokument_meta[ "file" ][ "type" ];
|
|
$optionen[ "dateigroesse" ] = $dokument_meta[ "file" ][ "size" ];
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
$pfad = $konfiguration[ "alpha_01" ];
|
|
$dateityp = $konfiguration[ "alpha_02" ];
|
|
$defaultini = $konfiguration[ "alpha_03" ];
|
|
|
|
//xlog( 5, $pfad );
|
|
//xlog( 5, $dateityp );
|
|
//xlog( 5, $defaultini );
|
|
|
|
$basis_attribute = array();
|
|
$basis_optionen = array();
|
|
$basis_dokart = "";
|
|
$basis_kennung = "";
|
|
|
|
if ( file_exists( $defaultini ) )
|
|
{
|
|
$ergebnis = parse_ini_file( $defaultini );
|
|
}
|
|
else
|
|
{
|
|
$ergebnis = array();
|
|
}
|
|
|
|
if ( is_array( $ergebnis ) && ( count( $ergebnis ) > 0 ) )
|
|
{
|
|
|
|
foreach ( $ergebnis as $schluessel => $wert )
|
|
{
|
|
//xlog( 5, "gefundener schlüssel: ".$schluessel." wert: ".$wert );
|
|
|
|
switch ( $schluessel )
|
|
{
|
|
case "dokart":
|
|
case "dokuart":
|
|
$basis_dokart = $wert;
|
|
break;
|
|
case "mime_type":
|
|
$basis_optionen[ "mime_type" ] = $wert;
|
|
break;
|
|
case "kennung":
|
|
$basis_kennung = $wert;
|
|
break;
|
|
case "ursprungs_dateiname":
|
|
$basis_optionen[ "ursprungs_dateiname" ] = $wert;
|
|
break;
|
|
default:
|
|
$key = substr( $schluessel, 0, 4 );
|
|
switch( $key )
|
|
{
|
|
case "alph":
|
|
case "text":
|
|
case "datu":
|
|
case "num_":
|
|
case "geld":
|
|
$basis_attribute[ $schluessel ] = $wert;
|
|
break;
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/*
|
|
xlog( 1, "basis ".json_encode( $basis_attribute ) );
|
|
xlog( 1, "basis ".json_encode( $basis_optionen ) );
|
|
xlog( 1, "basis ".$basis_dokart );
|
|
xlog( 1, "basis ".$basis_kennung );
|
|
*/
|
|
///////////////////////////////////////////
|
|
// Suche zu importierende Dateien
|
|
|
|
$fertiger_dateityp = "";
|
|
|
|
for ( $i = 0; $i < strlen( $dateityp ); $i++ )
|
|
{
|
|
$zeichen = substr( $dateityp, $i, 1 );
|
|
$fertiger_dateityp = $fertiger_dateityp."[".strtoupper( $zeichen ).strtolower( $zeichen )."]";
|
|
}
|
|
|
|
//xlog( 1, $fertiger_dateityp );
|
|
|
|
$fertiger_pfad = $pfad.DIRECTORY_SEPARATOR."*.".$fertiger_dateityp;
|
|
|
|
//xlog( 2, "fertiger Pfad ".$fertiger_pfad );
|
|
|
|
$zu_bearbeitende_dateien = glob( $fertiger_pfad );
|
|
|
|
foreach ( $zu_bearbeitende_dateien as $datei )
|
|
{
|
|
$pathteile = pathinfo( utf8_encode( $datei ) );
|
|
|
|
///xlog( 1, "bearbeite datei ".$datei );
|
|
|
|
//////////////////////////////////
|
|
// Suche von Attributdateien (.idx)
|
|
|
|
$attribute = $basis_attribute;
|
|
$optionen = $basis_optionen;
|
|
$dokart = $basis_dokart;
|
|
$kennung = $basis_kennung;
|
|
|
|
|
|
$idx_datei = $pathteile[ "dirname" ].DIRECTORY_SEPARATOR.$pathteile[ "filename" ].".idx";
|
|
|
|
if ( ! file_exists( $idx_datei ) )
|
|
{
|
|
$idx_datei = $pathteile[ "dirname" ].DIRECTORY_SEPARATOR.$pathteile[ "filename" ].".jpl";
|
|
}
|
|
$dateiname_fehlerdatei = $pathteile[ "dirname" ].DIRECTORY_SEPARATOR.$pathteile[ "filename" ].".err";
|
|
$fehlerdatei = $pathteile[ "dirname" ].DIRECTORY_SEPARATOR.$pathteile[ "filename" ]."._".$pathteile[ "extension" ];
|
|
|
|
if ( file_exists( $idx_datei ) )
|
|
{
|
|
$ergebnis = parse_ini_file( $idx_datei );
|
|
$idx_datei_existiert = true;
|
|
}
|
|
else
|
|
{
|
|
$ergebnis = array();
|
|
$idx_datei_existiert = false;
|
|
}
|
|
|
|
if ( is_array( $ergebnis ) && ( count( $ergebnis ) > 0 ) )
|
|
{
|
|
|
|
foreach ( $ergebnis as $schluessel => $wert )
|
|
{
|
|
|
|
switch ( $schluessel )
|
|
{
|
|
case "dokart":
|
|
case "dokuart":
|
|
$dokart = $wert;
|
|
break;
|
|
case "mime_type":
|
|
$optionen[ "mime_type" ] = $wert;
|
|
break;
|
|
case "erw":
|
|
$optionen[ "datei_erw_typ" ] = $wert;
|
|
break;
|
|
case "kennung":
|
|
$kennung = $wert;
|
|
break;
|
|
case "ursprungs_dateiname":
|
|
$optionen[ "ursprungs_dateiname" ] = $wert;
|
|
break;
|
|
default:
|
|
$key = substr( $schluessel, 0, 4 );
|
|
switch( $key )
|
|
{
|
|
case "alph":
|
|
case "text":
|
|
case "datu":
|
|
case "num_":
|
|
case "geld":
|
|
$attribute[ $schluessel ] = $wert;
|
|
break;
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//echo $buffer;
|
|
}
|
|
|
|
}
|
|
|
|
$dateibinary = file_get_contents( $datei );
|
|
|
|
if ( strlen( $optionen[ "ursprungs_dateiname" ] ) == 0 )
|
|
{
|
|
$optionen[ "ursprungs_dateiname" ] = $pathteile[ "basename" ];
|
|
}
|
|
|
|
if ( strlen( $optionen[ "mime_type" ] ) == 0 )
|
|
{
|
|
switch ( mb_strtolower( $pathteile[ "extension" ] ) )
|
|
{
|
|
case "pdf":
|
|
$optionen[ "mime_type" ] = "application/pdf";
|
|
break;
|
|
case "jpg":
|
|
$optionen[ "mime_type" ] = "image/jpeg";
|
|
break;
|
|
case "png":
|
|
$optionen[ "mime_type" ] = "image/png";
|
|
break;
|
|
case "gif":
|
|
$optionen[ "mime_type" ] = "image/gif";
|
|
break;
|
|
case "akte":
|
|
$optionen[ "mime_type" ] = "text/akte";
|
|
break;
|
|
|
|
default:
|
|
$optionen[ "mime_type" ] = "unknown/unknown";
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
if ( strlen( $optionen[ "dateigroesse" ] ) == 0 )
|
|
{
|
|
$optionen[ "dateigroesse" ] = strlen( $dateibinary );
|
|
}
|
|
|
|
|
|
//xlog( 1, "fertig ".json_encode( $attribute ) );
|
|
// import( $mandant_name, $dokart_kuerzel, $kennung, $attribute, $mehrfachattribute, $dokument_binary, $optionen )
|
|
$ok = import( $mandant_name, $dokart, $kennung, $attribute, array(), $dateibinary, $optionen );
|
|
|
|
if ( $ok[ 0 ] > 0 )
|
|
{
|
|
$dateiimporte_ok++;
|
|
unlink( $datei );
|
|
if ( $idx_datei_existiert )
|
|
{
|
|
xlog( 5, "__wfl.import_lauf: Lösche Index-Datei." );
|
|
unlink( $idx_datei );
|
|
}
|
|
if ( file_exists( $dateiname_fehlerdatei ) )
|
|
{
|
|
xlog( 5, "__wfl.import_lauf: Lösche Fehler-Datei." );
|
|
unlink( $dateiname_fehlerdatei );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$dateiimporte_nicht_ok++;
|
|
file_put_contents ( $dateiname_fehlerdatei, $ok[ 0 ]." | ".$ok[ 1 ] );
|
|
rename( $datei, $fehlerdatei );
|
|
}
|
|
|
|
set_time_limit( 30 );
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( $dateiimporte_nicht_ok > 0 )
|
|
{
|
|
$addon = " Bei ".$dateiimporte_nicht_ok." Dokumenten sind Probleme aufgetreten (siehe Systemlog).";
|
|
}
|
|
|
|
$rc = $dateiimporte_ok;
|
|
$meldung = "Es wurden ".$dateiimporte_ok." Dokumente importiert.".$addon;
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_1[ 0 ];
|
|
$meldung = $ok_1[ 1 ];
|
|
}
|
|
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.import_lauf: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung );
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function erstelle_favorit( $mandant_name, $benutzer_anmeldename, $dok_id, $ueber_element = "root" )
|
|
{
|
|
//xlog( 5, "eingabe ".$mandant_name." ".$benutzer_anmeldename." ".$dok_id." ".$ueber_element );
|
|
|
|
$ok = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok[ 0 ] > 0 )
|
|
{
|
|
$ok_2 = existiert_benutzer( $mandant_name, $benutzer_anmeldename );
|
|
|
|
if ( $ok_2[ 0 ] > 0 )
|
|
{
|
|
if ( ( strlen( $ueber_element ) == 0 ) || ( $ueber_element == "root" ) )
|
|
{
|
|
$ueber_element = "root";
|
|
$log_zusatz = "";
|
|
}
|
|
else
|
|
{
|
|
$log_zusatz = " im Favoritenordner ".$ueber_element;
|
|
}
|
|
|
|
// Prüfen, ob der Favorit vielleicht bereits Favorit ist
|
|
$STATEMENT = "select count(*) anzahl from ca_favoriten where mandant_id = ".$ok[0]." and benutzer_anmeldename = '".$benutzer_anmeldename."' and ueber_elem = '".$ueber_element."' and unter_elem = '".$dok_id."' and unter_elem_typ = 'd'";
|
|
|
|
//xlog( 5, $STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 1 ][ 0 ][ "anzahl" ] == 0 )
|
|
{
|
|
|
|
$STATEMENT = "insert into ca_favoriten ( mandant_id, benutzer_anmeldename, ueber_elem, unter_elem, unter_elem_typ, hinzugefuegt_am ) values ( ".$ok[ 0 ].", '".$benutzer_anmeldename."', '".$ueber_element."', ".$dok_id.", 'd', '".time()."');";
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] == 0 )
|
|
{
|
|
$rc = 0;
|
|
$meldung = "Der Favorit für Benutzer ".$benutzer_anmeldename." (Dok-ID ".$dok_id.$log_zusatz.") wurde angelegt.";
|
|
}
|
|
else
|
|
{
|
|
$rc = -4;
|
|
$meldung = "Der Favorit für Benutzer ".$benutzer_anmeldename." konnte nicht angelegt werden: ".$ergebnis[ 1 ];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -8;
|
|
$meldung = "Der Favorit für Benutzer ".$benutzer_anmeldename." (Dok-ID ".$dok_id.$log_zusatz.") existiert bereits.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_2[ 0 ];
|
|
$meldung = $ok_2[ 1 ];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok[ 0 ];
|
|
$meldung = $ok[ 1 ];
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.erstelle_favorit: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung );
|
|
|
|
|
|
}
|
|
|
|
function erstelle_favoriten_ordner( $mandant_name, $benutzer_anmeldename, $ordnername, $ueber_element = "root", $ansicht = "L" )
|
|
{
|
|
// $ueber_element ist depricated, weil seit der Existenz von Galerien bei den Favoriten nur noch eine einstufige Hierarchie geplant ist.
|
|
|
|
if ( strlen( $ordnername ) > 0 )
|
|
{
|
|
$ok = existiert_mandant( $mandant_name );
|
|
|
|
if ( strlen( $ueber_element ) == 0 )
|
|
{
|
|
$ueber_element = "root";
|
|
}
|
|
if ( strlen( $ansicht ) == 0 )
|
|
{
|
|
$ansicht = "L";
|
|
}
|
|
|
|
if ( $ok[ 0 ] > 0 )
|
|
{
|
|
$ok_2 = existiert_benutzer( $mandant_name, $benutzer_anmeldename );
|
|
|
|
if ( $ok_2[ 0 ] > 0 )
|
|
{
|
|
|
|
$STATEMENT = "select count(*) anzahl from ca_favoriten where mandant_id = ".$ok[0]." and benutzer_anmeldename = '".$benutzer_anmeldename."' and ueber_elem = '".$ueber_element."' and unter_elem = '".$ordnername."' and unter_elem_typ = 'o'";
|
|
|
|
//xlog( 4, $STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
|
|
|
|
if ( $ergebnis[ 1 ][ 0 ][ "anzahl" ] == 0 )
|
|
{
|
|
//xlog( 4, "angekommen! ".$mandant_name." ".$benutzer_anmeldename." ".$ordername." ".$uebergeordnet);
|
|
$STATEMENT = "insert into ca_favoriten ( mandant_id, benutzer_anmeldename, ueber_elem, unter_elem, unter_elem_typ, ansicht, hinzugefuegt_am ) values ( ".$ok[ 0 ].", '".$benutzer_anmeldename."', '".$ueber_element."', '".$ordnername."', 'o', '".$ansicht."', '".time()."' )";
|
|
|
|
//xlog( 3, $STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] == 0 )
|
|
{
|
|
$rc = 0;
|
|
$meldung = "Der Favoritenordner ".$ordnername." wurde für Benutzer ".$benutzer_anmeldename." angelegt.";
|
|
}
|
|
else
|
|
{
|
|
$rc = -4;
|
|
$meldung = "Der Favoritenordner ".$ordnername." für Benutzer ".$benutzer_anmeldename." konnte nicht angelegt werden: ".$ergebnis[ 1 ];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -8;
|
|
$meldung = "Der Favoritenordner für Benutzer ".$benutzer_anmeldename." (Ordner ".$ordnername.", übergeordnetes Element: ".$ueber_element.") existiert bereits.";
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_2[ 0 ];
|
|
$meldung = $ok_2[ 1 ];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok[ 0 ];
|
|
$meldung = $ok[ 1 ];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -18;
|
|
$meldung = "Es wurde kein Ordnername angegeben.";
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.erstelle_favoriten_ordner: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung );
|
|
}
|
|
|
|
function liefere_favoriten_liste( $mandant_name, $benutzer_anmeldename, $ueber_element = "root" )
|
|
{
|
|
$ok = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok[ 0 ] > 0 )
|
|
{
|
|
$ok_2 = existiert_benutzer( $mandant_name, $benutzer_anmeldename );
|
|
|
|
if ( strlen( $ueber_element ) == 0 )
|
|
{
|
|
$ueber_element = "root";
|
|
}
|
|
|
|
if ( $ok_2[ 0 ] > 0 )
|
|
{
|
|
$STATEMENT = "select f.unter_elem, p.dokart_kuerzel, f.hinzugefuegt_am, dd.mime_type from ca_favoriten f, ca_dok_ablage p, ca_dok_datei dd where f.mandant_id = ".$ok[ 0 ]." and f.benutzer_anmeldename = '".$benutzer_anmeldename."' and f.ueber_elem = '".$ueber_element."' and f.unter_elem_typ = 'd' and f.unter_elem = p.dok_id and dd.dok_id = p.dok_id and dd.mandant_id = f.mandant_id and dd.version = p.d_version and f.mandant_id = p.mandant_id order by dokart_kuerzel, hinzugefuegt_am, unter_elem";
|
|
|
|
//xlog( 5, $STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
foreach( $ergebnis[ 1 ] as $zeile )
|
|
{
|
|
$rueckgabe[ $zeile[ "unter_elem" ] ] = array( "dok_id"=>$zeile[ "unter_elem" ], "dokart_kuerzel"=>$zeile[ "dokart_kuerzel" ], "hinzugefuegt_am"=>$zeile[ "hinzugefuegt_am" ], "mime_type"=>$zeile[ "mime_type" ] );
|
|
}
|
|
$rc = $ergebnis[ 0 ];
|
|
$meldung = "Liefere ".$rc." Favoriten für den Benutzer ".$benutzer_anmeldename." (Oberordner: ".$ueber_element.").";
|
|
}
|
|
else
|
|
{
|
|
$rueckgabe = array();
|
|
$rc = $ergebnis[ 0 ];
|
|
$meldung = "Es wurden keine Favoriten gefunden oder Fehler: ".$ergebnis[ 1 ];
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_2[ 0 ];
|
|
$meldung = $ok_2[ 1 ];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok[ 0 ];
|
|
$meldung = $ok[ 1 ];
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.liefere_favoriten_liste: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung, $rueckgabe );
|
|
}
|
|
|
|
function liefere_favoriten_ordner( $mandant_name, $benutzer_anmeldename, $ordnername = "root" )
|
|
{
|
|
$ok = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok[ 0 ] > 0 )
|
|
{
|
|
$ok_2 = existiert_benutzer( $mandant_name, $benutzer_anmeldename );
|
|
|
|
if ( strlen( $ordnername ) == 0 )
|
|
{
|
|
$ordnername = "root";
|
|
}
|
|
|
|
if ( $ok_2[ 0 ] > 0 )
|
|
{
|
|
$STATEMENT = "select unter_elem, ansicht from ca_favoriten where mandant_id = ".$ok[ 0 ]." and benutzer_anmeldename = '".$benutzer_anmeldename."' and ueber_elem = '".$ordnername."' and unter_elem_typ = 'o'";
|
|
|
|
xlog( 4, $STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
foreach( $ergebnis[ 1 ] as $zeile )
|
|
{
|
|
$rueckgabe[ ] = array( "ordnername"=>$zeile[ "unter_elem" ], "ansicht"=>$zeile[ "ansicht" ] );
|
|
//xlog( 2, json_encode( $rueckgabe ) );
|
|
}
|
|
|
|
|
|
$rc = $ergebnis[ 0 ];
|
|
$meldung = "Liefere ".$rc." Favoritenordner für den Benutzer ".$benutzer_anmeldename." (Oberordner: ".$ordnername.").";
|
|
}
|
|
else
|
|
{
|
|
$rueckgabe = array();
|
|
$rc = $ergebnis[ 0 ];
|
|
$meldung = "Es wurden keine Favoritenordner gefunden oder Fehler: ".$ergebnis[ 1 ];
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_2[ 0 ];
|
|
$meldung = $ok_2[ 1 ];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok[ 0 ];
|
|
$meldung = $ok[ 1 ];
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.liefere_favoriten_ordner: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung, $rueckgabe );
|
|
}
|
|
|
|
function loesche_favorit( $mandant_name, $benutzer_anmeldename, $dok_id, $ueber_element = "root" )
|
|
{
|
|
$ok = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok[ 0 ] > 0 )
|
|
{
|
|
$ok_2 = existiert_benutzer( $mandant_name, $benutzer_anmeldename );
|
|
|
|
if ( $ok_2[ 0 ] > 0 )
|
|
{
|
|
if ( strlen( $dok_id ) > 0 )
|
|
{
|
|
if ( ( strlen( $ueber_element ) == 0 ) || ( $ueber_element == "root" ) )
|
|
{
|
|
$ueber_element = "root";
|
|
$log_zusatz = "";
|
|
}
|
|
else
|
|
{
|
|
$log_zusatz = " im Favoritenordner ".$ueber_element;
|
|
}
|
|
|
|
// Prüfen, ob der Favorit vielleicht bereits Favorit ist
|
|
$STATEMENT = "select count(*) anzahl from ca_favoriten where mandant_id = ".$ok[ 0 ]." and benutzer_anmeldename = '".$benutzer_anmeldename."' and ueber_elem = '".$ueber_element."' and unter_elem = '".$dok_id."' and unter_elem_typ = 'd'";
|
|
|
|
//xlog( 5, $STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 1 ][ 0 ][ "anzahl" ] == 1 )
|
|
{
|
|
$STATEMENT = "delete from ca_favoriten where mandant_id = ".$ok[ 0 ]." and benutzer_anmeldename = '".$benutzer_anmeldename."' and ueber_elem = '".$ueber_element."' and unter_elem = '".$dok_id."' and unter_elem_typ = 'd'";
|
|
|
|
//xlog( 5, $STATEMENT );
|
|
|
|
$ergebnis_2 = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis_2[ 0 ] == 0 )
|
|
{
|
|
$rc = 0;
|
|
$meldung = "Der Favorit für Benutzer ".$benutzer_anmeldename." (Dok-ID ".$dok_id.$log_zusatz.") wurde gelöscht.";
|
|
}
|
|
else
|
|
{
|
|
$rc = -4;
|
|
$meldung = "Der Favorit für Benutzer ".$benutzer_anmeldename." konnte nicht gelöscht werden: ".$ergebnis_2[ 1 ];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -8;
|
|
$meldung = "Der Favorit für Benutzer ".$benutzer_anmeldename." (Dok-ID ".$dok_id.$log_zusatz.") existiert nicht.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -7;
|
|
$meldung = "Es wurde keine Dokument-ID angegeben.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_2[ 0 ];
|
|
$meldung = $ok_2[ 1 ];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok[ 0 ];
|
|
$meldung = $ok[ 1 ];
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.loesche_favorit: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung );
|
|
|
|
|
|
}
|
|
|
|
function loesche_favoriten_ordner( $mandant_name, $benutzer_anmeldename, $ordnername, $ueber_element = "root" )
|
|
{
|
|
$ok = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok[ 0 ] > 0 )
|
|
{
|
|
$ok_2 = existiert_benutzer( $mandant_name, $benutzer_anmeldename );
|
|
|
|
if ( $ok_2[ 0 ] > 0 )
|
|
{
|
|
if ( strlen( $ordnername ) > 0 )
|
|
{
|
|
if ( ( strlen( $ueber_element ) == 0 ) || ( $ueber_element == "root" ) )
|
|
{
|
|
$ueber_element = "root";
|
|
$log_zusatz = "";
|
|
}
|
|
else
|
|
{
|
|
$log_zusatz = " im Favoritenordner ".$ueber_element;
|
|
}
|
|
|
|
// Prüfen, ob der Favoritenordner überhaupt existiert für diesen Benutzer
|
|
$STATEMENT = "select count(*) anzahl from ca_favoriten where mandant_id = ".$ok[ 0 ]." and benutzer_anmeldename = '".$benutzer_anmeldename."' and ueber_elem = '".$ueber_element."' and unter_elem = '".$ordnername."' and unter_elem_typ = 'o'";
|
|
|
|
//xlog( 5, $STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 1 ][ 0 ][ "anzahl" ] == 1 )
|
|
{
|
|
$ergebnis = liefere_favoriten_liste( $mandant_name, $benutzer_anmeldename, $ordnername );
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
foreach( $ergebnis[ 2 ] as $favorit )
|
|
{
|
|
$ergebnis = loesche_favorit( $mandant_name, $benutzer_anmeldename, $favorit[ "dok_id" ], $ordnername );
|
|
}
|
|
}
|
|
|
|
$erg_2 = loesche_benutzerspezifische_einstellung( $mandant_name, $benutzer_anmeldename, "favordner_ansicht_".$ordnername );
|
|
|
|
// Ab hier hat der Favoritenordner keine Unterelemente mehr. Jetzt wird er gelöscht.
|
|
|
|
$STATEMENT = "delete from ca_favoriten where mandant_id = ".$ok[ 0 ]." and benutzer_anmeldename = '".$benutzer_anmeldename."' and ueber_elem = '".$ueber_element."' and unter_elem = '".$ordnername."' and unter_elem_typ = 'o'";
|
|
|
|
xlog( 5, $STATEMENT );
|
|
|
|
$ergebnis_2 = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis_2[ 0 ] == 1 )
|
|
{
|
|
$rc = 0;
|
|
$meldung = "Der Favoritenordner ".$ordnername." für Benutzer ".$benutzer_anmeldename." wurde gelöscht.";
|
|
}
|
|
else
|
|
{
|
|
$rc = -4;
|
|
$meldung = "Der Favorit für Benutzer ".$benutzer_anmeldename." konnte nicht gelöscht werden: ".$ergebnis_2[ 1 ];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -8;
|
|
$meldung = "Der Favoritenordner ".$ordnername." für Benutzer ".$benutzer_anmeldename." existiert nicht.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -7;
|
|
$meldung = "Es wurde keine Dokument-ID angegeben.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok_2[ 0 ];
|
|
$meldung = $ok_2[ 1 ];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok[ 0 ];
|
|
$meldung = $ok[ 1 ];
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
xlog( $level, "__wfl.loesche_favoriten_ordner: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung );
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function liefere_galerie( $mandant_name, $galerie, $ebene, $bisherige_auswahl )
|
|
{
|
|
// Diese Funktion soll im Mandanten die Elemente liefern, die auf einer bestimmten Galerieebene liegen. Dabei soll sie angeben, ob es sich um Dokumente oder um Gruppierungen handelt.
|
|
|
|
/*
|
|
Ebene 1 => alpha_03
|
|
Ebene 2 => alpha_04
|
|
Ebene 3 => alpha_05
|
|
Ebene 4 => alpha_06
|
|
Ebene 5 => alpha_07
|
|
|
|
$bisherige_auswahl = array( "ebene_1"=>"Chr. Tegeler", "ebene_2"=>"2014", ... )
|
|
|
|
|
|
*/
|
|
|
|
$gemerkter_wert = "";
|
|
|
|
$ok = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok[ 0 ] > 0 )
|
|
{
|
|
$wm = liefere_wertemenge_elemente( $mandant_name, "galerien" );
|
|
|
|
foreach ( $wm[ 2 ] as $wm_galerie )
|
|
{
|
|
if ( $galerie == $wm_galerie[ "alpha_01" ] )
|
|
{
|
|
// passende Galerie gefunden!
|
|
|
|
$dokuart = $wm_galerie[ "alpha_02" ];
|
|
|
|
$ebene_1 = $wm_galerie[ "alpha_03" ];
|
|
$ebene_2 = $wm_galerie[ "alpha_04" ];
|
|
$ebene_3 = $wm_galerie[ "alpha_05" ];
|
|
$ebene_4 = $wm_galerie[ "alpha_06" ];
|
|
$ebene_5 = $wm_galerie[ "alpha_07" ];
|
|
|
|
|
|
|
|
switch ( $ebene )
|
|
{
|
|
case "1":
|
|
$STATEMENT = "select distinct i.".$ebene_1." from ca_index i, ca_dok_ablage a where a.dok_id = i.dok_id and a.mandant_id = ".$ok[ 0 ]." and a.dokart_kuerzel = '".$dokuart."' order by ".$ebene_1;
|
|
//xlog( 5, $STATEMENT );
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
foreach( $ergebnis[ 1 ] as $treffer )
|
|
{
|
|
if ( substr( $ebene_1, 0, 3 ) == "num" )
|
|
{
|
|
$wert = trim( $treffer[ $ebene_1 ], "0" );
|
|
$wert = trim( $wert, "." );
|
|
}
|
|
else
|
|
{
|
|
$wert = $treffer[ $ebene_1 ];
|
|
}
|
|
$rueckgabe[] = $wert;
|
|
}
|
|
|
|
$rueckgabetyp = "v"; // Verzeichnis
|
|
$rc = count( $rueckgabe );
|
|
$meldung = "Liefere ".$rc." Elemente für Galerieebene ".$ebene." der Galerie ".$galerie.".";
|
|
}
|
|
else
|
|
{
|
|
$rueckgabetyp = "v"; // Verzeichnis
|
|
$rueckgabe = array();
|
|
$rc = 0;
|
|
$meldung = "Es wurden keine Treffer für die Selektion gefunden.";
|
|
}
|
|
|
|
break;
|
|
case "2":
|
|
if ( $ebene_3 == "" )
|
|
{
|
|
$rueckgabetyp = "d"; // Dokumente
|
|
$ebene_2_sel = $ebene_2.", i.dok_id";
|
|
$distinct = "";
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
$rueckgabetyp = "v"; // Verzeichnis
|
|
$ebene_2_sel = $ebene_2;
|
|
$distinct = " distinct ";
|
|
}
|
|
|
|
if ( $bisherige_auswahl[ "ebene_1" ] == "(nicht angegeben)" )
|
|
{
|
|
$t = explode( "_", $ebene_1 );
|
|
|
|
switch ( $t[ 0 ] )
|
|
{
|
|
case "alpha":
|
|
case "text":
|
|
$ebene_1_where = $ebene_1." = ''";
|
|
break;
|
|
case "num":
|
|
case "datum":
|
|
case "geld":
|
|
$ebene_1_where = $ebene_1." is null ";
|
|
break;
|
|
}
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
$ebene_1_where = $ebene_1." = '".$bisherige_auswahl[ "ebene_1" ]."'";
|
|
}
|
|
|
|
$STATEMENT = "select ".$distinct." i.".$ebene_2_sel.", dd.mime_type from ca_index i, ca_dok_ablage a, ca_dok_datei dd where dd.dok_id = a.dok_id and dd.version = a.d_version and a.dok_id = i.dok_id and a.mandant_id = ".$ok[ 0 ]." and a.dokart_kuerzel = '".$dokuart."' and ".$ebene_1_where." order by ".$ebene_2_sel;
|
|
|
|
//xlog(5, "Stufe 2: ". $STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
if ( $ebene_3 == "" )
|
|
{
|
|
// Es müssen Dokumente geliefert werden
|
|
//Initialisierung
|
|
$listenelement = "j309fkswmlfoijmyvfopyivjypvaoirewguskjdhnfiutvbesar";
|
|
foreach( $ergebnis[ 1 ] as $treffer )
|
|
{
|
|
//xlog( 5, "Listenelement = ".$listenelement );
|
|
//xlog( 5, "treffer ebene_2 = ".$treffer[ $ebene_2 ] );
|
|
if ( $listenelement != $treffer[ $ebene_2 ] )
|
|
{
|
|
$listenelement = $treffer[ $ebene_2 ];
|
|
$gefundene_dok_id = $treffer[ "dok_id" ];
|
|
$mime_type = $treffer[ "mime_type" ];
|
|
}
|
|
|
|
//xlog( 5, "listenelement: ".$listenelement );
|
|
|
|
if ( strlen( $listenelement ) == 0 )
|
|
{
|
|
$listenelement = "(nicht angegeben)";
|
|
}
|
|
|
|
$rueckgabe[ $listenelement ] = array( "dok_id"=>$gefundene_dok_id, "mime_type"=>$mime_type );
|
|
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
foreach( $ergebnis[ 1 ] as $treffer )
|
|
{
|
|
//xlog( 1, "ergebnis ".json_encode( $treffer ) );
|
|
if ( strlen( $treffer[ $ebene_2 ] ) == 0 )
|
|
{
|
|
$treffer[ $ebene_2 ] = "(nicht angegeben)";
|
|
}
|
|
|
|
if ( substr( $ebene_2, 0, 3 ) == "num" )
|
|
{
|
|
$wert = trim( $treffer[ $ebene_2 ], "0" );
|
|
$wert = trim( $wert, "." );
|
|
}
|
|
else
|
|
{
|
|
$wert = $treffer[ $ebene_2 ];
|
|
}
|
|
|
|
if ( $wert != $gemerkter_wert )
|
|
{
|
|
$rueckgabe[] = $wert;
|
|
}
|
|
|
|
$gemerkter_wert = $wert;
|
|
}
|
|
}
|
|
|
|
$rc = count( $rueckgabe );
|
|
$meldung = "Liefere ".$rc." Elemente für Galerieebene ".$ebene." der Galerie ".$galerie.".";
|
|
}
|
|
else
|
|
{
|
|
$rueckgabe = array();
|
|
$rc = 0;
|
|
$meldung = "Es wurden keine Treffer für die Selektion gefunden (Galerieebene ".$ebene." der Galerie ".$galerie.").";
|
|
}
|
|
|
|
break;
|
|
case "3":
|
|
if ( $ebene_4 == "" )
|
|
{
|
|
$rueckgabetyp = "d"; // Dokumente
|
|
$ebene_3_sel = $ebene_3.", i.dok_id";
|
|
$distinct = "";
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
$rueckgabetyp = "v"; // Verzeichnis
|
|
$ebene_3_sel = $ebene_3;
|
|
$distinct = " distinct ";
|
|
}
|
|
|
|
if ( $bisherige_auswahl[ "ebene_1" ] == "(nicht angegeben)" )
|
|
{
|
|
$t = explode( "_", $ebene_1 );
|
|
|
|
switch ( $t[ 0 ] )
|
|
{
|
|
case "alpha":
|
|
case "text":
|
|
$ebene_1_where = $ebene_1." = ''";
|
|
break;
|
|
case "num":
|
|
case "datum":
|
|
case "geld":
|
|
$ebene_1_where = $ebene_1." is null ";
|
|
break;
|
|
}
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
$ebene_1_where = $ebene_1." = '".$bisherige_auswahl[ "ebene_1" ]."'";
|
|
}
|
|
|
|
if ( $bisherige_auswahl[ "ebene_2" ] == "(nicht angegeben)" )
|
|
{
|
|
$t = explode( "_", $ebene_2 );
|
|
|
|
switch ( $t[ 0 ] )
|
|
{
|
|
case "alpha":
|
|
case "text":
|
|
$ebene_2_where = $ebene_2." = ''";
|
|
break;
|
|
case "num":
|
|
case "datum":
|
|
case "geld":
|
|
$ebene_2_where = $ebene_2." is null ";
|
|
break;
|
|
}
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
$ebene_2_where = $ebene_2." = '".$bisherige_auswahl[ "ebene_2" ]."'";
|
|
}
|
|
|
|
$STATEMENT = "select ".$distinct." i.".$ebene_3_sel.", dd.mime_type from ca_index i, ca_dok_ablage a, ca_dok_datei dd where dd.dok_id = a.dok_id and dd.version = a.d_version and a.dok_id = i.dok_id and a.mandant_id = ".$ok[ 0 ]." and a.dokart_kuerzel = '".$dokuart."' and ".$ebene_1_where." and ".$ebene_2_where." order by ".$ebene_3_sel;
|
|
|
|
//xlog(5, "Stufe 3: ". $STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
if ( $ebene_4 == "" )
|
|
{
|
|
// Es müssen Dokumente geliefert werden
|
|
//Initialisierung
|
|
$listenelement = "j309fkswmlfoijmyvfopyivjypvaoirewguskjdhnfiutvbesar";
|
|
foreach( $ergebnis[ 1 ] as $treffer )
|
|
{
|
|
//xlog( 5, "Listenelement = ".$listenelement );
|
|
//xlog( 5, "treffer ebene_3 = ".$treffer[ $ebene_3 ] );
|
|
if ( $listenelement != $treffer[ $ebene_3 ] )
|
|
{
|
|
$listenelement = $treffer[ $ebene_3 ];
|
|
$gefundene_dok_id = $treffer[ "dok_id" ];
|
|
$mime_type = $treffer[ "mime_type" ];
|
|
}
|
|
|
|
if ( strlen( $listenelement ) == 0 )
|
|
{
|
|
$listenelement = "(nicht angegeben)";
|
|
}
|
|
|
|
$rueckgabe[ $listenelement ] = array( "dok_id"=>$gefundene_dok_id, "mime_type"=>$mime_type );
|
|
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
foreach( $ergebnis[ 1 ] as $treffer )
|
|
{
|
|
//xlog( 1, "ergebnis ".json_encode( $treffer ) );
|
|
if ( strlen( $treffer[ $ebene_3 ] ) == 0 )
|
|
{
|
|
$treffer[ $ebene_3 ] = "(nicht angegeben)";
|
|
}
|
|
|
|
if ( substr( $ebene_3, 0, 3 ) == "num" )
|
|
{
|
|
$wert = trim( $treffer[ $ebene_3 ], "0" );
|
|
$wert = trim( $wert, "." );
|
|
}
|
|
else
|
|
{
|
|
$wert = $treffer[ $ebene_3 ];
|
|
}
|
|
|
|
if ( $wert != $gemerkter_wert )
|
|
{
|
|
$rueckgabe[] = $wert;
|
|
}
|
|
|
|
$gemerkter_wert = $wert;
|
|
}
|
|
}
|
|
|
|
$rc = count( $rueckgabe );
|
|
$meldung = "Liefere ".$rc." Elemente für Galerieebene ".$ebene." der Galerie ".$galerie.".";
|
|
}
|
|
else
|
|
{
|
|
$rueckgabe = array();
|
|
$rc = 0;
|
|
$meldung = "Es wurden keine Treffer für die Selektion gefunden (Galerieebene ".$ebene." der Galerie ".$galerie.").";
|
|
}
|
|
|
|
break;
|
|
case "4":
|
|
if ( $ebene_5 == "" )
|
|
{
|
|
$rueckgabetyp = "d"; // Dokumente
|
|
$ebene_4_sel = $ebene_4.", i.dok_id";
|
|
$distinct = "";
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
$rueckgabetyp = "v"; // Verzeichnis
|
|
$ebene_4_sel = $ebene_4;
|
|
$distinct = " distinct ";
|
|
}
|
|
|
|
if ( $bisherige_auswahl[ "ebene_1" ] == "(nicht angegeben)" )
|
|
{
|
|
$t = explode( "_", $ebene_1 );
|
|
|
|
switch ( $t[ 0 ] )
|
|
{
|
|
case "alpha":
|
|
case "text":
|
|
$ebene_1_where = $ebene_1." = ''";
|
|
break;
|
|
case "num":
|
|
case "datum":
|
|
case "geld":
|
|
$ebene_1_where = $ebene_1." is null ";
|
|
break;
|
|
}
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
$ebene_1_where = $ebene_1." = '".$bisherige_auswahl[ "ebene_1" ]."'";
|
|
}
|
|
|
|
if ( $bisherige_auswahl[ "ebene_2" ] == "(nicht angegeben)" )
|
|
{
|
|
$t = explode( "_", $ebene_2 );
|
|
|
|
switch ( $t[ 0 ] )
|
|
{
|
|
case "alpha":
|
|
case "text":
|
|
$ebene_2_where = $ebene_2." = ''";
|
|
break;
|
|
case "num":
|
|
case "datum":
|
|
case "geld":
|
|
$ebene_2_where = $ebene_2." is null ";
|
|
break;
|
|
}
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
$ebene_2_where = $ebene_2." = '".$bisherige_auswahl[ "ebene_2" ]."'";
|
|
}
|
|
|
|
if ( $bisherige_auswahl[ "ebene_3" ] == "(nicht angegeben)" )
|
|
{
|
|
$t = explode( "_", $ebene_3 );
|
|
|
|
switch ( $t[ 0 ] )
|
|
{
|
|
case "alpha":
|
|
case "text":
|
|
$ebene_3_where = $ebene_3." = ''";
|
|
break;
|
|
case "num":
|
|
case "datum":
|
|
case "geld":
|
|
$ebene_3_where = $ebene_3." is null ";
|
|
break;
|
|
}
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
$ebene_3_where = $ebene_3." = '".$bisherige_auswahl[ "ebene_3" ]."'";
|
|
}
|
|
|
|
|
|
//$STATEMENT = "select ".$distinct." i.".$ebene_4_sel." from ca_index i, ca_dok_ablage a where a.dok_id = i.dok_id and a.mandant_id = ".$ok[ 0 ]." and a.dokart_kuerzel = '".$dokuart."' and ".$ebene_1." = '".$bisherige_auswahl[ "ebene_1" ]."' and ".$ebene_2." = '".$bisherige_auswahl[ "ebene_2" ]."' and ".$ebene_3." = '".$bisherige_auswahl[ "ebene_3" ]."' order by ".$ebene_4_sel;
|
|
|
|
$STATEMENT = "select ".$distinct." i.".$ebene_4_sel.", dd.mime_type from ca_index i, ca_dok_ablage a, ca_dok_datei dd where dd.dok_id = a.dok_id and dd.version = a.d_version and a.dok_id = i.dok_id and a.mandant_id = ".$ok[ 0 ]." and a.dokart_kuerzel = '".$dokuart."' and ".$ebene_1_where." and ".$ebene_2_where." and ".$ebene_3_where." order by ".$ebene_4_sel;
|
|
|
|
//xlog(5, "Stufe 4: ". $STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
if ( $ebene_5 == "" )
|
|
{
|
|
// Es müssen Dokumente geliefert werden
|
|
//Initialisierung
|
|
$listenelement = "j309fkswmlfoijmyvfopyivjypvaoirewguskjdhnfiutvbesar";
|
|
foreach( $ergebnis[ 1 ] as $treffer )
|
|
{
|
|
//xlog( 5, "Listenelement = ".$listenelement );
|
|
//xlog( 5, "treffer ebene_3 = ".$treffer[ $ebene_3 ] );
|
|
if ( $listenelement != $treffer[ $ebene_3 ] )
|
|
{
|
|
$listenelement = $treffer[ $ebene_4 ];
|
|
$gefundene_dok_id = $treffer[ "dok_id" ];
|
|
$mime_type = $treffer[ "mime_type" ];
|
|
}
|
|
|
|
if ( strlen( $listenelement ) == 0 )
|
|
{
|
|
$listenelement = "(nicht angegeben)";
|
|
}
|
|
|
|
$rueckgabe[ $listenelement ] = array( "dok_id"=>$gefundene_dok_id, "mime_type"=>$mime_type );
|
|
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
foreach( $ergebnis[ 1 ] as $treffer )
|
|
{
|
|
//xlog( 1, "ergebnis ".json_encode( $treffer ) );
|
|
if ( strlen( $treffer[ $ebene_2 ] ) == 0 )
|
|
{
|
|
$treffer[ $ebene_4 ] = "(nicht angegeben)";
|
|
}
|
|
|
|
if ( substr( $ebene_4, 0, 3 ) == "num" )
|
|
{
|
|
$wert = trim( $treffer[ $ebene_4 ], "0" );
|
|
$wert = trim( $wert, "." );
|
|
}
|
|
else
|
|
{
|
|
$wert = $treffer[ $ebene_4 ];
|
|
}
|
|
|
|
if ( $wert != $gemerkter_wert )
|
|
{
|
|
$rueckgabe[] = $wert;
|
|
}
|
|
|
|
$gemerkter_wert = $wert;
|
|
}
|
|
}
|
|
|
|
$rc = count( $rueckgabe );
|
|
$meldung = "Liefere ".$rc." Elemente für Galerieebene ".$ebene." der Galerie ".$galerie.".";
|
|
}
|
|
else
|
|
{
|
|
$rueckgabe = array();
|
|
$rc = 0;
|
|
$meldung = "Es wurden keine Treffer für die Selektion gefunden (Galerieebene ".$ebene." der Galerie ".$galerie.").";
|
|
}
|
|
break;
|
|
case "5":
|
|
$rueckgabetyp = "d"; // Dokumente
|
|
|
|
if ( $bisherige_auswahl[ "ebene_1" ] == "(nicht angegeben)" )
|
|
{
|
|
$bisherige_auswahl[ "ebene_1" ] = "";
|
|
}
|
|
|
|
if ( $bisherige_auswahl[ "ebene_2" ] == "(nicht angegeben)" )
|
|
{
|
|
$bisherige_auswahl[ "ebene_2" ] = "";
|
|
}
|
|
|
|
if ( $bisherige_auswahl[ "ebene_3" ] == "(nicht angegeben)" )
|
|
{
|
|
$bisherige_auswahl[ "ebene_3" ] = "";
|
|
}
|
|
|
|
if ( $bisherige_auswahl[ "ebene_4" ] == "(nicht angegeben)" )
|
|
{
|
|
$bisherige_auswahl[ "ebene_4" ] = "";
|
|
}
|
|
|
|
$STATEMENT = "select i.".$ebene_5.", i.dok_id, dd.mime_type from ca_index i, ca_dok_ablage a, ca_dok_datei dd where dd.dok_id = a.dok_id and dd.version = a.d_version and a.dok_id = i.dok_id and a.mandant_id = ".$ok[ 0 ]." and a.dokart_kuerzel = '".$dokuart."' and ".$ebene_1." = '".$bisherige_auswahl[ "ebene_1" ]."' and ".$ebene_2." = '".$bisherige_auswahl[ "ebene_2" ]."' and ".$ebene_3." = '".$bisherige_auswahl[ "ebene_3" ]."' and ".$ebene_4." = '".$bisherige_auswahl[ "ebene_4" ]."' order by ".$ebene_5.", dok_id";
|
|
|
|
//xlog(5, "Stufe 5: ". $STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
|
|
// Es müssen Dokumente geliefert werden
|
|
//Initialisierung
|
|
$listenelement = "j309fkswmlfoijmyvfopyivjypvaoirewguskjdhnfiutvbesar";
|
|
foreach( $ergebnis[ 1 ] as $treffer )
|
|
{
|
|
if ( $listenelement != $treffer[ $ebene_4 ] )
|
|
{
|
|
$listenelement = $treffer[ $ebene_5 ];
|
|
$gefundene_dok_id = $treffer[ "dok_id" ];
|
|
$mime_type = $treffer[ "mime_type" ];
|
|
}
|
|
|
|
if ( strlen( $listenelement ) == 0 )
|
|
{
|
|
$listenelement = "(nicht angegeben)";
|
|
}
|
|
|
|
$rueckgabe[ $listenelement ] = array( "dok_id"=>$gefundene_dok_id, "mime_type"=>$mime_type );
|
|
|
|
}
|
|
|
|
|
|
|
|
$rc = count( $rueckgabe );
|
|
$meldung = "Liefere ".$rc." Elemente für Galerieebene ".$ebene." der Galerie ".$galerie.".";
|
|
}
|
|
else
|
|
{
|
|
$rueckgabe = array();
|
|
$rc = 0;
|
|
$meldung = "Es wurden keine Treffer für die Selektion gefunden (Galerieebene ".$ebene." der Galerie ".$galerie.").";
|
|
}
|
|
break;
|
|
|
|
default:
|
|
// WTF?
|
|
break;
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok[ 0 ];
|
|
$meldung = $ok[ 1 ];
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
//xlog( 4, json_encode( $rueckgabe ) );
|
|
|
|
xlog( $level, "__wfl.liefere_galerie: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung, $rueckgabe, $rueckgabetyp );
|
|
}
|
|
|
|
function liefere_galerie_elemente( $mandant_name, $galerie, $bisherige_auswahl )
|
|
{
|
|
// $bisherige_auswahl = array( "ebene_1"=>"Chr. Tegeler", "ebene_2"=>"2014", ... )
|
|
|
|
$ok = existiert_mandant( $mandant_name );
|
|
|
|
$rc = "";
|
|
|
|
if ( $ok[ 0 ] > 0 )
|
|
{
|
|
if ( count( $bisherige_auswahl ) != 0 )
|
|
{
|
|
$wm = liefere_wertemenge_elemente( $mandant_name, "galerien" );
|
|
|
|
foreach ( $wm[ 2 ] as $wm_galerie )
|
|
{
|
|
if ( $galerie == $wm_galerie[ "alpha_01" ] )
|
|
{
|
|
// passende Galerie gefunden!
|
|
|
|
$dokuart = $wm_galerie[ "alpha_02" ];
|
|
|
|
$ebene_1 = $wm_galerie[ "alpha_03" ];
|
|
$ebene_2 = $wm_galerie[ "alpha_04" ];
|
|
$ebene_3 = $wm_galerie[ "alpha_05" ];
|
|
$ebene_4 = $wm_galerie[ "alpha_06" ];
|
|
$ebene_5 = $wm_galerie[ "alpha_07" ];
|
|
|
|
$bisherige_auswahl_sel = "i.".$ebene_1." = '".$bisherige_auswahl[ "ebene_1" ]."'";
|
|
|
|
if ( strlen( $ebene_2 ) > 0 )
|
|
{
|
|
if ( $bisherige_auswahl[ "ebene_2" ] == "(nicht angegeben)" )
|
|
{
|
|
$bisherige_auswahl[ "ebene_2" ] = "";
|
|
}
|
|
$bisherige_auswahl_sel = $bisherige_auswahl_sel." and i.".$ebene_2." = '".$bisherige_auswahl[ "ebene_2" ]."'";
|
|
}
|
|
|
|
if ( strlen( $ebene_3 ) > 0 )
|
|
{
|
|
if ( $bisherige_auswahl[ "ebene_3" ] == "(nicht angegeben)" )
|
|
{
|
|
$bisherige_auswahl[ "ebene_3" ] = "";
|
|
}
|
|
$bisherige_auswahl_sel = $bisherige_auswahl_sel." and i.".$ebene_3." = '".$bisherige_auswahl[ "ebene_3" ]."'";
|
|
}
|
|
|
|
if ( strlen( $ebene_4 ) > 0 )
|
|
{
|
|
if ( $bisherige_auswahl[ "ebene_4" ] == "(nicht angegeben)" )
|
|
{
|
|
$bisherige_auswahl[ "ebene_4" ] = "";
|
|
}
|
|
$bisherige_auswahl_sel = $bisherige_auswahl_sel." and i.".$ebene_4." = '".$bisherige_auswahl[ "ebene_4" ]."'";
|
|
}
|
|
|
|
if ( strlen( $ebene_5 ) > 0 )
|
|
{
|
|
if ( $bisherige_auswahl[ "ebene_5" ] == "(nicht angegeben)" )
|
|
{
|
|
$bisherige_auswahl[ "ebene_5" ] = "";
|
|
}
|
|
$bisherige_auswahl_sel = $bisherige_auswahl_sel." and i.".$ebene_5." = '".$bisherige_auswahl[ "ebene_5" ]."'";
|
|
}
|
|
|
|
$STATEMENT = "select i.dok_id, d.mime_type, a.d_version from ca_index i, ca_dok_ablage a, ca_dok_datei d where a.d_version = d.version and d.erw = 0 and a.dok_id = i.dok_id and a.dok_id = d.dok_id and a.mandant_id = ".$ok[ 0 ]." and a.dokart_kuerzel = '".$dokuart."' and a.status = 'offen' and ".$bisherige_auswahl_sel." order by dok_id";
|
|
|
|
//xlog(4, $STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
foreach ( $ergebnis[ 1 ] as $eintrag )
|
|
{
|
|
$rueckgabe[ ] = array( "dok_id"=>$eintrag[ "dok_id" ], "mime_type"=>$eintrag[ "mime_type" ], "d_version"=>$eintrag[ "d_version" ] );
|
|
}
|
|
|
|
$rc = count( $rueckgabe );
|
|
$meldung = "Liefere ".$rc." Elemente für Galerie ".$galerie.".";
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
if ( $rc == "" )
|
|
{
|
|
$rc = -1;
|
|
$meldung = "Es wurde keine passende Galerie gefunden.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -1;
|
|
$meldung = "Es wurde keine bisherige Auswahl übergeben.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok[ 0 ];
|
|
$meldung = $ok[ 1 ];
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
//xlog( 4, json_encode( $rueckgabe ) );
|
|
|
|
xlog( $level, "__wfl.liefere_galerie_elemente: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung, $rueckgabe );
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function liefere_log( $mandant_name )
|
|
{
|
|
$ok = existiert_mandant( $mandant_name );
|
|
|
|
|
|
$stat_arr = stat( "system.log" );
|
|
|
|
$h = fopen( "system.log", r );
|
|
|
|
if ( $stat_arr[ "size" ] > 60000 )
|
|
{
|
|
// Eine Durchschnittszeile ist ca. 200 Zeichen lang. 300 Durchschnittszeilen sind also 60000 Bytes lang.
|
|
$ergebnis = fseek( $h, -60000, SEEK_END );
|
|
}
|
|
|
|
|
|
// wir sind u. U. mitten im Dateistrom gelandet, daher verwerfen wir die erste Zeile:
|
|
fgets( $h );
|
|
|
|
|
|
// Ab jetzt lesen wir die Zeilen ein und parsen sie auch gleich:
|
|
|
|
$logs = array();
|
|
$i = 0;
|
|
|
|
while ( true )
|
|
{
|
|
$zeile = fgets( $h );
|
|
|
|
$logzeile = array();
|
|
|
|
//2014.09.30 15:28:21 INFO 24 __wfl.liefere_wertemenge_elemente: RC 12: Liefere 12 Elemente der Wertemenge >monate<.
|
|
if ( $zeile !== false )
|
|
{
|
|
$i++;
|
|
$datum = substr( $zeile, 0, 10 );
|
|
$uhrzeit = substr( $zeile, 11, 8 );
|
|
$loglevel = trim( substr( $zeile, 20, 5 ) );
|
|
$mandant = trim( substr( $zeile, 26, 2 ) );
|
|
$meldung = trim( substr( $zeile, strpos( $zeile, " ", 26) ) );
|
|
|
|
//xlog( 5, $zeile );
|
|
//xlog( 5, $datum." ".$uhrzeit." ".$loglevel." |".$mandant."| ".$meldung );
|
|
|
|
$logzeile[ "datum" ] = $datum;
|
|
$logzeile[ "uhrzeit" ] = $uhrzeit;
|
|
$logzeile[ "loglevel" ] = $loglevel;
|
|
$logzeile[ "mandant" ] = $mandant;
|
|
$logzeile[ "meldung" ] = $meldung;
|
|
|
|
if ( $ok[ 0 ] == $mandant )
|
|
{
|
|
// in umgekehrter Reihenfolge ablegen
|
|
//xlog( 3, substr( json_encode( $logzeile ), 0, 220 ) );
|
|
$logs[ bcsub( 1500, $i, 0 ) ] = $logzeile;
|
|
}
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
$logs_fertig = array();
|
|
|
|
if ( count( $logs ) > 0 )
|
|
{
|
|
$k = 0;
|
|
for ( $i = 0; $i <= 1500; $i++ )
|
|
{
|
|
/// xlog( 5, "jayson ".json_encode( $logs[ $i ][ "meldung" ] ) );
|
|
if ( strlen( $logs[ $i ][ "meldung" ] ) > 0 )
|
|
{
|
|
// sortiere von neu nach alt
|
|
|
|
//xlog( 4, "logs_i ".json_encode($logs[ $i ] ) );
|
|
$logs_fertig[ $k ] = $logs[ $i ];
|
|
$k++;
|
|
}
|
|
}
|
|
}
|
|
|
|
//xlog( 4, "anzahl logeinträge ".count( $logs_fertig ) );
|
|
|
|
return $logs_fertig;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function erzeuge_postkorb_element( $mandant_name, $dok_id, $empfaenger, $sender_benutzer, $betreff, $typ, $empfaenger_typ = "b", $erinnern_am = "", $quittieren_bis = "", $zustellen_am = "", $workflow_id = 0, $maske_id = 0 )
|
|
{
|
|
$ok = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok[ 0 ] > 0 )
|
|
{
|
|
if ( ! ( ( strlen( $empfaenger ) == 0 ) || ( strlen( $sender_benutzer ) == 0 ) || ( ( strlen( $betreff ) == 0 ) && ( ( $typ != "quittung" ) ) ) || ( strlen( $typ ) == 0 ) || ( strlen( $dok_id ) == 0 ) || ( ! ( ( $empfaenger_typ == "b" ) || ( $empfaenger_typ == "g" ) ) ) ) )
|
|
{
|
|
/*
|
|
if ( $typ == "quittung" )
|
|
{
|
|
if ( $empfaenger_typ == "b" )
|
|
{
|
|
$benutzer = liefere_benutzerinformationen( $mandant_name, $empfaenger );
|
|
$betreff = "Der Benutzer ".$benutzer[ 2 ][ "benutzer_name" ]." (".$empfaenger.") hat das Dokument zur Kenntnis genommen.";
|
|
}
|
|
else
|
|
{
|
|
$betreff = "Ein Mitglied der Gruppe ".$empfaenger." hat das Dokument ".$dok_id." zur Kenntnis genommen.";
|
|
}
|
|
|
|
}
|
|
*/
|
|
|
|
$ursprung = "";
|
|
|
|
if ( $empfaenger_typ == "g" )
|
|
{
|
|
$id = liefere_gruppeninformationen( $mandant_name, $empfaenger );
|
|
$emp = " der Gruppe ".$empfaenger;
|
|
}
|
|
else
|
|
{
|
|
$id = liefere_benutzerinformationen( $mandant_name, $empfaenger );
|
|
$emp = " dem Benutzer ".$id[ 2 ][ "benutzer_name_komplett" ];
|
|
}
|
|
|
|
if ( $id[ 0 ] > 0 )
|
|
{
|
|
|
|
if ( $id[ 2 ][ "benutzer_abwesend" ] == "ja" )
|
|
{
|
|
$ursprung = $empfaenger;
|
|
$empfaenger = $id[ 2 ][ "benutzer_vertreter" ];
|
|
$empfaenger_typ = $id[ 2 ][ "benutzer_vertreter_typ" ];
|
|
}
|
|
|
|
$quittieren_bis = datum2mysql( $quittieren_bis );
|
|
$erinnern_am = datum2mysql( $erinnern_am );
|
|
$zustellen_am = datum2mysql( $zustellen_am );
|
|
|
|
$STATEMENT = "insert into ca_postkorb ( mandant_id, dok_id, empfaenger, empfaenger_typ, sender_benutzer, empfangen_am, quittieren_bis, erinnern_am, typ, gelesen, betreff, ursprung, zustellen_am, wid, mid ) values ( ".$ok[ 0 ].", ".$dok_id.", '".$empfaenger."', '".$empfaenger_typ."', '".$sender_benutzer."', '".time()."', '".$quittieren_bis."', '".$erinnern_am."', '".$typ."', 0, '".$betreff."', '".$ursprung."', '".$zustellen_am."', ".$workflow_id.", ".$maske_id." )";
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
$rc = $ergebnis[ 0 ];
|
|
|
|
$notiz = liefere_konfig( $mandant_name, "postkorbeintrag_erzeugt_notiz" );
|
|
|
|
if ( $notiz == "ja" )
|
|
{
|
|
$b = liefere_benutzerinformationen( $mandant_name, $sender_benutzer );
|
|
|
|
$e = notiz_an_dokument_anlegen( $mandant_name, $dok_id, "Der Benutzer ".$b[ 2 ][ "benutzer_name_komplett" ]." hat das Dokument ".$dok_id." ".$emp." in den Postkorb gelegt (Postkorb-Element-ID ".$rc.")." );
|
|
|
|
$m = " Dieser Sachverhalt wurde per Notiz am Dokument ".$dok_id." festgehalten.";
|
|
}
|
|
|
|
$meldung = "Das Postkorbelement wurde mit der ID ".$rc." erstellt.".$m;
|
|
}
|
|
else
|
|
{
|
|
$rc = -3;
|
|
$meldung = "Es ist ein Fehler aufgetreten: ".$ergebnis[ 1 ];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -5;
|
|
$meldung = $empfaenger." ist kein gültiger Empfänger.";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -9;
|
|
$meldung = "Die Funktion wurde mit falschen Parametern aufgerufen: dok_id|empfaenger|sender|betreff|typ|empfaenger_typ => ".$dok_id."|".$empfaenger."|".$sender_benutzer."|".$betreff."|".$typ."|".$empfaenger_typ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok[ 0 ];
|
|
$meldung = $ok[ 1 ];
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
|
|
|
|
xlog( $level, "__wfl.erzeuge_postkorb_element: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung );
|
|
}
|
|
|
|
function quittiere_postkorb_element( $mandant_name, $element_id )
|
|
{
|
|
$ok = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok[ 0 ] > 0 )
|
|
{
|
|
if ( ! ( strlen( $element_id ) == 0 ) )
|
|
{
|
|
$STATEMENT = "select dok_id from ca_postkorb where element_id = ".$element_id;
|
|
|
|
$e = xdb( $STATEMENT );
|
|
|
|
$dok_id = $e[ 1 ][ 0 ][ "dok_id" ];
|
|
|
|
$STATEMENT = "update ca_postkorb set quittiert_am = '".time()."' where element_id = ".$element_id;
|
|
|
|
//xlog( 4, $STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
//xlog( 5, json_encode( $ergebnis ) );
|
|
|
|
if ( $ergebnis[ 0 ] == 0 )
|
|
{
|
|
$rc = $ergebnis[ 0 ];
|
|
|
|
$notiz = liefere_konfig( $mandant_name, "postkorbeintrag_erzeugt_notiz" );
|
|
|
|
if ( $notiz == "ja" )
|
|
{
|
|
$b = liefere_benutzerinformationen( $mandant_name, $_SESSION[ "benutzer_anmeldename" ] );
|
|
|
|
$e = notiz_an_dokument_anlegen( $mandant_name, $dok_id, "Der Benutzer ".$b[ 2 ][ "benutzer_name_komplett" ]." hat das Dokument ".$dok_id." quittiert (Postkorb-Element-ID ".$element_id.")." );
|
|
|
|
$m = " Dieser Sachverhalt wurde per Notiz am Dokument ".$dok_id." festgehalten.";
|
|
}
|
|
|
|
$meldung = "Das Postkorbelement mit der ID ".$element_id." wurde quittiert.".$m;
|
|
}
|
|
else
|
|
{
|
|
$rc = -3;
|
|
$meldung = "Es ist ein Fehler aufgetreten: ".$ergebnis[ 1 ];
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = -9;
|
|
$meldung = "Die Funktion wurde mit falschen Parametern aufgerufen: element_id => ".$element_id;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok[ 0 ];
|
|
$meldung = $ok[ 1 ];
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
|
|
|
|
xlog( $level, "__wfl.quittiere_postkorb_element: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung );
|
|
}
|
|
|
|
function markiere_postkorb_element_als_gelesen( $mandant_name, $element_id )
|
|
{
|
|
$ok = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok[ 0 ] > 0 )
|
|
{
|
|
if ( ! ( strlen( $element_id ) == 0 ) )
|
|
{
|
|
$STATEMENT = "update ca_postkorb set gelesen = 1 where element_id = ".$element_id;
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] == 0 )
|
|
{
|
|
$rc = $ergebnis[ 0 ];
|
|
$meldung = "Das Postkorbelement mit der ID ".$element_id." wurde als gelesen markiert.";
|
|
}
|
|
else
|
|
{
|
|
$rc = -3;
|
|
$meldung = "Es ist ein Fehler aufgetreten: ".$ergebnis[ 1 ];
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = -9;
|
|
$meldung = "Die Funktion wurde mit falschen Parametern aufgerufen: element_id => ".$element_id;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok[ 0 ];
|
|
$meldung = $ok[ 1 ];
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
|
|
|
|
xlog( $level, "__wfl.markiere_postkorb_element_als_gelesen: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung );
|
|
}
|
|
|
|
function markiere_postkorb_element_als_ungelesen( $mandant_name, $element_id )
|
|
{
|
|
$ok = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok[ 0 ] > 0 )
|
|
{
|
|
if ( ! ( strlen( $element_id ) == 0 ) )
|
|
{
|
|
$STATEMENT = "update ca_postkorb set gelesen = 0 where element_id = ".$element_id;
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] == 0 )
|
|
{
|
|
$rc = $ergebnis[ 0 ];
|
|
$meldung = "Das Postkorbelement mit der ID ".$rc." wurde als ungelesen markiert.";
|
|
}
|
|
else
|
|
{
|
|
$rc = -3;
|
|
$meldung = "Es ist ein Fehler aufgetreten: ".$ergebnis[ 1 ];
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = -9;
|
|
$meldung = "Die Funktion wurde mit falschen Parametern aufgerufen: element_id => ".$element_id;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok[ 0 ];
|
|
$meldung = $ok[ 1 ];
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 6;
|
|
}
|
|
|
|
|
|
|
|
xlog( $level, "__wfl.markiere_postkorb_element_als_ungelesen: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung );
|
|
}
|
|
|
|
function liefere_postkorb_elemente( $mandant_name, $empfaenger, $empfaenger_typ, $zukunft = false, $erinnern = false )
|
|
{
|
|
|
|
$ok = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok[ 0 ] > 0 )
|
|
{
|
|
if ( ! ( ( strlen( $empfaenger ) == 0 ) || ( strlen( $empfaenger_typ ) == 0 ) ) )
|
|
{
|
|
if ( !( ( $zukunft ) && ( $erinnern ) ) )
|
|
{
|
|
|
|
$heute = date( "d.m.Y" );
|
|
|
|
$heute = datum2mysql( $heute );
|
|
|
|
if ( $zukunft == false )
|
|
{
|
|
$op = " <= ";
|
|
}
|
|
else
|
|
{
|
|
$op = " > ";
|
|
}
|
|
|
|
if ( $erinnern == true )
|
|
{
|
|
$erinnern_where = " erinnern_am <= '".$heute."' and erinnern_am <> '00-00-0000' and";
|
|
}
|
|
else
|
|
{
|
|
$erinnern_where = "";
|
|
}
|
|
|
|
$STATEMENT = "SELECT p.empfaenger, p.empfaenger_typ, p.element_id, p.dok_id, d.dokart_name, d.dokart_kuerzel, a.titel, a.titel_lang, a.a_flag, a.n_flag, a.v_flag, a.j_flag, dd.mime_type, p.sender_benutzer, p.empfangen_am, p.quittiert_am, p.quittieren_bis, p.erinnern_am, p.betreff, p.typ, p.gelesen, p.ursprung, p.zustellen_am, p.wid, p.mid FROM ca_postkorb p, ca_dokart d, ca_dok_ablage a, ca_dok_datei dd WHERE ".$erinnern_where." p.empfaenger = '".$empfaenger."' and empfaenger_typ = '".$empfaenger_typ."' AND p.dok_id = a.dok_id AND a.dokart_kuerzel = d.dokart_kuerzel and dd.dok_id = a.dok_id and a.d_version = dd.version and dd.erw='0' and p.quittiert_am = '' and p.mandant_id = ".$ok[ 0 ]." and d.mandant_id = ".$ok[ 0 ]." and zustellen_am ".$op." '".$heute."' order by empfangen_am desc limit 0, 250 ";
|
|
|
|
|
|
|
|
//xlog( 4, $STATEMENT );
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] >= 0 )
|
|
{
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
foreach( $ergebnis[ 1 ] as $treffer )
|
|
{
|
|
// "sender_vorname"=>$treffer[ "benutzer_vorname" ], "sender_nachname"=>$treffer[ "benutzer_nachname" ],
|
|
$elemente[] = array( "empfaenger"=>$treffer[ "empfaenger" ], "empfaenger_typ"=>$treffer[ "empfaenger_typ" ], "element_id"=>$treffer[ "element_id" ], "dokart_kuerzel"=>$treffer[ "dokart_kuerzel" ], "dokart_name"=>$treffer[ "dokart_name" ], "betreff"=>$treffer[ "betreff" ], "typ"=>$treffer[ "typ" ], "gelesen"=>$treffer[ "gelesen" ], "dok_id"=>$treffer[ "dok_id" ], "sender_benutzer"=>$treffer[ "sender_benutzer" ], "empfangen_am"=>date( "d.m.Y H:i", $treffer[ "empfangen_am" ] )." Uhr", "quittieren_bis"=>mysql2datum( $treffer[ "quittieren_bis" ] ), "erinnern_am"=>mysql2datum( $treffer[ "erinnern_am" ] ), "mime_type"=>$treffer[ "mime_type" ], "titel"=>$treffer[ "titel" ], "titel_lang"=>$treffer[ "titel_lang" ], "a_flag"=>$treffer[ "a_flag" ], "n_flag"=>$treffer[ "n_flag" ], "v_flag"=>$treffer[ "v_flag" ], "j_flag"=>$treffer[ "j_flag" ], "ursprung"=>$treffer[ "ursprung" ], "zustellen_am"=>mysql2datum( $treffer[ "zustellen_am" ] ), "workflow_id"=>$treffer[ "wid" ], "maske_id"=>$treffer[ "mid" ] );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$elemente = array();
|
|
}
|
|
if ( $empfaenger_typ == "b" )
|
|
{
|
|
$text = " den Benutzer ";
|
|
}
|
|
else
|
|
{
|
|
$text = " die Gruppe ";
|
|
}
|
|
|
|
$rc = $ergebnis[ 0 ];
|
|
//$elemente = $ergebnis[ 1 ];
|
|
$meldung = "Liefere ".$rc." Elemente für".$text.$empfaenger.".";
|
|
}
|
|
else
|
|
{
|
|
$rc = -3;
|
|
$elemente = array();
|
|
$meldung = "Es ist ein Fehler aufgetreten: ".$ergebnis[ 1 ];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -5;
|
|
$meldung = "Falscher Funktionsaufruf: zukunft und erinnern können nicht beide true sein.";
|
|
$elemente = array();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = -9;
|
|
$meldung = "Die Funktion wurde mit falschen Parametern aufgerufen: empfaenger|empfaenger_typ => ".$empfaenger."|".$empfaenger_typ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok[ 0 ];
|
|
$meldung = $ok[ 1 ];
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 6;
|
|
}
|
|
|
|
|
|
|
|
xlog( $level, "__wfl.liefere_postkorb_elemente: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung, $elemente );
|
|
}
|
|
|
|
function loesche_postkorb_element( $mandant_name, $element_id )
|
|
{
|
|
$ok = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok[ 0 ] > 0 )
|
|
{
|
|
if ( ! ( strlen( $element_id ) == 0 ) )
|
|
{
|
|
$STATEMENT = "delete from ca_postkorb where element_id = ".$element_id;
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] == 0 )
|
|
{
|
|
$rc = $ergebnis[ 0 ];
|
|
$meldung = "Das Postkorbelement mit der ID ".$rc." wurde als gelesen markiert.";
|
|
}
|
|
else
|
|
{
|
|
$rc = -3;
|
|
$meldung = "Es ist ein Fehler aufgetreten: ".$ergebnis[ 1 ];
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = -9;
|
|
$meldung = "Die Funktion wurde mit falschen Parametern aufgerufen: element_id => ".$element_id;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok[ 0 ];
|
|
$meldung = $ok[ 1 ];
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
|
|
|
|
xlog( $level, "__wfl.loesche_postkorb_element: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung );
|
|
}
|
|
|
|
function liefere_postkorb_gesendete_elemente( $mandant_name, $sender )
|
|
{
|
|
|
|
$ok = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok[ 0 ] > 0 )
|
|
{
|
|
if ( ! ( strlen( $sender ) == 0 ) )
|
|
{
|
|
$STATEMENT = "SELECT p.empfaenger, p.empfaenger_typ, p.element_id, p.dok_id, d.dokart_name, d.dokart_kuerzel, a.titel, a.titel_lang, a.a_flag, a.n_flag, a.v_flag, a.j_flag, dd.mime_type, p.sender_benutzer, p.empfangen_am, p.quittiert_am, p.quittieren_bis, p.erinnern_am, p.betreff, p.typ, p.gelesen FROM ca_postkorb p, ca_dokart d, ca_dok_ablage a, ca_dok_datei dd WHERE p.sender_benutzer = '".$sender."' AND p.dok_id = a.dok_id AND a.dokart_kuerzel = d.dokart_kuerzel and dd.dok_id = a.dok_id and a.d_version = dd.version and dd.erw='0' and p.mandant_id = ".$ok[ 0 ]." order by empfangen_am desc";
|
|
|
|
//xlog( 4, $STATEMENT );
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
foreach( $ergebnis[ 1 ] as $treffer )
|
|
{
|
|
$elemente[] = array( "empfaenger"=>$treffer[ "empfaenger" ], "empfaenger_typ"=>$treffer[ "empfaenger_typ" ], "element_id"=>$treffer[ "element_id" ], "dokart_kuerzel"=>$treffer[ "dokart_kuerzel" ], "dokart_name"=>$treffer[ "dokart_name" ], "betreff"=>$treffer[ "betreff" ], "typ"=>$treffer[ "typ" ], "gelesen"=>$treffer[ "gelesen" ], "dok_id"=>$treffer[ "dok_id" ], "sender_benutzer"=>$treffer[ "sender_benutzer" ], "empfangen_am"=>date( "d.m.Y H:i", $treffer[ "empfangen_am" ] )." Uhr", "quittieren_bis"=>mysql2datum( $treffer[ "quittieren_bis" ] ), "erinnern_am"=>mysql2datum( $treffer[ "erinnern_am" ] ), "mime_type"=>$treffer[ "mime_type" ], "titel"=>$treffer[ "titel" ], "titel_lang"=>$treffer[ "titel_lang" ], "a_flag"=>$treffer[ "a_flag" ], "n_flag"=>$treffer[ "n_flag" ], "v_flag"=>$treffer[ "v_flag" ], "j_flag"=>$treffer[ "j_flag" ] );
|
|
}
|
|
|
|
|
|
|
|
|
|
$rc = $ergebnis[ 0 ];
|
|
//$elemente = $ergebnis[ 1 ];
|
|
$meldung = "Liefere ".$rc." gesendete Elemente für den Benutzer ".$sender.".";
|
|
}
|
|
else
|
|
{
|
|
if ( $ergebnis[ 0 ] == 0 )
|
|
{
|
|
$rc = 0;
|
|
$elemente = array();
|
|
$meldung = "Es wurden keine Elemente gefunden.";
|
|
}
|
|
else
|
|
{
|
|
$rc = -3;
|
|
$elemente = array();
|
|
$meldung = "Es ist ein Fehler aufgetreten: ".$ergebnis[ 1 ];
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = -9;
|
|
$meldung = "Die Funktion wurde mit falschen Parametern aufgerufen: sender => ".$sender;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok[ 0 ];
|
|
$meldung = $ok[ 1 ];
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
|
|
|
|
xlog( $level, "__wfl.liefere_postkorb_gesendete_elemente: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung, $elemente );
|
|
}
|
|
|
|
function finde_dok_in_postkorb( $mandant_name, $dok_id )
|
|
{
|
|
$ok = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok[ 0 ] > 0 )
|
|
{
|
|
if ( strlen( $dok_id ) > 0 )
|
|
{
|
|
$STATEMENT = "select empfaenger, '' as benutzer_vorname, '' as benutzer_nachname, '' as benutzer_anmeldename, '' as benutzer_geschlecht, empfaenger_typ, ursprung from ca_postkorb where quittiert_am = '' and empfaenger_typ = 'g' and dok_id = ".$dok_id." union select p.empfaenger, b.benutzer_vorname, b.benutzer_nachname, b.benutzer_anmeldename, b.benutzer_geschlecht, p.empfaenger_typ, p.ursprung from ca_postkorb p, ca_benutzer b where quittiert_am = '' and p.empfaenger = b.benutzer_anmeldename and p.empfaenger_typ = 'b' and dok_id = ".$dok_id;
|
|
|
|
//xlog( 4, $STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
$e = $ergebnis[ 1 ];
|
|
$rc = count( $e );
|
|
$meldung = "Das Dokument ".$dok_id." liegt in ".$rc." Postkörben.";
|
|
|
|
}
|
|
elseif ( $ergebnis[ 0 ] == 0 )
|
|
{
|
|
$rc = 0;
|
|
$e = array();
|
|
$meldung = "Das Dokument mit der ID ".$dok_id." wurde in keinem Postkorb gefunden.";
|
|
}
|
|
else
|
|
{
|
|
$rc = -4;
|
|
$meldung = "Es ist ein Fehler aufgetreten: ".$ergebnis[ 1 ];
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = -9;
|
|
$meldung = "Die Parametrisierung ist nicht korrekt: dok_id => ".$dok_id;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok[ 0 ];
|
|
$meldung = $ok[ 1 ];
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 6;
|
|
}
|
|
|
|
|
|
|
|
xlog( $level, "__wfl.finde_dok_in_postkorb: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung, $e );
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function speichere_recherche( $mandant_name, $dokart_kuerzel, $stichwoerter, $benutzer_anmeldename, $schablonenname, $sortierung = array(), $anzahl_treffer = 250, $rech_stil='Liste' )
|
|
{
|
|
$ok = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok[ 0 ] > 0 )
|
|
{
|
|
if ( ( strlen( $dokart_kuerzel ) > 0 ) && ( is_array( $stichwoerter ) ) && ( strlen( $benutzer_anmeldename ) > 0 ) )
|
|
{
|
|
$STATEMENT = "insert into ca_rech_verlauf ( mandant_id, dokart_kuerzel, benutzer_anmeldename, stichwoerter, schablonenname, sortierung, anzahl_treffer, recherche_stil, angelegt_am, datum ) values ( ".$ok[ 0 ].", '".$dokart_kuerzel."', '".$benutzer_anmeldename."', '".json_encode( $stichwoerter )."', '".$schablonenname."', '".json_encode( $sortierung )."', ".$anzahl_treffer.", '".$rech_stil."', '".time()."', '".datum2mysql( date( "d.m.Y" ) )."' )";
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
$rc = $ergebnis[ 0 ];
|
|
$meldung = "Die Recherche in der Dokumentart ".$dokart_kuerzel." wurde mit der ID ".$rc." für den Benutzer ".$benutzer_anmeldename." abgelegt.";
|
|
}
|
|
else
|
|
{
|
|
$rc = $ergebnis[ 0 ];
|
|
$meldung = "Es ist ein Fehler aufgetreten: ".$ergebnis[ 1 ];
|
|
}
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = -9;
|
|
$meldung = "Die Parametrisierung ist nicht korrekt: dokart_kuerzel|stichwoerter|benutzer_anmeldename|schablonen_name => ".$dokart_kuerzel."|".$stichwoerter."|".$benutzer_anmeldename."|".$schablonen_name;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok[ 0 ];
|
|
$meldung = $ok[ 1 ];
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 6;
|
|
}
|
|
|
|
|
|
|
|
xlog( $level, "__wfl.speichere_recherche: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung );
|
|
}
|
|
|
|
function liefere_gespeicherte_recherche( $mandant_name, $benutzer_anmeldename, $id = "", $name = "" )
|
|
{
|
|
$ok = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok[ 0 ] > 0 )
|
|
{
|
|
if ( ( strlen( $benutzer_anmeldename ) > 0 ) && ( ( strlen( $id ) > 0 ) || ( strlen( $name ) > 0 ) ) )
|
|
{
|
|
if ( strlen( $id ) > 0 )
|
|
{
|
|
$bedingung = " crv.id = ".$id;
|
|
}
|
|
else
|
|
{
|
|
$bedingung = " crv.schablonenname = ".$name;
|
|
}
|
|
|
|
|
|
$STATEMENT = "select crv.mandant_id, crv.id, crv.dokart_kuerzel, cd.dokart_name, crv.benutzer_anmeldename, crv.stichwoerter, crv.schablonenname, crv.sortierung, crv.anzahl_treffer, crv.recherche_stil, crv.angelegt_am, crv.datum from ca_rech_verlauf crv, ca_dokart cd where crv.mandant_id = ".$ok[ 0 ]." and cd.mandant_id = ".$ok[ 0 ]." and crv.benutzer_anmeldename = '".$benutzer_anmeldename."' and crv.dokart_kuerzel = cd.dokart_kuerzel and ".$bedingung;
|
|
|
|
xlog( 6, $STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
$ergebnis_arr[ "mandant_id" ] = $ergebnis[ 1 ][ 0 ][ "mandant_id" ];
|
|
$ergebnis_arr[ "id" ] = $ergebnis[ 1 ][ 0 ][ "id" ];
|
|
$ergebnis_arr[ "dokart_kuerzel" ] = $ergebnis[ 1 ][ 0 ][ "dokart_kuerzel" ];
|
|
$ergebnis_arr[ "dokart_name" ] = $ergebnis[ 1 ][ 0 ][ "dokart_name" ];
|
|
$ergebnis_arr[ "benutzer_anmeldename" ] = $ergebnis[ 1 ][ 0 ][ "benutzer_anmeldename" ];
|
|
$ergebnis_arr[ "stichwoerter" ] = json_decode( $ergebnis[ 1 ][ 0 ][ "stichwoerter" ], true );
|
|
$ergebnis_arr[ "schablonenname" ] = $ergebnis[ 1 ][ 0 ][ "schablonenname" ];
|
|
$ergebnis_arr[ "name" ] = $ergebnis[ 1 ][ 0 ][ "schablonenname" ];
|
|
$ergebnis_arr[ "sortierung" ] = json_decode( $ergebnis[ 1 ][ 0 ][ "sortierung" ], true );
|
|
$ergebnis_arr[ "anzahl_treffer" ] = $ergebnis[ 1 ][ 0 ][ "anzahl_treffer" ];
|
|
$ergebnis_arr[ "angelegt_am" ] = $ergebnis[ 1 ][ 0 ][ "angelegt_am" ];
|
|
$ergebnis_arr[ "rech_stil" ] = $ergebnis[ 1 ][ 0 ][ "recherche_stil" ];
|
|
$ergebnis_arr[ "recherche_stil" ] = $ergebnis[ 1 ][ 0 ][ "recherche_stil" ];
|
|
$ergebnis_arr[ "datum" ] = mysql2datum( $ergebnis[ 1 ][ 0 ][ "datum" ] );
|
|
|
|
$rc = $ergebnis[ 0 ];
|
|
$meldung = "Liefere gespeicherte Recherche mit der ID ".$rc.".";
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = $ergebnis[ 0 ];
|
|
$meldung = "Gespeicherte Recherche nicht gefunden oder es ist ein Fehler aufgetreten: ".$ergebnis[ 1 ];
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = -9;
|
|
$meldung = "Die Parametrisierung ist nicht korrekt: mandant_name|benutzer_anmeldename|id|name => ".$mandant_name."|".$benutzer_anmeldename."|".$id."|".$name;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok[ 0 ];
|
|
$meldung = $ok[ 1 ];
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
|
|
|
|
xlog( $level, "__wfl.liefere_gespeicherte_recherche: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung, $ergebnis_arr );
|
|
}
|
|
|
|
function liefere_gespeicherte_recherchen_fuer_benutzer( $mandant_name, $benutzer_anmeldename, $gesverlauf = 's' )
|
|
{
|
|
$ok = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok[ 0 ] > 0 )
|
|
{
|
|
if ( ( strlen( $benutzer_anmeldename ) > 0 ) )
|
|
{
|
|
// alle, nur verlauf, nur gespeicherte?
|
|
switch( $gesverlauf )
|
|
{
|
|
case "v":
|
|
// nur Verlauf
|
|
$bedingung = " and schablonenname = ''";
|
|
break;
|
|
case "s":
|
|
// nur gespeicherte
|
|
$bedingung = " and schablonenname != ''";
|
|
break;
|
|
default:
|
|
case "a":
|
|
$bedingung = "";
|
|
break;
|
|
|
|
}
|
|
|
|
$STATEMENT = "select crv.mandant_id, crv.id, crv.dokart_kuerzel, cd.dokart_name, crv.benutzer_anmeldename, crv.stichwoerter, crv.schablonenname, crv.sortierung, crv.anzahl_treffer, crv.recherche_stil, crv.angelegt_am, crv.datum from ca_rech_verlauf crv, ca_dokart cd where crv.mandant_id = ".$ok[ 0 ]." and cd.mandant_id = ".$ok[ 0 ]." and cd.mandant_id = ".$ok[ 0 ]." and cd.dokart_kuerzel = crv.dokart_kuerzel and crv.benutzer_anmeldename = '".$benutzer_anmeldename."' ".$bedingung." order by crv.datum desc, crv.angelegt_am desc";
|
|
|
|
|
|
xlog( 6, $STATEMENT );
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
$e = array();
|
|
foreach( $ergebnis[ 1 ] as $gespeicherte_recherche )
|
|
{
|
|
$ergebnis_arr = array();
|
|
$ergebnis_arr[ "mandant_id" ] = $gespeicherte_recherche[ "mandant_id" ];
|
|
$ergebnis_arr[ "id" ] = $gespeicherte_recherche[ "id" ];
|
|
$ergebnis_arr[ "dokart_kuerzel" ] = $gespeicherte_recherche[ "dokart_kuerzel" ];
|
|
$ergebnis_arr[ "dokart_name" ] = $gespeicherte_recherche[ "dokart_name" ];
|
|
$ergebnis_arr[ "benutzer_anmeldename" ] = $gespeicherte_recherche[ "benutzer_anmeldename" ];
|
|
$ergebnis_arr[ "stichwoerter" ] = json_decode( $gespeicherte_recherche[ "stichwoerter" ], true );
|
|
$ergebnis_arr[ "schablonenname" ] = $gespeicherte_recherche[ "schablonenname" ];
|
|
$ergebnis_arr[ "name" ] = $gespeicherte_recherche[ "schablonenname" ];
|
|
$ergebnis_arr[ "sortierung" ] = json_decode( $gespeicherte_recherche[ "sortierung" ], true );
|
|
$ergebnis_arr[ "anzahl_treffer" ] = $gespeicherte_recherche[ "anzahl_treffer" ];
|
|
$ergebnis_arr[ "angelegt_am" ] = $gespeicherte_recherche[ "angelegt_am" ];
|
|
$ergebnis_arr[ "rech_stil" ] = $gespeicherte_recherche[ "recherche_stil" ];
|
|
$ergebnis_arr[ "recherche_stil" ] = $gespeicherte_recherche[ "recherche_stil" ];
|
|
$ergebnis_arr[ "datum" ] = mysql2datum( $gespeicherte_recherche[ "datum" ] );
|
|
|
|
$e[] = $ergebnis_arr;
|
|
|
|
|
|
}
|
|
$rc = count( $e );
|
|
$meldung = "Liefere ".$rc." gespeicherte Recherchen für den Benutzer ".$benutzer_anmeldename.".";
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = $ergebnis[ 0 ];
|
|
$meldung = "Es ist ein Fehler aufgetreten: ".$ergebnis[ 1 ];
|
|
}
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = -9;
|
|
$meldung = "Die Parametrisierung ist nicht korrekt: mandant_name|benutzer_anmeldename => ".$mandant_name."|".$benutzer_anmeldename;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok[ 0 ];
|
|
$meldung = $ok[ 1 ];
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
|
|
|
|
xlog( $level, "__wfl.liefere_gespeicherte_recherchen_fuer_benutzer: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung, $e );
|
|
}
|
|
|
|
function liefere_verlauf_recherchen_fuer_benutzer_nach_datum( $mandant_name, $benutzer_anmeldename, $datum )
|
|
{
|
|
$ok = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok[ 0 ] > 0 )
|
|
{
|
|
if ( ( strlen( $benutzer_anmeldename ) > 0 ) && ( strlen( $datum ) > 0 ) )
|
|
{
|
|
|
|
|
|
$STATEMENT = "select crv.mandant_id, crv.id, crv.dokart_kuerzel, cd.dokart_name, crv.benutzer_anmeldename, crv.stichwoerter, crv.schablonenname, crv.sortierung, crv.anzahl_treffer, crv.recherche_stil, crv.angelegt_am, crv.datum from ca_rech_verlauf crv, ca_dokart cd where crv.mandant_id = ".$ok[ 0 ]." and cd.mandant_id = ".$ok[ 0 ]." and crv.dokart_kuerzel = cd.dokart_kuerzel and crv.benutzer_anmeldename = '".$benutzer_anmeldename."' and crv.schablonenname = '' and crv.datum = '".datum2mysql( $datum )."' order by crv.angelegt_am desc";
|
|
|
|
|
|
xlog( 6, $STATEMENT );
|
|
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] > 0 )
|
|
{
|
|
$e = array();
|
|
foreach( $ergebnis[ 1 ] as $gespeicherte_recherche )
|
|
{
|
|
$ergebnis_arr = array();
|
|
$ergebnis_arr[ "mandant_id" ] = $gespeicherte_recherche[ "mandant_id" ];
|
|
$ergebnis_arr[ "id" ] = $gespeicherte_recherche[ "id" ];
|
|
$ergebnis_arr[ "dokart_kuerzel" ] = $gespeicherte_recherche[ "dokart_kuerzel" ];
|
|
$ergebnis_arr[ "dokart_name" ] = $gespeicherte_recherche[ "dokart_name" ];
|
|
$ergebnis_arr[ "benutzer_anmeldename" ] = $gespeicherte_recherche[ "benutzer_anmeldename" ];
|
|
$ergebnis_arr[ "stichwoerter" ] = json_decode( $gespeicherte_recherche[ "stichwoerter" ], true );
|
|
$ergebnis_arr[ "schablonenname" ] = $gespeicherte_recherche[ "schablonenname" ];
|
|
$ergebnis_arr[ "name" ] = $gespeicherte_recherche[ "schablonenname" ];
|
|
$ergebnis_arr[ "sortierung" ] = json_decode( $gespeicherte_recherche[ "sortierung" ], true );
|
|
$ergebnis_arr[ "anzahl_treffer" ] = $gespeicherte_recherche[ "anzahl_treffer" ];
|
|
$ergebnis_arr[ "angelegt_am" ] = $gespeicherte_recherche[ "angelegt_am" ];
|
|
$ergebnis_arr[ "rech_stil" ] = $gespeicherte_recherche[ "recherche_stil" ];
|
|
$ergebnis_arr[ "recherche_stil" ] = $gespeicherte_recherche[ "recherche_stil" ];
|
|
$ergebnis_arr[ "datum" ] = mysql2datum( $gespeicherte_recherche[ "datum" ] );
|
|
|
|
$e[] = $ergebnis_arr;
|
|
|
|
|
|
}
|
|
$rc = count( $e );
|
|
$meldung = "Liefere ".$rc." Recherchen aus dem Verlauf des Benutzers ".$benutzer_anmeldename.".";
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = $ergebnis[ 0 ];
|
|
$meldung = "Es ist ein Fehler aufgetreten: ".$ergebnis[ 1 ];
|
|
}
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = -9;
|
|
$meldung = "Die Parametrisierung ist nicht korrekt: mandant_name|benutzer_anmeldename|datum => ".$mandant_name."|".$benutzer_anmeldename."|".$datum;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok[ 0 ];
|
|
$meldung = $ok[ 1 ];
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
|
|
|
|
xlog( $level, "__wfl.liefere_verlauf_recherchen_fuer_benutzer_nach_datum: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung, $e );
|
|
}
|
|
|
|
function loesche_gespeicherte_recherche( $mandant_name, $id )
|
|
{
|
|
$ok = existiert_mandant( $mandant_name );
|
|
|
|
if ( $ok[ 0 ] > 0 )
|
|
{
|
|
if ( strlen( $id ) > 0 )
|
|
{
|
|
$STATEMENT = "delete from ca_rech_verlauf where mandant_id = ".$ok[ 0 ]." and id = ".$id;
|
|
|
|
$ergebnis = xdb( $STATEMENT );
|
|
|
|
if ( $ergebnis[ 0 ] == 0 )
|
|
{
|
|
$rc = 0;
|
|
$meldung = "Die gespeicherte Recherche mit der ID ".$id." wurde gelöscht.";
|
|
}
|
|
else
|
|
{
|
|
$rc = -1;
|
|
$meldung = "Es ist ein Fehler aufgetreten: ".$ergebnis[ 1 ];
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
$rc = -9;
|
|
$meldung = "Die Parametrisierung ist nicht korrekt: id => ".$id;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$rc = $ok[ 0 ];
|
|
$meldung = $ok[ 1 ];
|
|
}
|
|
|
|
if ( $rc < 0 )
|
|
{
|
|
$level = 2;
|
|
}
|
|
else
|
|
{
|
|
$level = 4;
|
|
}
|
|
|
|
|
|
|
|
xlog( $level, "__wfl.loesche_gespeicherte_recherche: RC ".$rc.": ".$meldung );
|
|
return array( $rc, $meldung );
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function liefere_unterstuetzte_mime_types()
|
|
{
|
|
|
|
/*
|
|
Anhand des Dateinamens des Icons (insbesondere der drei Buchstaben nach dem "ico_") wird auf den Mime-Type rückgeschlossen. Die dürfen also nur bei gleichen Mime-Typen gleich sein
|
|
(z. B. bei "application/octetstream" und "application/octet-stream", die sich nur durch einen Bindestrich unterscheiden).
|
|
|
|
*/
|
|
|
|
|
|
$mime_types = array(
|
|
|
|
////////////////////////// PDF
|
|
array( "kuerzel"=>"pdf", "mime_type"=>"application/pdf", "icon"=>"img/ico_pdf.gif", "icon_gross"=>"img/ico_pdf_b.gif" ),
|
|
|
|
////////////////////////// Bilder
|
|
array( "kuerzel"=>"jpe", "mime_type"=>"image/jpeg", "icon"=>"img/ico_jpg.gif", "icon_gross"=>"img/ico_jpg_b.gif" ),
|
|
array( "kuerzel"=>"jpg", "mime_type"=>"image/jpg", "icon"=>"img/ico_jpg.gif", "icon_gross"=>"img/ico_jpg_b.gif" ),
|
|
array( "kuerzel"=>"png", "mime_type"=>"image/png", "icon"=>"img/ico_png.gif", "icon_gross"=>"img/ico_png_b.gif" ),
|
|
array( "kuerzel"=>"gif", "mime_type"=>"image/gif", "icon"=>"img/ico_gif.gif", "icon_gross"=>"img/ico_gif_b.gif" ),
|
|
|
|
////////////////////////// Office
|
|
array( "kuerzel"=>"wrd", "mime_type"=>"application/msword", "icon"=>"img/ico_wrd.gif", "icon_gross"=>"img/ico_wrd_b.gif" ),
|
|
array( "kuerzel"=>"xsl", "mime_type"=>"application/vnd.ms-e", "icon"=>"img/ico_xls.gif", "icon_gross"=>"img/ico_xls_b.gif" ),
|
|
array( "kuerzel"=>"rtf", "mime_type"=>"application/rtf", "icon"=>"img/ico_rtf.gif", "icon_gross"=>"img/ico_rtf_b.gif" ),
|
|
array( "kuerzel"=>"w09", "mime_type"=>"application/vnd.openxmlformats-officedocument.wordprocessingml.document", "icon"=>"img/ico_w09.gif", "icon_gross"=>"img/ico_w09_b.gif" ),
|
|
|
|
////////////////////////// Sonstiges
|
|
array( "kuerzel"=>"maf", "mime_type"=>"application/x-maff", "icon"=>"img/ico_maf.gif", "icon_gross"=>"img/ico_maf_b.gif" ),
|
|
array( "kuerzel"=>"app", "mime_type"=>"application/octetstream", "icon"=>"img/ico_app.gif", "icon_gross"=>"img/ico_app_b.gif" ),
|
|
array( "kuerzel"=>"app", "mime_type"=>"application/octet-stream", "icon"=>"img/ico_app.gif", "icon_gross"=>"img/ico_app_b.gif" ),
|
|
array( "kuerzel"=>"app", "mime_type"=>"application/octet-st", "icon"=>"img/ico_app.gif", "icon_gross"=>"img/ico_app_b.gif" ),
|
|
|
|
////////////////////////// Textformate / Akten
|
|
array( "kuerzel"=>"akt", "mime_type"=>"text/akte", "icon"=>"img/ico_akt.gif", "icon_gross"=>"img/ico_akt_b.gif" ),
|
|
array( "kuerzel"=>"txt", "mime_type"=>"text/plain", "icon"=>"img/ico_txt.gif", "icon_gross"=>"img/ico_txt_b.gif" ),
|
|
array( "kuerzel"=>"xml", "mime_type"=>"text/xml", "icon"=>"img/ico_xml.gif", "icon_gross"=>"img/ico_xml_b.gif" ),
|
|
array( "kuerzel"=>"htm", "mime_type"=>"text/html", "icon"=>"img/ico_htm.gif", "icon_gross"=>"img/ico_htm_b.gif" ),
|
|
|
|
////////////////////////// Video
|
|
array( "kuerzel"=>"vid", "mime_type"=>"video/mp4", "icon"=>"img/ico_vid.gif", "icon_gross"=>"img/ico_vid_b.gif" ),
|
|
|
|
|
|
|
|
|
|
|
|
);
|
|
|
|
|
|
return $mime_types;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
?>
|