2018-03-29 19:45:41 +02:00
package application ;
2018-03-29 19:51:34 +02:00
import java.sql.Connection ;
import java.sql.DriverManager ;
import java.sql.PreparedStatement ;
2018-03-29 19:45:41 +02:00
import java.sql.ResultSet ;
2018-03-29 19:51:34 +02:00
import java.sql.SQLException ;
2018-03-29 19:45:41 +02:00
import java.sql.Statement ;
import java.util.ArrayList ;
import java.io.File ;
import java.io.FileInputStream ;
2018-03-29 19:51:34 +02:00
class DBController
{
private Connection connection ;
2018-03-29 19:45:41 +02:00
private String DB_PATH_Win = " C:/ProgramData/PWMaster/datenbank.db " ;
2018-03-29 19:51:34 +02:00
private String DB_PATH_Linux = System . getProperty ( " user.home " )
+ " /bin/PWMaster/datenbank.db " ;
2018-03-29 19:45:41 +02:00
private Main main ;
2018-03-29 19:51:34 +02:00
// private Cryption crypo = new Cryption();
private String schluessel ; // Für Ver-/Entschlüsselung
public void main ( )
{
2018-03-29 19:45:41 +02:00
try {
2018-03-29 19:51:34 +02:00
if ( System . getProperty ( " os.name " ) . equals ( " Linux " ) ) {
connection = DriverManager
. getConnection ( " jdbc:sqlite: " + DB_PATH_Linux ) ;
2018-03-29 19:45:41 +02:00
} else {
2018-03-29 19:51:34 +02:00
connection = DriverManager
. getConnection ( " jdbc:sqlite: " + DB_PATH_Win ) ;
2018-03-29 19:45:41 +02:00
}
} catch ( SQLException e ) {
// TODO Auto-generated catch block
e . printStackTrace ( ) ;
}
2018-03-29 19:51:34 +02:00
}
DBController ( Main main )
{
2018-03-29 19:45:41 +02:00
this . main = main ;
2018-03-29 19:51:34 +02:00
}
public void verbindeDatenbank ( )
{ // Verbinde mit der Datenbank-Datei
try {
if ( connection ! = null )
return ;
if ( System . getProperty ( " os.name " ) . equals ( " Linux " ) ) {
connection = DriverManager
. getConnection ( " jdbc:sqlite: " + DB_PATH_Linux ) ;
2018-03-29 19:45:41 +02:00
} else {
2018-03-29 19:51:34 +02:00
connection = DriverManager
. getConnection ( " jdbc:sqlite: " + DB_PATH_Win ) ;
2018-03-29 19:45:41 +02:00
}
2018-03-29 19:51:34 +02:00
if ( ! connection . isClosed ( ) )
System . out . println ( ) ;
} catch ( SQLException e ) {
throw new RuntimeException ( e ) ;
}
Runtime . getRuntime ( ) . addShutdownHook ( new Thread ( ) {
public void run ( )
{
try {
if ( ! connection . isClosed ( ) & & connection ! = null ) {
connection . close ( ) ;
if ( connection . isClosed ( ) )
System . out . println ( ) ;
}
} catch ( SQLException e ) {
e . printStackTrace ( ) ;
}
}
} ) ;
}
public void fuellenDatenbank ( int pID , String pDatum , String pKonto ,
String pNutzername , String pEmail , String pPasswort )
{ // Neuen Eintrag erstellen
try {
PreparedStatement ps = connection . prepareStatement (
" INSERT INTO konten VALUES (?, ?, ?, ?, ?, ?); " ) ;
ps . setInt ( 1 , pID ) ; // Primärschlässel
2018-03-29 19:45:41 +02:00
ps . setString ( 2 , pDatum ) ;
ps . setString ( 3 , pKonto ) ;
ps . setString ( 4 , pNutzername ) ;
ps . setString ( 5 , pEmail ) ;
ps . setString ( 6 , pPasswort ) ;
ps . addBatch ( ) ;
2018-03-29 19:51:34 +02:00
connection . setAutoCommit ( false ) ;
ps . executeBatch ( ) ; // SQL ausführen
connection . setAutoCommit ( true ) ;
// connection.close();
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
}
2018-03-29 19:45:41 +02:00
}
2018-03-29 19:51:34 +02:00
public void erstelleDatenbank ( )
{ // Erstelle Tabelle mit Reihen
try {
Statement stmt = connection . createStatement ( ) ;
stmt . executeUpdate ( " DROP TABLE IF EXISTS konten; " ) ;
stmt . executeUpdate (
" CREATE TABLE konten (id, datum, konto, nutzername, email, passwort); " ) ;
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
}
2018-03-29 19:45:41 +02:00
}
2018-03-29 19:51:34 +02:00
public boolean existiertDatenbank ( String pPfad )
{ // Prüft ob die Datenbank existiert
2018-03-29 19:45:41 +02:00
File varTmpDir = new File ( pPfad ) ;
2018-03-29 19:51:34 +02:00
if ( ! varTmpDir . exists ( ) ) {
2018-03-29 19:45:41 +02:00
return false ;
2018-03-29 19:51:34 +02:00
} else {
2018-03-29 19:45:41 +02:00
return true ;
}
}
2018-03-29 19:51:34 +02:00
private void ausgebenSyso ( )
{ // Debugging Ausgabe der kompletten Datenbank
try {
Statement stmt = connection . createStatement ( ) ;
ResultSet rs = stmt . executeQuery ( " SELECT * FROM konten; " ) ;
while ( rs . next ( ) ) {
System . out . println ( " Datum = " + rs . getString ( " datum " ) ) ;
System . out . println ( " Konto = " + rs . getString ( " konto " ) ) ;
System . out . println ( " Nutzername = " + rs . getString ( " nutzername " ) ) ;
System . out . println ( " E-Mail = " + rs . getString ( " email " ) ) ;
System . out . println ( " Passwort = " + rs . getString ( " passwort " ) ) ;
2018-03-29 19:45:41 +02:00
System . out . println ( " " ) ;
2018-03-29 19:51:34 +02:00
}
2018-03-29 19:45:41 +02:00
2018-03-29 19:51:34 +02:00
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
}
2018-03-29 19:45:41 +02:00
}
2018-03-29 19:51:34 +02:00
public String getDatum ( int pID )
{ // Gibt das Datum zurück
try {
Statement stmt = connection . createStatement ( ) ;
ResultSet rs = stmt . executeQuery (
" SELECT id, datum FROM konten WHERE id = " + pID + " ; " ) ;
return rs . getString ( " datum " ) ;
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
2018-03-29 19:45:41 +02:00
return " Error 404 " ;
2018-03-29 19:51:34 +02:00
}
2018-03-29 19:45:41 +02:00
}
2018-03-29 19:51:34 +02:00
public String getKonto ( int pID )
{ // Gibt das Konto zurück
try {
Statement stmt = connection . createStatement ( ) ;
ResultSet rs = stmt . executeQuery (
" SELECT id, konto FROM konten WHERE id = " + pID + " ; " ) ;
return rs . getString ( " konto " ) ;
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
2018-03-29 19:45:41 +02:00
return " Error 404 " ;
2018-03-29 19:51:34 +02:00
}
2018-03-29 19:45:41 +02:00
}
2018-03-29 19:51:34 +02:00
public String getNutzername ( int pID )
{ // Gibt den Nutzernamen zurück
try {
Statement stmt = connection . createStatement ( ) ;
ResultSet rs = stmt . executeQuery (
" SELECT id, nutzername FROM konten WHERE id = " + pID + " ; " ) ;
return rs . getString ( " nutzername " ) ;
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
2018-03-29 19:45:41 +02:00
return " Error 404 " ;
2018-03-29 19:51:34 +02:00
}
2018-03-29 19:45:41 +02:00
}
2018-03-29 19:51:34 +02:00
public String getEmail ( int pID )
{ // Gibt die Email zurück
try {
Statement stmt = connection . createStatement ( ) ;
ResultSet rs = stmt . executeQuery (
" SELECT id, email FROM konten WHERE id = " + pID + " ; " ) ;
return rs . getString ( " email " ) ;
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
2018-03-29 19:45:41 +02:00
return " Error 404 " ;
2018-03-29 19:51:34 +02:00
}
2018-03-29 19:45:41 +02:00
}
2018-03-29 19:51:34 +02:00
public String getPasswort ( int pID )
{ // Gibt das Passwort zurück
try {
Statement stmt = connection . createStatement ( ) ;
ResultSet rs = stmt . executeQuery (
" SELECT id, passwort FROM konten WHERE id = " + pID + " ; " ) ;
return rs . getString ( " passwort " ) ;
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
2018-03-29 19:45:41 +02:00
return " Error 404 " ;
2018-03-29 19:51:34 +02:00
}
2018-03-29 19:45:41 +02:00
}
2018-03-29 19:51:34 +02:00
public void setDatum ( int pID , String pDatum )
{ // Setzt das Datum
try {
Statement stmt = connection . createStatement ( ) ;
stmt . executeUpdate ( " UPDATE konten SET datum = ' " + pDatum
+ " 'WHERE id = " + pID + " ; " ) ;
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
}
2018-03-29 19:45:41 +02:00
}
2018-03-29 19:51:34 +02:00
public void setKonto ( int pID , String pKonto )
{ // Setzt das Konto
try {
Statement stmt = connection . createStatement ( ) ;
stmt . executeUpdate ( " UPDATE konten SET konto = ' " + pKonto
+ " 'WHERE id = " + pID + " ; " ) ;
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
}
2018-03-29 19:45:41 +02:00
}
2018-03-29 19:51:34 +02:00
public void setNutername ( int pID , String pNutername )
{ // Setzt den Nutzername
try {
Statement stmt = connection . createStatement ( ) ;
stmt . executeUpdate ( " UPDATE konten SET nutzername = ' " + pNutername
+ " 'WHERE id = " + pID + " ; " ) ;
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
}
2018-03-29 19:45:41 +02:00
}
2018-03-29 19:51:34 +02:00
public void setEmail ( int pID , String pEmail )
{ // Setzt die Email
try {
Statement stmt = connection . createStatement ( ) ;
stmt . executeUpdate ( " UPDATE konten SET email = ' " + pEmail
+ " 'WHERE id = " + pID + " ; " ) ;
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
}
2018-03-29 19:45:41 +02:00
}
2018-03-29 19:51:34 +02:00
public void setPasswort ( int pID , String pPasswort )
{ // Setzt das Passwort
try {
Statement stmt = connection . createStatement ( ) ;
stmt . executeUpdate ( " UPDATE konten SET passwort = ' " + pPasswort
+ " 'WHERE id = " + pID + " ; " ) ;
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
}
2018-03-29 19:45:41 +02:00
}
2018-03-29 19:51:34 +02:00
public void loeschenEintrag ( int pID )
{ // Löscht den Eintrag
int alteOrdnung = getNeueID ( ) ; // Speichert die ID des letzten Eintrags
2018-03-29 19:45:41 +02:00
try {
2018-03-29 19:51:34 +02:00
if ( pID = = getNeueID ( ) - 1 ) { // Falls letzter Eintrag gelöscht werden
// soll
PreparedStatement ps = connection
. prepareStatement ( " DELETE FROM konten WHERE id=? " ) ;
2018-03-29 19:45:41 +02:00
ps . setInt ( 1 , pID ) ;
ps . executeUpdate ( ) ;
2018-03-29 19:51:34 +02:00
} else { // Wenn ein Eintrag in mitten der DB gelöscht wird, dann wird
// hochkopiert
while ( ! ( pID + 1 = = alteOrdnung - 1 ) ) {
2018-03-29 19:45:41 +02:00
int pIDneu = pID + 1 ;
2018-03-29 19:51:34 +02:00
Statement stmt = connection . createStatement ( ) ;
ResultSet rs = stmt . executeQuery (
" SELECT id, datum, konto, nutzername, email, passwort FROM konten WHERE id = "
+ pIDneu + " ; " ) ;
2018-03-29 19:45:41 +02:00
String pDatum = rs . getString ( " datum " ) ;
String pKonto = rs . getString ( " konto " ) ;
String pNutzername = rs . getString ( " nutzername " ) ;
2018-03-29 19:51:34 +02:00
String pEmail = rs . getString ( " email " ) ;
String pPasswort = rs . getString ( " passwort " ) ;
2018-03-29 19:45:41 +02:00
2018-03-29 19:51:34 +02:00
stmt . executeUpdate ( " UPDATE konten SET datum = ' " + pDatum
+ " ', konto = ' " + pKonto + " ', nutzername = ' "
+ pNutzername + " ', email = ' " + pEmail + " ', passwort = ' "
+ pPasswort + " 'WHERE id = " + pID + " ; " ) ;
2018-03-29 19:45:41 +02:00
pID = pID + 1 ;
}
2018-03-29 19:51:34 +02:00
PreparedStatement ps = connection
. prepareStatement ( " DELETE FROM konten WHERE id=? " ) ;
ps . setInt ( 1 , alteOrdnung - 1 ) ;
2018-03-29 19:45:41 +02:00
ps . executeUpdate ( ) ;
}
2018-03-29 19:51:34 +02:00
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
}
2018-03-29 19:45:41 +02:00
}
2018-03-29 19:51:34 +02:00
public int getNeueID ( )
{ // Gibt die ID des nächsten Eintrags zurück
2018-03-29 19:45:41 +02:00
int neueID = 0 ;
2018-03-29 19:51:34 +02:00
try {
Statement stmt = connection . createStatement ( ) ;
ResultSet rs = stmt . executeQuery ( " SELECT * FROM konten; " ) ;
while ( rs . next ( ) ) {
2018-03-29 19:45:41 +02:00
neueID = rs . getInt ( " id " ) + 1 ;
2018-03-29 19:51:34 +02:00
}
rs . close ( ) ;
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
}
return neueID ;
2018-03-29 19:45:41 +02:00
}
2018-03-29 19:51:34 +02:00
public ArrayList < tableData > ladeTabelle ( )
{ // Gibt ein Objekt daten mit allen Einträgen der DB zurück
2018-03-29 19:45:41 +02:00
ArrayList < tableData > daten = new ArrayList < > ( ) ;
2018-03-29 19:51:34 +02:00
try {
Statement stmt = connection . createStatement ( ) ;
ResultSet rs = stmt . executeQuery ( " SELECT * FROM konten; " ) ;
2018-03-29 19:45:41 +02:00
while ( rs . next ( ) ) {
try {
// Entschlüsselte Daten werden als Datenobjekt gespeichert
2018-03-29 19:51:34 +02:00
// daten.add(new tableData(rs.getInt("id"),
// crypo.entschluesseln(rs.getString("datum"), schluessel),
// crypo.entschluesseln(rs.getString("konto"),schluessel)));
2018-03-29 19:45:41 +02:00
} catch ( Exception e ) {
// TODO Auto-generated catch block
e . printStackTrace ( ) ;
}
2018-03-29 19:51:34 +02:00
}
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
}
2018-03-29 19:45:41 +02:00
return daten ;
}
2018-03-29 19:51:34 +02:00
public void setSchluessel ( String pSchluessel )
{ // Setzt den Schlüssel für die Ver-/Entschlüsslung
2018-03-29 19:45:41 +02:00
schluessel = pSchluessel ;
}
}