def DatenbankCheck(usDB1, usDB2):
    """
    die Funktion DatenbankCheck
        - Alle Datensätze aus Temp die in Ziel Vorkommen in Temp löschen.
          wobei db1 die ZielDB ist
          und   db2 die TempDB
          
        ich überleg noch ob ich die funktion andersrum auch mal brauchen kann ... ;)
    """    
    print('-------- DatenbankCheck -------------------------------------------------------------------')
    print("Beginn: ", str(strftime("%Y.%m.%d.%H.%M.%S" , time.localtime(time.time()))))

    #db ermitteln und füllen
    MeinePfade = Class_lese_Config.Pfade()
    
    sQuellPfad = MeinePfade.quellpfad
    sZielpfad = MeinePfade.zielpfad
    sPfadZielDB = MeinePfade.zieldb
    sPfadTempDB = MeinePfade.tempdb

    #if usQuelle_Verzeichnis == "quell":
    sDB1 = sPfadZielDB
    #elif usQuelle_Verzeichnis == "ziel":
    sDB2 = sPfadTempDB

    print('funktion:    DatenbankCheck --> daten: sQuellPfad: ', sQuellPfad)
    print('funktion:    DatenbankCheck --> daten: sZielpfad: ', sZielpfad)
    print('funktion:    DatenbankCheck --> daten: sDB1: ', sDB1)    
    print('funktion:    DatenbankCheck --> daten: sDB2: ', sDB2)

    ZaehlerGesamtanzahl = 0
    ZaehlerGeloescht = 0
    ZaehlerBereitsVorhanden = 0
    ZaehlerDateiOhneSuchstring = 0
    b=1000

    #else:
    #baustelle: test ob vorhanden und dann komplett raus?
    #sQuelle_Verzeichnis = usQuelle_Verzeichnis
    ## datenbanken zuordnern und verbinden
    
    conDB1 = sqlite3.connect(sDB1)
    db1Cursor = conDB1.cursor()
    conDB2 = sqlite3.connect(sDB2)
    db2Cursor = conDB2.cursor()
        

    # Beispiel für eine Endlosschleife:
    y = 1
    x = 0

    while y != 0:
        #    print(x)
        #    x += 1
        y = 0
        #findet alle:

        db2Cursor.execute("SELECT * FROM `Dateien`")        #Temp
       
        for datensatzTemp in db2Cursor:
            sIDTemp = datensatzTemp[0]
            sPfadTemp = datensatzTemp[1]
            sPruefsummeTemp = datensatzTemp[3]
            #print ("++++" , sIDTemp , "++++" , sPfadTemp , "++++" , sPruefsummeTemp , "++++")
            ZaehlerGesamtanzahl+=1

            #dbCursorZiel = conZiel.cursor()
            #db1Cursor.execute("SELECT * FROM `Dateien` WHERE `Pruefsumme` LIKE '" + sPruefsummeTemp + "'")  #"721482FF72B6F6642F6713CF01DB6BFC'")


            bMerker = False
            if mod_check_Datei_In_ZielDB_Vorhanden.checkDateiInZielDBVorhanden(sPruefsummeTemp) == None:
                bMerker = True
                #print('in mod_check_Datei_In_ZielDB_Vorhanden')


            #for datensatzZiel in db1Cursor:
                #return(datensatz)

            if bMerker == True:
                #x+=1
                ZaehlerBereitsVorhanden+=1
                #Zähler einbauen und alle 20 dateien eine meldung abgeben, dass es noch läuft wie es soll ...
                if (ZaehlerBereitsVorhanden % b)== 0 :
                    print('es wurden  ', ZaehlerBereitsVorhanden ,'  Datensätze verarbeitet')

                
            else:
                #sIDZiel = datensatzZiel[0]
                #sPfadZiel = datensatzZiel[1]
                #sPruefsummeZiel = datensatzZiel[3]
                
                ZaehlerGeloescht+=1

                #print ("++++")
                #print("DELETE FROM `Dateien` WHERE `ID` = '" + str(sIDTemp) + "'")
                sSQLAnweisung = "DELETE FROM `Dateien` WHERE `ID` = '" + str(sIDTemp) + "'"
                db2Cursor.execute(sSQLAnweisung)
                conDB2.commit()
                y = 1


    
    print('\n ZaehlerGesamtanzahl ' , ZaehlerGesamtanzahl , '\n ZaehlerBereitsVorhanden ' , ZaehlerBereitsVorhanden , '\n ZaehlerGeloescht ' , ZaehlerGeloescht , '\n ZaehlerDateiOhneSuchstring ' , ZaehlerDateiOhneSuchstring)
    print("Beginn: ", str(strftime("%Y.%m.%d.%H.%M.%S" , time.localtime(time.time()))))
    print('-------- ende DatenbankCheck --------------------------------------------------------------')
