2018-12-03 21:12:00 +01:00
package com.jFxKasse.controller ;
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 ;
2018-12-03 20:27:55 +01:00
2018-12-03 21:12:00 +01:00
import com.jFxKasse.application.Main ;
import com.jFxKasse.datatypes.tableDataJob ;
import com.jFxKasse.datatypes.tableDataPositionen ;
2018-12-03 20:27:55 +01:00
2018-03-29 19:45:41 +02:00
import java.io.File ;
2018-12-03 20:27:55 +01:00
public class DBController
2018-03-29 19:51:34 +02:00
{
private Connection connection ;
2018-03-29 19:45:41 +02:00
2018-03-29 19:51:34 +02:00
private String DB_PATH_Linux = System . getProperty ( " user.home " )
2018-03-31 23:50:17 +02:00
+ " /bin/jFxKasse/ " ;
2018-03-29 19:51:34 +02:00
2018-12-05 22:44:15 +01:00
private String dbname ;
2018-03-29 19:51:34 +02:00
2018-04-05 12:25:29 +02:00
@SuppressWarnings ( " unused " )
2018-04-02 20:31:47 +02:00
private Main main ;
2018-03-29 19:51:34 +02:00
public void main ( )
{
2018-03-29 19:45:41 +02:00
try {
2018-04-02 20:31:47 +02:00
connection = DriverManager
. getConnection ( " jdbc:sqlite: " + DB_PATH_Linux + dbname + " .db " ) ;
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
}
2018-12-03 20:27:55 +01:00
public DBController ( Main main )
2018-03-29 19:51:34 +02:00
{
2018-03-29 19:45:41 +02:00
this . main = main ;
2018-03-29 19:51:34 +02:00
}
2018-12-05 22:44:15 +01:00
public void setDbname ( String dbname )
{
this . dbname = dbname ;
}
2018-03-29 19:51:34 +02:00
2018-04-02 20:31:47 +02:00
public void connectDatabase ( )
{ // connect to database
2018-03-31 23:50:17 +02:00
System . out . println ( " Verbinde ... DB name: " + dbname ) ;
2018-03-29 19:51:34 +02:00
try {
if ( connection ! = null )
return ;
2018-04-02 20:31:47 +02:00
connection = DriverManager
. getConnection ( " jdbc:sqlite: " + DB_PATH_Linux + dbname + " .db " ) ;
2018-03-29 19:51:34 +02:00
if ( ! connection . isClosed ( ) )
2018-03-31 23:50:17 +02:00
System . out . println ( " DB Datei-Verbindung erstellt " ) ;
2018-03-29 19:51:34 +02:00
} 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 ( ) ;
}
}
} ) ;
}
2018-04-02 20:31:47 +02:00
public boolean existiertDatenbank ( String pPfad )
{ // Prüft ob die Datenbank existiert
File varTmpDir = new File ( pPfad ) ;
if ( ! varTmpDir . exists ( ) ) {
return false ;
} else {
return true ;
2018-03-29 19:51:34 +02:00
}
2018-03-29 19:45:41 +02:00
}
2018-10-05 13:01:42 +02:00
2018-10-01 11:31:05 +02:00
public String getCategoryNameFromPositionen ( int pID )
{
2018-10-03 21:53:26 +02:00
// System.out.println("getCategoryName: " + pID);
int catInPos = 0 ;
2018-10-01 11:31:05 +02:00
try {
Statement stmt = connection . createStatement ( ) ;
2018-10-03 21:53:26 +02:00
ResultSet rs = stmt . executeQuery ( " SELECT posid, cat FROM positionen "
+ " WHERE posid = " + pID + " ; " ) ;
catInPos = rs . getInt ( " cat " ) ;
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
}
if ( catInPos = = 6 ) {
2018-10-03 22:19:29 +02:00
return " Standard " ;
2018-10-03 21:53:26 +02:00
}
try {
Statement stmt = connection . createStatement ( ) ;
ResultSet rs = stmt . executeQuery ( " SELECT catid, catname FROM category "
+ " WHERE catid = " + catInPos + " ; " ) ;
2018-10-01 11:31:05 +02:00
return rs . getString ( " catname " ) ;
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
2018-10-03 21:53:26 +02:00
return " keine Kategorie " ;
2018-10-01 11:31:05 +02:00
}
}
2018-10-04 23:46:42 +02:00
// table Position section //
public void createTablePositionen ( )
{ // create table position
System . out . println ( " Erstelle Tabelle Positionen " ) ;
2018-10-01 11:31:05 +02:00
try {
Statement stmt = connection . createStatement ( ) ;
2018-10-04 23:46:42 +02:00
stmt . executeUpdate ( " DROP TABLE IF EXISTS positionen; " ) ;
stmt . executeUpdate (
" CREATE TABLE positionen (posid, name, value, cat, color); " ) ;
2018-10-01 11:31:05 +02:00
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
}
2018-10-04 23:46:42 +02:00
// create 25 demo/default data entries
for ( int i = 0 ; i < 25 ; i + + ) {
fillPositionen_Positionen ( i + 1 , " Noch frei " , ( float ) 0 . 00 , 6 ,
" #ad0000 " ) ;
2018-03-29 19:45:41 +02:00
}
}
2018-03-29 19:51:34 +02:00
2018-10-01 11:31:05 +02:00
public void fillPositionen_Positionen ( int pID , String pName , float pValue ,
int pCat , String pColor )
2018-04-02 20:31:47 +02:00
{ // create new data in table
System . out . println ( " Erstelle neuen positionen eintrag " ) ;
2018-03-29 19:51:34 +02:00
try {
2018-10-01 11:31:05 +02:00
PreparedStatement ps = connection . prepareStatement (
" INSERT INTO positionen VALUES (?, ?, ?, ?, ?); " ) ;
2018-04-02 20:31:47 +02:00
ps . setInt ( 1 , pID ) ; // primary
ps . setString ( 2 , pName ) ;
ps . setFloat ( 3 , pValue ) ;
2018-10-01 11:31:05 +02:00
ps . setInt ( 4 , pCat ) ;
ps . setString ( 5 , pColor ) ;
2018-03-29 19:45:41 +02:00
2018-04-02 20:31:47 +02:00
ps . addBatch ( ) ;
connection . setAutoCommit ( false ) ;
ps . executeBatch ( ) ; // SQL execution
connection . setAutoCommit ( true ) ;
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
2018-10-01 11:31:05 +02:00
public String getName_Positionen ( int pID )
2018-03-29 19:51:34 +02:00
{ // Gibt das Datum zurück
try {
Statement stmt = connection . createStatement ( ) ;
ResultSet rs = stmt . executeQuery (
2018-10-01 11:31:05 +02:00
" SELECT posid, name FROM positionen WHERE posid = " + pID + " ; " ) ;
2018-04-02 15:07:58 +02:00
return rs . getString ( " name " ) ;
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 " 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
2018-10-01 11:31:05 +02:00
public String getValue_Positionen ( int pID )
2018-03-29 19:51:34 +02:00
{ // Gibt das Konto zurück
try {
Statement stmt = connection . createStatement ( ) ;
ResultSet rs = stmt . executeQuery (
2018-10-01 11:31:05 +02:00
" SELECT posid, value FROM positionen WHERE posid = " + pID
+ " ; " ) ;
2018-04-02 15:07:58 +02:00
return rs . getString ( " value " ) ;
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 " 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
2018-10-01 11:31:05 +02:00
public int getCat_Positionen ( int pID )
2018-03-29 19:51:34 +02:00
{ // Gibt den Nutzernamen zurück
try {
Statement stmt = connection . createStatement ( ) ;
ResultSet rs = stmt . executeQuery (
2018-10-01 11:31:05 +02:00
" SELECT catid, cat FROM positionen WHERE catid = " + pID + " ; " ) ;
System . out . println ( " getCarTet: " + rs . getInt ( " cat " ) ) ;
return rs . getInt ( " cat " ) ;
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
return 0 ;
}
}
public String getColor_Positionen ( int pID )
{ // Gibt den Nutzernamen zurück
try {
Statement stmt = connection . createStatement ( ) ;
ResultSet rs = stmt . executeQuery (
" SELECT posid, color FROM positionen WHERE posid = " + pID
+ " ; " ) ;
2018-04-02 15:07:58 +02:00
return rs . getString ( " color " ) ;
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 " 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
2018-10-01 11:31:05 +02:00
public void setName_Positionen ( int pID , String pName )
2018-03-29 19:51:34 +02:00
{ // Setzt das Datum
try {
Statement stmt = connection . createStatement ( ) ;
2018-04-02 15:07:58 +02:00
stmt . executeUpdate ( " UPDATE positionen SET name = ' " + pName
2018-10-01 11:31:05 +02:00
+ " 'WHERE posid = " + pID + " ; " ) ;
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-10-01 11:31:05 +02:00
public void setValue_Positionen ( int pID , String pValue )
2018-03-29 19:51:34 +02:00
{ // Setzt das Konto
try {
Statement stmt = connection . createStatement ( ) ;
2018-04-02 15:07:58 +02:00
stmt . executeUpdate ( " UPDATE positionen SET value = ' " + pValue
2018-10-01 11:31:05 +02:00
+ " 'WHERE posid = " + pID + " ; " ) ;
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-10-01 11:31:05 +02:00
public void setCat_Positionen ( int pID , int pCat )
{ // Setzt den Nutzername
try {
Statement stmt = connection . createStatement ( ) ;
stmt . executeUpdate ( " UPDATE positionen SET cat = ' " + pCat
2018-10-03 21:53:26 +02:00
+ " 'WHERE posid = " + pID + " ; " ) ;
2018-10-01 11:31:05 +02:00
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
}
}
public void setColor_Positionen ( int pID , String pColor )
2018-03-29 19:51:34 +02:00
{ // Setzt den Nutzername
try {
Statement stmt = connection . createStatement ( ) ;
2018-04-02 15:07:58 +02:00
stmt . executeUpdate ( " UPDATE positionen SET color = ' " + pColor
2018-10-01 11:31:05 +02:00
+ " 'WHERE posid = " + pID + " ; " ) ;
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-04-02 20:31:47 +02:00
public ArrayList < tableDataPositionen > ladeTabellePositionen ( )
{ // Gibt ein Objekt daten mit allen Einträgen der DB zurück
ArrayList < tableDataPositionen > daten = new ArrayList < > ( ) ;
2018-03-29 19:51:34 +02:00
try {
Statement stmt = connection . createStatement ( ) ;
2018-04-02 20:31:47 +02:00
ResultSet rs = stmt . executeQuery ( " SELECT * FROM positionen; " ) ;
while ( rs . next ( ) ) {
try {
// Entschlüsselte Daten werden als Datenobjekt gespeichert
2018-10-01 11:31:05 +02:00
daten . add ( new tableDataPositionen ( rs . getInt ( " posid " ) ,
2018-04-02 20:31:47 +02:00
rs . getString ( " name " ) , rs . getString ( " value " ) ,
2018-10-01 11:31:05 +02:00
rs . getString ( " cat " ) , rs . getString ( " color " ) ) ) ;
2018-04-02 20:31:47 +02:00
} catch ( Exception e ) {
// TODO Auto-generated catch block
e . printStackTrace ( ) ;
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-04-02 20:31:47 +02:00
return daten ;
2018-03-29 19:45:41 +02:00
}
2018-10-01 11:31:05 +02:00
2018-04-02 20:31:47 +02:00
public void ausgebenSysoPositionen ( )
{ // Debugging Ausgabe der kompletten Tabelle
System . out . println ( " Print positionen " ) ;
2018-03-29 19:51:34 +02:00
try {
Statement stmt = connection . createStatement ( ) ;
2018-04-02 20:31:47 +02:00
ResultSet rs = stmt . executeQuery ( " SELECT * FROM positionen; " ) ;
2018-03-29 19:51:34 +02:00
while ( rs . next ( ) ) {
2018-10-01 11:31:05 +02:00
System . out . println ( " posid = " + rs . getString ( " posid " ) ) ;
2018-04-02 20:31:47 +02:00
System . out . println ( " name = " + rs . getString ( " name " ) ) ;
System . out . println ( " vale = " + rs . getString ( " value " ) ) ;
System . out . println ( " color = " + rs . getString ( " color " ) ) ;
System . out . println ( " " ) ;
2018-03-29 19:51:34 +02:00
}
2018-04-02 20:31:47 +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-10-04 23:46:42 +02:00
// table Category section //
public void createTableCategory ( )
{ // create table position
System . out . println ( " Erstelle Tabelle Kategorie " ) ;
try {
Statement stmt = connection . createStatement ( ) ;
stmt . executeUpdate ( " DROP TABLE IF EXISTS category; " ) ;
stmt . executeUpdate ( " CREATE TABLE category (catid, catname); " ) ;
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
}
fillCategory_Category ( 1 , " Essen " ) ;
fillCategory_Category ( 2 , " alkoholische Getränke " ) ;
fillCategory_Category ( 3 , " alkoholfreie Getränke " ) ;
fillCategory_Category ( 4 , " Kuchen " ) ;
fillCategory_Category ( 5 , " Standard " ) ;
}
public void setName_Category ( int pID , String pName )
{ // Setzte den Namen
try {
Statement stmt = connection . createStatement ( ) ;
stmt . executeUpdate ( " UPDATE category SET catname = ' " + pName
+ " 'WHERE catid = " + pID + " ; " ) ;
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
}
}
public void fillCategory_Category ( int pID , String pName )
{
System . out . println ( " Erstelle neuen Kategorie Eintrag " ) ;
try {
PreparedStatement ps = connection
. prepareStatement ( " INSERT INTO category VALUES (?, ?); " ) ;
ps . setInt ( 1 , pID ) ; // primary
ps . setString ( 2 , pName ) ;
ps . addBatch ( ) ;
connection . setAutoCommit ( false ) ;
ps . executeBatch ( ) ; // SQL execution
connection . setAutoCommit ( true ) ;
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
}
}
public String getName_Category ( int pID )
{ // Gibt das Datum zurück
try {
Statement stmt = connection . createStatement ( ) ;
ResultSet rs = stmt . executeQuery (
" SELECT catid, catname FROM category WHERE catid = " + pID
+ " ; " ) ;
return rs . getString ( " catname " ) ;
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
return " Error 404 " ;
}
}
// table Jobs section //
2018-04-02 20:31:47 +02:00
public void erstelleTabelleJobs ( )
{ // Erstelle Tabelle mit Reihen
System . out . println ( " Erstelle Tabelle Jobs " ) ;
2018-03-29 19:51:34 +02:00
try {
Statement stmt = connection . createStatement ( ) ;
2018-04-02 20:31:47 +02:00
stmt . executeUpdate ( " DROP TABLE IF EXISTS jobs; " ) ;
stmt . executeUpdate (
2018-10-05 13:01:42 +02:00
" CREATE TABLE jobs (jobid, time, positionen_quantity, positionen_name, positionen_value, positionen_cat, state, jobvalue); " ) ;
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-10-05 13:01:42 +02:00
public int getLatestJobNumber_Job ( )
{
2018-10-04 23:46:42 +02:00
try {
Statement stmt = connection . createStatement ( ) ;
ResultSet rs = stmt . executeQuery (
" SELECT jobid from jobs ORDER BY jobid DESC LIMIT 1; " ) ;
return rs . getInt ( " jobid " ) ;
} catch ( SQLException e ) {
2018-10-05 13:01:42 +02:00
// System.err.println("Couldn't handle DB-Query");
// e.printStackTrace();
2018-10-04 23:46:42 +02:00
}
2018-10-05 13:01:42 +02:00
return 0 ;
}
2018-10-07 00:50:59 +02:00
public String getTime_Job ( int pID )
{ // Gibt den Nutzernamen zurück
try {
Statement stmt = connection . createStatement ( ) ;
ResultSet rs = stmt . executeQuery (
" SELECT jobid, time FROM jobs WHERE jobid = " + pID + " ; " ) ;
return rs . getString ( " time " ) ;
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
return " 404 " ;
}
}
public String getQuantity_Job ( int pID )
{ // Gibt den Nutzernamen zurück
try {
Statement stmt = connection . createStatement ( ) ;
ResultSet rs = stmt . executeQuery (
" SELECT jobid, positionen_quantity FROM jobs WHERE jobid = "
+ pID + " ; " ) ;
return rs . getString ( " positionen_quantity " ) ;
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
return " 404 " ;
}
}
public String getName_Job ( int pID )
{ // Gibt den Nutzernamen zurück
try {
Statement stmt = connection . createStatement ( ) ;
ResultSet rs = stmt . executeQuery (
" SELECT jobid, positionen_name FROM jobs WHERE jobid = " + pID
+ " ; " ) ;
return rs . getString ( " positionen_name " ) ;
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
return " 404 " ;
}
}
public String getValue_Job ( int pID )
{ // Gibt den Nutzernamen zurück
try {
Statement stmt = connection . createStatement ( ) ;
ResultSet rs = stmt . executeQuery (
" SELECT jobid, positionen_value FROM jobs WHERE jobid = " + pID
+ " ; " ) ;
return rs . getString ( " positionen_value " ) ;
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
return " 404 " ;
}
}
public String getCategory_Job ( int pID )
{ // Gibt den Nutzernamen zurück
try {
Statement stmt = connection . createStatement ( ) ;
ResultSet rs = stmt . executeQuery (
" SELECT jobid, positionen_cat FROM jobs WHERE jobid = " + pID
+ " ; " ) ;
return rs . getString ( " positionen_cat " ) ;
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
return " 404 " ;
}
}
public String getState_Job ( int pID )
{ // Gibt den Nutzernamen zurück
try {
Statement stmt = connection . createStatement ( ) ;
ResultSet rs = stmt . executeQuery (
" SELECT jobid, state FROM jobs WHERE jobid = " + pID + " ; " ) ;
return rs . getString ( " state " ) ;
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
return " 404 " ;
}
}
public String getJobValue_Job ( int pID )
{ // Gibt den Nutzernamen zurück
try {
Statement stmt = connection . createStatement ( ) ;
ResultSet rs = stmt . executeQuery (
" SELECT jobid, jobvalue FROM jobs WHERE jobid = " + pID + " ; " ) ;
return rs . getString ( " jobvalue " ) ;
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
return " 404 " ;
}
}
public String getAllJobValue_Job ( )
{ // Gibt den Nutzernamen zurück
try {
Statement stmt = connection . createStatement ( ) ;
ResultSet rs = stmt . executeQuery (
" SELECT state, jobvalue, SUM(jobvalue) AS ALLVALUE FROM jobs WHERE state = "
+ '"' + " verbucht " + '"' + " ; " ) ;
return rs . getString ( " ALLVALUE " ) ;
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
return " 0 " ;
}
}
2018-12-03 21:50:41 +01:00
public String getJobCount ( )
{ // Gibt den Nutzernamen zurück
try {
Statement stmt = connection . createStatement ( ) ;
ResultSet rs = stmt . executeQuery (
" SELECT count(*) AS JOBCOUNT FROM jobs WHERE state = "
+ '"' + " verbucht " + '"' + " ; " ) ;
return rs . getString ( " JOBCOUNT " ) ;
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
return " 0 " ;
}
}
2018-10-07 00:50:59 +02:00
public void setStatus_Jobs ( int pID , String pStatus )
{ // Setzt das Konto
try {
Statement stmt = connection . createStatement ( ) ;
stmt . executeUpdate ( " UPDATE jobs SET state = ' " + pStatus
+ " 'WHERE jobid = " + pID + " ; " ) ;
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
}
}
public ArrayList < tableDataJob > loadTableJobs_Job ( )
{ // Gibt den Nutzernamen zurück
ArrayList < tableDataJob > tmp = new ArrayList < tableDataJob > ( ) ;
try {
Statement stmt = connection . createStatement ( ) ;
ResultSet rs = stmt . executeQuery (
" SELECT jobid, time, positionen_quantity, positionen_name, positionen_value, positionen_cat, state, jobvalue FROM jobs; " ) ;
while ( rs . next ( ) ) {
try {
// return rs.getString("jobvalue");
String tablePosition = rs . getString ( " positionen_name " ) ;
tableDataJob data = new tableDataJob ( rs . getInt ( " jobid " ) ,
rs . getString ( " time " ) , tablePosition , rs . getString ( " state " ) ,
rs . getString ( " jobvalue " ) ) ;
tmp . add ( data ) ;
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
}
}
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
}
return tmp ;
}
public void fillJobs_Jobs ( int pID , String pTime , String pPositionen_quantity ,
String pPositionen_name , String pPositionen_value ,
String pPositionen_cat , String pState , String pJobvalue )
2018-10-05 13:01:42 +02:00
{
System . out . println ( " Create new Job Entry " ) ;
try {
2018-10-07 00:50:59 +02:00
PreparedStatement ps = connection . prepareStatement (
" INSERT INTO jobs VALUES (?, ?, ?, ?, ?, ?, ?, ?); " ) ;
2018-10-05 13:01:42 +02:00
ps . setInt ( 1 , pID ) ; // primary
ps . setString ( 2 , pTime ) ;
ps . setString ( 3 , pPositionen_quantity ) ;
ps . setString ( 4 , pPositionen_name ) ;
ps . setString ( 5 , pPositionen_value ) ;
ps . setString ( 6 , pPositionen_cat ) ;
ps . setString ( 7 , pState ) ;
ps . setString ( 8 , pJobvalue ) ;
ps . addBatch ( ) ;
connection . setAutoCommit ( false ) ;
ps . executeBatch ( ) ; // SQL execution
connection . setAutoCommit ( true ) ;
} catch ( SQLException e ) {
System . err . println ( " Couldn't handle DB-Query " ) ;
e . printStackTrace ( ) ;
}
2018-10-04 23:46:42 +02:00
}
2018-03-29 19:51:34 +02:00
2018-03-29 19:45:41 +02:00
}