コード例 #2
0
def DatenbankFuellen(usQuelle_Verzeichnis, usQuelle_Datenbank):
    """
    die Funktion DatenbankVerifizieren
        - kontrolliert alle datensätze ob eine entsprechende datei da ist - wenn nein - datensatz löschen!

    Übergabe: quelle_Dateien, quelle_Verzeichnis, quelle_Datenbank
    Rückgabe: -- möglicherweise mal ein ok ;)
                - später auf jeden fall mal ein logfile
    """    
    print('-------- DatenbankFuellen -------------------------------------------------------------------')

    #db ermitteln und füllen
    MeinePfade = Class_lese_Config.Pfade()
    
    sQuellPfad = MeinePfade.quellpfad
    sZielpfad = MeinePfade.zielpfad
    sPfadZielDB = MeinePfade.zieldb
    sPfadTempDB = MeinePfade.tempdb

    if usQuelle_Verzeichnis == "quell":
        sQuelle_Verzeichnis = MeinePfade.quellpfad
    elif usQuelle_Verzeichnis == "ziel":
        sQuelle_Verzeichnis = MeinePfade.zielpfad
    else:
        #baustelle: test ob vorhanden und dann komplett raus?
        sQuelle_Verzeichnis = usQuelle_Verzeichnis

    if usQuelle_Datenbank == "temp":
        conDB = sqlite3.connect(sPfadTempDB)
        dbCursor = conDB.cursor()
    elif usQuelle_Datenbank == "ziel":
        conDB = sqlite3.connect(sPfadZielDB)
        dbCursor = conDB.cursor()
    #else:
        #baustelle: test ob vorhanden und dann komplett raus?        
    #    pass

    print('funktion:    DatenbankFuellen --> daten: usQuelle_Verzeichnis: ', usQuelle_Verzeichnis)
    print('funktion:    DatenbankFuellen --> daten: sQuelle_Verzeichnis: ', sQuelle_Verzeichnis)    
    print('funktion:    DatenbankFuellen --> daten: usQuelle_Datenbank: ', usQuelle_Datenbank)
    print('\n')

    ZaehlerGesamtanzahl =0
    ZaehlerEingepflegt  =0
    ZaehlerBereitsVorhanden  =0
    ZaehlerDateiOhneSuchstring=0
    
    #print('funktion:    DatenbankFuellen --> daten: usQuelle_Datenbank: ', usQuelle_Datenbank)   
    # daten holen
    # dbCursor.execute("SELECT * FROM `Dateien`")
   
    for root, dirs, files in os.walk(sQuelle_Verzeichnis, topdown=False):
        for name in files:
            #print('---------------------------------------------------------------------------')
            sDateinameUndPfad = os.path.join(root, name)
            sDateiname = (os.path.join(name))
            sPruefsumme = scan(sDateinameUndPfad)

            ZaehlerGesamtanzahl += 1
            #print('funktion:    DatenbankFuellen -->\n      sDateinameUndPfad  :' + sDateinameUndPfad + '\n      und sDateiname  :' + sDateiname + '\n      und sPrüfsumme: ' + sPruefsumme)

            #Hier werden die suchstrings definidert .... sollte noch was nötig sein ...
            sSuchString = (".jp", ".avi",  ".mp", ".png", ".JP", ".AVI",  ".MP", ".PNG")
            bVorhandenTrue = False

            for sSuchstrings in sSuchString:
                if sDateiname.find(sSuchstrings) != -1:
                    bVorhandenTrue = True

            if bVorhandenTrue == True:
                    
                #print('!!funktion:    DatenbankFuellen --> daten: sDateinameUndPfad',sDateinameUndPfad)
                sDatenUndGroessen = mod_Daten_zurueck_Geben.DatenzurueckGeben(sDateinameUndPfad)
                #print('!!funktion:    DatenbankFuellen --> daten: sDatenUndGroessen',sDatenUndGroessen)
                
                #print('sDateinameUndPfad  :' + sDateinameUndPfad + '      und sDateiname  :' + sDateiname + '      und sPrüfsumme: ' + sPruefsumme)


                bMerker = False
                if usQuelle_Verzeichnis == "ziel":
                    if mod_check_Datei_In_ZielDB_Vorhanden.checkDateiInZielDBVorhanden(sPruefsumme) == None:
                        bMerker = True
                        #print('in mod_check_Datei_In_ZielDB_Vorhanden')
                else:
                    if mod_check_Datei_In_TempDB_Vorhanden.checkDateiInTempDBVorhanden(sPruefsumme) == None:
                        bMerker = True
                        #print('in mod_check_Datei_In_TempDB_Vorhanden')

                if bMerker == True:
                    sql = "INSERT INTO `Dateien` (`UNCPfad`, `Dateiname`, `Pruefsumme`, `DateinameNeu` ) VALUES (" \
                      "'" + sDateinameUndPfad + "', " \
                      "'" + sDateiname + "', " \
                      "'" + sPruefsumme + "', " \
                      "'" + sDatenUndGroessen + "')"
                    
                    #print(sDatenUndGroessen)
                    #print('funktion:    TempDBfuellen --> daten: sql', sql)

                    dbCursor.execute(sql)
                    conDB.commit()
                    #print('wurde unter dieser ID ' + str(dbCursor.lastrowid) + ' in die DB ' + usQuelle_Datenbank + ' aufgenommen eingepflegt')                               # gibt die ID des letzten Eintrags zurück
                    ZaehlerEingepflegt+=1

                else:
                    ZaehlerBereitsVorhanden+=1
                    #print('datei is scho da')
                    #Baustelle - Logging:
                    # hier wäre ein log nicht schlecht, nur dass man weiß, wieviele dateien im quellordner dubletten sind.

            else:
                ZaehlerDateiOhneSuchstring+=1
                #print("suchstring nicht vorhanden")

    print('\n ZaehlerGesamtanzahl ' , ZaehlerGesamtanzahl , '\n ZaehlerEingepflegt ' , ZaehlerEingepflegt , '\n ZaehlerBereitsVorhanden ' , ZaehlerBereitsVorhanden , '\n ZaehlerDateiOhneSuchstring ' , ZaehlerDateiOhneSuchstring)
    print('-------- ende DatenbankFuellen --------------------------------------------------------------')
コード例 #3
0
def DatenbankCheck(usDB1, usDB2):
    """
    die Funktion DatenbankCheck
        - Alle Datensätze aus Temp die in Ziel Vorkommen in Temp löschen.
          wobei db1 die ZielDB ist
          und   db2 die TempDB
          
    """    
    print('-------- DatenbankCheck -------------------------------------------------------------------')
    print("Beginn: ", str(strftime("%Y.%m.%d.%H.%M.%S" , time.localtime(time.time()))))

    #db ermitteln und füllen
    MeinePfade = Class_lese_Config.Pfade()
    
    sQuellPfad = MeinePfade.quellpfad
    sZielpfad = MeinePfade.zielpfad
    sPfadZielDB = MeinePfade.zieldb
    sPfadTempDB = MeinePfade.tempdb

    #if usQuelle_Verzeichnis == "quell":
    sDB1 = sPfadZielDB
    #elif usQuelle_Verzeichnis == "ziel":
    sDB2 = sPfadTempDB

    print('funktion:    DatenbankCheck --> daten: sQuellPfad: ', sQuellPfad)
    print('funktion:    DatenbankCheck --> daten: sZielpfad: ', sZielpfad)
    print('funktion:    DatenbankCheck --> daten: sDB1: ', sDB1)    
    print('funktion:    DatenbankCheck --> daten: sDB2: ', sDB2)

    ZaehlerGesamtanzahl = 0
    ZaehlerGeloescht = 0
    ZaehlerBereitsVorhanden = 0
    ZaehlerDateiOhneSuchstring = 0
    b=500
    ZuLoeschendeIDs = [""]

    #else:
    #baustelle: test ob vorhanden und dann komplett raus?
    #sQuelle_Verzeichnis = usQuelle_Verzeichnis
    ## datenbanken zuordnern und verbinden
    
    conDB1 = sqlite3.connect(sDB1)
    db1Cursor = conDB1.cursor()
    conDB2 = sqlite3.connect(sDB2)
    db2Cursor = conDB2.cursor()
        

    # Beispiel für eine Endlosschleife:
    y = 1
    x = 0

    db2Cursor.execute("SELECT * FROM `Dateien`")        #Temp

#datem aus temp in ziel suchen und markieren
    for datensatzTemp in db2Cursor:
        ZaehlerGesamtanzahl+=1

        sIDTemp = datensatzTemp[0]
        sPfadTemp = datensatzTemp[1]
        sPruefsummeTemp = datensatzTemp[3]
        #print ("++++" , sIDTemp , "++++" , sPfadTemp , "++++" , sPruefsummeTemp , "++++")

        bMerker = False
        if mod_check_Datei_In_ZielDB_Vorhanden.checkDateiInZielDBVorhanden(sPruefsummeTemp) == None:
            bMerker = True

        if bMerker == True:
            ZaehlerBereitsVorhanden+=1
##            #Zähler einbauen und alle 'b' dateien eine meldung abgeben, dass es noch läuft wie es soll ...
##            if (ZaehlerBereitsVorhanden % b)== 0 :
##                print('es wurden  ', ZaehlerBereitsVorhanden ,'  Datensätze verarbeitet')
            
        else:
            y = 1
            ZuLoeschendeIDs += [sIDTemp] 
            ZaehlerGeloescht+=1

#daten aus temp löschen:

    for ZuLoeschendeID in ZuLoeschendeIDs:
##        print ("++++")
##        print(ZuLoeschendeID)
##        print("DELETE FROM `Dateien` WHERE `ID` = '" + str(ZuLoeschendeID) + "'")
        sSQLAnweisung = "DELETE FROM `Dateien` WHERE `ID` = '" + str(ZuLoeschendeID) + "'"
        db2Cursor.execute(sSQLAnweisung)
        conDB2.commit()

    
    print('\n ZaehlerGesamtanzahl ' , ZaehlerGesamtanzahl , '\n ZaehlerBereitsVorhanden ' , ZaehlerBereitsVorhanden , '\n ZaehlerGeloescht ' , ZaehlerGeloescht , '\n ZaehlerDateiOhneSuchstring ' , ZaehlerDateiOhneSuchstring)
    print("Beginn: ", str(strftime("%Y.%m.%d.%H.%M.%S" , time.localtime(time.time()))))
    print('-------- ende DatenbankCheck --------------------------------------------------------------')
コード例 #4
0
def BilderBearbeiten():
    """
    die Funktion BilderBearbeiten
        - arbeitet alle datensätze der temp datei ab,
        - je datensatz schaut es in die zieldb und sieht nach, ob der datensatz schon vorhanden ist
        - wenn nein wird die datei nach folgenden maßgaben
            - ordner mit bilddatumjahr.bilddatummonat wird erstellt
            - bild wird als '2012.07.04.10.34.09.jpg' dort abgespeichert
        - nocht nicht implementiert: bild wird in ordner: aufsHaendy\bilddatumjahr.bilddatummonat kopiert
    Übergabe: usTempDB
    Rückgabe: --
    """
    print(
        '------------- BilderBearbeiten --------------------------------------------------------------'
    )

    MeinePfade = Class_lese_Config.Pfade()
    conTemp = sqlite3.connect(MeinePfade.tempdb)
    dbCursorTemp = conTemp.cursor()
    dbCursorTemp.execute("SELECT * FROM `Dateien`"
                         )  #Findet nimmt alle daten aus der datenbank Temp

    for datensatz in dbCursorTemp:  #und arbeitet sie ab
        #print(datensatz[4])                                         #gibt die Prüfsumme aus
        print(
            'funktion:    BilderBearbeiten --> daten: datensatz[3](Prüfsumme): ',
            datensatz[3])

        #Übergibt die prüfsumme an PruefsummeInZielVorhanden bekommt ID zurück
        sPruefsumme = datensatz[3]
        sID = mod_check_Datei_In_ZielDB_Vorhanden.checkDateiInZielDBVorhanden(
            sPruefsumme)

        if mod_check_Datei_In_ZielDB_Vorhanden.checkDateiInZielDBVorhanden(
                sPruefsumme) != None:

            #Datei bereits vorhanden.
            print("Datei vorhanden")  #    + str(sID))
            print('funktion:    BilderBearbeiten --> daten: datensatz: ',
                  datensatz)

        else:

            ##          hier müssen die entspechenden daten kopiert werden
            print("Datei nicht vorhanden")
            print('funktion:    BilderBearbeiten --> daten: datensatz: ',
                  datensatz)

            ##              prüfen ob ordner in zielstruktur vorhanden?                       - läuft
            sPfad = MeinePfade.zielpfad + (datensatz[4][:7])

            if os.path.exists(sPfad) == True:
                print(sPfad, "existiert.")
            else:
                print(sPfad, "existiert nicht.")
                os.mkdir(sPfad)

##            datei umbenennen und kopieren
            sQuellPfadUndDatei = datensatz[1]

            ##          hier die letzten 4 ziffern der prüfsumme in variable schreiben:
            #print(a[-5:])
            sPruefziffenteil = sPruefsumme[-2:]

            sZielPfadUndDatei = sPfad + '\\' + datensatz[
                4] + sPruefziffenteil + (
                    "." + datensatz[2][len(datensatz[2]) - 4:]).replace(
                        "..", ".")

            ##            print('sQuellPfadUndDatei ' + sQuellPfadUndDatei)
            print(
                'funktion:    BilderBearbeiten --> daten: sQuellPfadUndDatei: ',
                sQuellPfadUndDatei)
            # bedeutet: punkt und die letzten 4 des dateinamens, replaced werden 2 gegen einen punkt
            #print(("." + datensatz[2] [len(datensatz[2])-4:]).replace("..","."))
            ##            print('sZielPfadUndDatei ' + sZielPfadUndDatei)
            print(
                'funktion:    BilderBearbeiten --> daten: sZielPfadUndDatei: ',
                sZielPfadUndDatei)

            try:
                shutil.copy2(sQuellPfadUndDatei, sZielPfadUndDatei)

            except (FileNotFoundError):
                pass

##            datei schrumpfen

    print(
        '-------- ende BilderBearbeiten --------------------------------------------------------------'
    )