finish up bonus-1

bonus-1/.classpath

@@ -6,12 +6,12 @@
 			<attribute name="module" value="true"/>
 		</attributes>
 	</classpathentry>
-	<classpathentry kind="lib" path="/home/local/Downloads/sqlite-jdbc-3.43.2.2.jar">
+	<classpathentry kind="lib" path="C:/Program Files/SQLite/sqlite-jdbc-3.43.2.2.jar">
 		<attributes>
 			<attribute name="module" value="true"/>
 		</attributes>
 	</classpathentry>
-	<classpathentry kind="lib" path="/home/local/Downloads/slf4j-api-1.7.36.jar">
+	<classpathentry kind="lib" path="C:/Program Files/SQLite/slf4j-api-1.7.36.jar">
 		<attributes>
 			<attribute name="module" value="true"/>
 		</attributes>

bonus-1/schema-and-data.sql

@@ -0,0 +1,135 @@
+DROP TABLE IF EXISTS MovieCharacter;
+DROP TABLE IF EXISTS MovieGenre;
+DROP TABLE IF EXISTS Movie;
+DROP TABLE IF EXISTS Person;
+DROP TABLE IF EXISTS Genre;
+DROP TABLE IF EXISTS Counter;
+
+CREATE TABLE Person (
+	PersonID LONG PRIMARY KEY,
+	Name VARCHAR(100),
+	Sex char
+);
+
+CREATE TABLE Genre (
+	GenreID LONG PRIMARY KEY,
+	Genre VARCHAR(100)
+);
+
+CREATE TABLE Movie (
+	MovieID LONG PRIMARY KEY,
+	Title VARCHAR(100),
+	Year INT,
+	Type CHAR
+);
+CREATE TABLE MovieGenre (
+	MovieID LONG,
+	GenreID LONG,
+	PRIMARY KEY (MovieID, GenreID),
+	FOREIGN KEY (MovieID)
+		REFERENCES Movie(MovieID)
+		ON DELETE CASCADE,
+	FOREIGN KEY (GenreID)
+		REFERENCES Genre(GenreId)
+		ON DELETE CASCADE
+);
+
+CREATE TABLE MovieCharacter (
+	MovCharID LONG PRIMARY KEY,
+	Character VARCHAR(100),
+	Alias VARCHAR(100),
+	Position INT,
+	PlayedBy LONG,
+	MovieID LONG,
+	FOREIGN KEY (PlayedBy)
+		REFERENCES Person(PersonID)
+		ON DELETE CASCADE,
+	FOREIGN KEY (MovieID)
+		REFERENCES Movie(MovieID)
+		ON DELETE CASCADE
+);
+
+CREATE TABLE Counter (
+	TableName VARCHAR(100) PRIMARY KEY,
+	Counter LONG
+);
+
+INSERT INTO `Person` VALUES
+	(0, 'Peter Fritz Willi Lustig', 'M'),
+	(1, 'Ryan Reynolds', 'M'),
+	(2, 'Tom Holland', 'M'),
+	(3, 'Robert Downey Jr', 'M'),
+	(4, 'Emma Watson', 'F'),
+	(5, 'Daniel Radcliffe', 'M'),
+	(6, 'Benedict Cumberbatch', 'M'),
+	(7, 'Martin Freeman', 'M');
+
+INSERT INTO `Counter` VALUES ('Person', 8);
+
+INSERT INTO `Genre` VALUES
+	(0, 'Kinder'),
+	(1, 'Comedy'),
+	(2, 'Action'),
+	(3, 'Superhelden'),
+	(4, 'Fantasy'),
+	(5, 'Mystery'),
+	(6, 'Drama'),
+	(7, 'Adventure');
+	
+INSERT INTO `Counter` VALUES ('Genre', 8);
+
+INSERT INTO `Movie` VALUES
+	(0, 'Löwenzahn', 1981, 'S'),
+	(1, 'Deadpool', 2016, 'M'),
+	(2, 'The Proposal', 2009, 'M'),
+	(3, 'Spider-Man: Homecoming', 2017, 'M'),
+	(4, 'Avengers: Endgame', 2019, 'M'),
+	(5, 'Harry Potter and the Philosophers Stone', 2001, 'M'),
+	(6, 'Doctor Strange', 2016, 'M'),
+	(7, 'The Hobbit', 2012, 'M'),
+	(8, 'Sherlock', 2010, 'S');
+
+
+INSERT INTO `Counter` VALUES ('Movie', 9);
+
+INSERT INTO MovieGenre VALUES
+	(0, 0),
+	(0, 1),
+	(1, 1),
+	(1, 2),
+	(1, 3),
+	(2, 6),
+	(2, 1),
+	(3, 2),
+	(3, 3),
+	(4, 2),
+	(4, 3),
+	(5, 4),
+	(5, 7),
+	(6, 2),
+	(6, 3),
+	(6, 4),
+	(7, 4),
+	(7, 7),
+	(8, 5),
+	(8, 6);
+
+INSERT INTO `MovieCharacter` VALUES
+	(0, 'Peter Lustig', 'Peter', 0, 0, 0),	
+	(1, 'Wade Wilson', 'Deadpool', 0, 1, 1),
+	(2, 'Andrew Paxton', 'Andrew', 0, 1, 2),
+	(3, 'Peter Parker', 'Spider-Man', 0, 2, 3),
+	(4, 'Tony Stark', 'Iron-Man', 0, 3, 3),
+	(5, 'Peter Parker', 'Spider-Man', 0, 2, 4),
+	(6, 'Tony Stark', 'Iron-Man', 0, 3, 4),
+	(7, 'Stephen Strange', 'Doctor Strange', 0, 6, 4),
+	(8, 'Hermione Granger', 'Hermine', 0, 4, 5),
+	(9, 'Harry Potter', 'The boy who lived', 0, 5, 5),
+	(10, 'Stephen Strange', 'Doctor Strange', 0, 6, 6),
+	(11, 'Bilbo Baggins', 'Bilbo Beutlin', 0, 7, 7),
+	(12, 'Sauron', 'Annatar', 0, 6, 7),
+	(13, 'Smaug', 'Smaug the Golden', 0, 6, 7),
+	(14, 'Sherlock Holmes', 'Consulting Detective Holmes', 0, 6, 8),
+	(15, 'John H. Watson', 'Dr. Watson', 0, 7, 8);
+
+INSERT INTO `Counter` VALUES ('MovieCharacter', 16);

bonus-1/src/Main.java

@@ -1,48 +0,0 @@
-import java.sql.*;
-
-public class Main {
-	public static void main(String[] args) throws SQLException {
-		ConnectionManager.connect();
-		
-		Person p = new Person(0, "Mueller", 'M');
-		p.insert();
-		
-		
-		for (Person ps : Person.findAll()) {
-			System.out.println(ps);
-		}
-		
-		
-		Genre g = new Genre(0, "Horror");
-		g.insert();
-		
-		for (Genre gs : Genre.findAll()) {
-			System.out.println(gs);
-		}
-		
-		Movie m = new Movie(0, "Löwenzahn", 1981, 'S');
-		m.insert();
-		
-		for (Movie ms : Movie.findAll()) {
-			System.out.println(ms);
-		}
-		
-		
-		MovieCharacter mc = new MovieCharacter(0, "Peter Lustig", "Peter Unlustig", 1, p.getPersonID(), 2);
-		mc.insert();
-		
-		for (MovieCharacter mcs : MovieCharacter.findAll()) {
-			System.out.println(mcs);
-		}
-		
-		
-		MovieGenre mg = new MovieGenre(m.getMovieID(), g.getGenreID());
-		mg.insert();
-		
-		for (MovieGenre mgs : MovieGenre.findAll()) {
-			System.out.println(mgs);
-		}
-		
-		ConnectionManager.disconnect();
-	}
-}

bonus-1/src/de/hsh/dbs2/imdb/Starter.java

@@ -0,0 +1,31 @@
+package de.hsh.dbs2.imdb;
+
+import javax.swing.SwingUtilities;
+
+import de.hsh.dbs2.imdb.gui.SearchMovieDialog;
+import de.hsh.dbs2.imdb.gui.SearchMovieDialogCallback;
+
+public class Starter {
+
+	/**
+	 * @param args
+	 * @throws Throwable 
+	 */
+	public static void main(String[] args) throws Throwable {
+		
+		SwingUtilities.invokeLater(new Runnable() {
+			@Override
+			public void run() {
+				new Starter().run();
+			}
+		});
+	
+	}
+	
+	public void run() {
+		SearchMovieDialogCallback callback = new SearchMovieDialogCallback();
+		SearchMovieDialog sd = new SearchMovieDialog(callback);
+		sd.setVisible(true);
+	}
+
+}

bonus-1/src/de/hsh/dbs2/imdb/gui/CharacterDialog.java

@@ -0,0 +1,232 @@
+package de.hsh.dbs2.imdb.gui;
+
+import java.awt.GridBagConstraints;
+import java.awt.GridBagLayout;
+import java.awt.Insets;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.swing.JButton;
+import javax.swing.JDialog;
+import javax.swing.JLabel;
+import javax.swing.JList;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTextField;
+import javax.swing.event.DocumentEvent;
+import javax.swing.event.DocumentListener;
+import javax.swing.event.ListSelectionEvent;
+import javax.swing.event.ListSelectionListener;
+
+/**
+ * Dialog um einen Character eines Filmes zu aendern.
+ * Es kann eine neue Person (d.h. ein neuer Schauspieler) ausgewaehlt werden,
+ * und es kann Name und Alias des Characters veraendert werden.
+ * Die Position wird indirekt ueber die Sortierung der Liste im Movie-Dialog 
+ * festgelegt.
+ */
+public class CharacterDialog extends JDialog {
+	private static final long serialVersionUID = 1L;
+
+	private JLabel labCharacter;
+	private JTextField txtCharacter;
+
+	private JLabel labAlias;
+	private JTextField txtAlias;
+
+	private JLabel labPlayer;
+	private JTextField txtPlayer;
+	private JList<String> lstPersons;
+	private JScrollPane scrPersons;
+
+	private JPanel pnlButtons;
+	private JButton btnOk;
+	private JButton btnCancel;
+
+	private String outcome = "cancel";
+
+	private CharacterDialogCallback callback;
+	
+	private String player;
+	
+	public CharacterDialog(CharacterDialogCallback callback) {
+		this.callback = callback;
+		
+		setTitle("Movie Character");
+		setSize(200, 200);
+		setModal(true);
+
+		GridBagLayout layout = new GridBagLayout();
+		setLayout(layout);
+
+		GridBagConstraints gbc = new GridBagConstraints();
+
+		// Festlegen, dass die GUI-Elemente die Gitterfelder in
+		// waagerechter Richtung ausfuellen:
+		gbc.fill = GridBagConstraints.BOTH;
+
+		// Die Abstaende der einzelnen GUI-Elemente zu den gedachten
+		// Gitterlinien festgelegen:
+		gbc.insets = new Insets(2, 2, 2, 2);
+
+		gbc.gridx = 0;
+		gbc.gridy = 0;
+		labCharacter = new JLabel("Character:");
+		layout.setConstraints(labCharacter, gbc);
+		add(labCharacter);
+
+		gbc.gridx = 1;
+		gbc.gridy = 0;
+		txtCharacter = new JTextField(50);
+		layout.setConstraints(txtCharacter, gbc);
+		add(txtCharacter);
+
+		gbc.gridx = 0;
+		gbc.gridy = 1;
+		labAlias = new JLabel("Alias:");
+		layout.setConstraints(labAlias, gbc);
+		add(labAlias);
+
+		gbc.gridx = 1;
+		gbc.gridy = 1;
+		txtAlias = new JTextField(50);
+		layout.setConstraints(txtAlias, gbc);
+		add(txtAlias);
+
+		gbc.gridx = 0;
+		gbc.gridy = 3;
+		labPlayer = new JLabel("Player:");
+		layout.setConstraints(labPlayer, gbc);
+		add(labPlayer);
+
+		gbc.gridx = 1;
+		gbc.gridy = 3;
+		txtPlayer = new JTextField(50);
+		layout.setConstraints(txtPlayer, gbc);
+		add(txtPlayer);
+
+		txtPlayer.getDocument().addDocumentListener(new DocumentListener() {
+			@Override
+			public void changedUpdate(DocumentEvent arg0) {
+				loadPersonList();
+			}
+			@Override
+			public void insertUpdate(DocumentEvent arg0) {
+				loadPersonList();
+			}
+			@Override
+			public void removeUpdate(DocumentEvent arg0) {
+				loadPersonList();
+			}
+		});
+		
+		gbc.gridx = 0;
+		gbc.gridy = 4;
+		gbc.gridheight = 4;
+		gbc.gridwidth = 2;
+		lstPersons = new JList<String>();
+		scrPersons = new JScrollPane(lstPersons);
+		layout.setConstraints(scrPersons, gbc);
+		add(scrPersons);
+		
+		lstPersons.addListSelectionListener(new ListSelectionListener() {
+			
+			@Override
+			public void valueChanged(ListSelectionEvent e) {
+				if (lstPersons.getSelectedIndex() != -1) {
+					String player = lstPersons.getSelectedValue();
+					setPlayer(player);
+				}
+			}
+		});
+		
+		gbc.gridx = 0;
+		gbc.gridy = 8;
+		gbc.gridheight = 1;
+		gbc.gridwidth = 2;
+		pnlButtons = new JPanel();
+		layout.setConstraints(pnlButtons, gbc);
+		add(pnlButtons);
+
+		btnOk = new JButton("OK");
+		pnlButtons.add(btnOk);
+
+		btnOk.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				outcome = "ok";
+				setVisible(false);
+			}
+		});
+
+		btnCancel = new JButton("Cancel");
+		pnlButtons.add(btnCancel);
+
+		btnCancel.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				try {
+					outcome = "cancel";
+					setVisible(false);
+				} catch (Exception ex) {
+					ex.printStackTrace();
+				}
+			}
+		});
+
+		setResizable(false);
+		pack();
+		setLocationRelativeTo(null);
+	}
+
+	public void start() {
+		pack();
+		outcome = "cancel";
+		setVisible(true);
+	}
+
+	public void setCharacter(String character) {
+		txtCharacter.setText(character);
+	}
+	
+	public String getCharacter() {
+		return txtCharacter.getText();
+	}
+	
+	public void setAlias(String alias) {
+		txtAlias.setText(alias);
+	}
+	
+	public String getAlias() {
+		return txtAlias.getText();
+	}
+	
+	public void setPlayer(String player) {
+		txtPlayer.setText(player);
+		this.player = player;
+	}
+	
+	public String getPlayer() {
+		return this.player;
+	}
+		
+	public String getOutcome() {
+		return outcome;
+	}
+
+	/**
+	 * Neuladen der Personenliste. Wird immer aufgerufen, wenn der Text im Dialogfeld "schauspieler"
+	 * geaendert wurde.
+	 */
+	private void loadPersonList() {
+		List<String> p;
+		if (txtPlayer.getText().isEmpty()) {
+			p = new ArrayList<String>();
+		} else {
+			p = callback.getPersonList(txtPlayer.getText());
+		}
+		lstPersons.setListData(p.toArray(new String[0]));
+	}
+
+
+}

bonus-1/src/de/hsh/dbs2/imdb/gui/CharacterDialogCallback.java

@@ -0,0 +1,23 @@
+package de.hsh.dbs2.imdb.gui;
+
+import java.util.List;
+
+import javax.swing.JOptionPane;
+
+import de.hsh.dbs2.imdb.logic.PersonManager;
+
+public class CharacterDialogCallback {
+
+	private PersonManager pm = new PersonManager();
+
+	public List<String> getPersonList(String text) {
+		try {
+			List<String> persons = pm.getPersonList(text);
+			return persons;
+		} catch (Exception e) {
+			JOptionPane.showMessageDialog(null, "Fehler bei der Personensuche: \n" + e.getMessage());
+			e.printStackTrace();
+			return null;
+		}
+	}
+}

bonus-1/src/de/hsh/dbs2/imdb/gui/MovieDialog.java

@@ -0,0 +1,351 @@
+package de.hsh.dbs2.imdb.gui;
+
+import java.awt.GridBagConstraints;
+import java.awt.GridBagLayout;
+import java.awt.Insets;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import javax.swing.JButton;
+import javax.swing.JDialog;
+import javax.swing.JLabel;
+import javax.swing.JList;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTable;
+import javax.swing.JTextField;
+import javax.swing.ListSelectionModel;
+
+import de.hsh.dbs2.imdb.logic.dto.CharacterDTO;
+import de.hsh.dbs2.imdb.logic.dto.MovieDTO;
+
+public class MovieDialog extends JDialog {
+	private static final long serialVersionUID = 1L;
+
+	private JLabel labId;
+	private JLabel txtId;
+
+	private JLabel labTitle;
+	private JTextField txtTitle;
+
+	private JLabel labYear;
+	private JTextField txtYear;
+
+	private JLabel labType;
+	private JTextField txtType;
+
+	private JLabel labGenre;
+	private JList<String> lstGenre;
+	private JScrollPane scrGenre; 
+	
+	private JPanel pnlButtons;
+	private JButton btnOk;
+	private JButton btnCancel;
+	
+	private JTable tabCharacters;
+	private JScrollPane scrCharacters;
+
+	private JButton btnUp;
+	private JButton btnDown;
+	private JButton btnAdd;
+	private JButton btnEdit;
+	private JButton btnDelete;
+
+	private String outcome = "cancel";
+
+	private MovieDialogCallback callback;
+	private TabModelCharacter tabModel;
+
+	private MovieDTO movie;
+	
+	public MovieDialog(MovieDialogCallback callback, List<String> allGenres) {
+		this.callback = callback;
+		
+		setTitle("Movie");
+		setSize(400, 200);
+		setModal(true);
+
+		GridBagLayout layout = new GridBagLayout();
+		setLayout(layout);
+
+		GridBagConstraints gbc = new GridBagConstraints();
+		gbc.fill = GridBagConstraints.BOTH;
+		gbc.insets = new Insets(2, 2, 2, 2);
+
+		gbc.gridx = 0;
+		gbc.gridy = 0;
+		labId = new JLabel("Id:");
+		layout.setConstraints(labId, gbc);
+		add(labId);
+
+		gbc.gridx = 1;
+		gbc.gridy = 0;
+		txtId = new JLabel("");
+		layout.setConstraints(txtId, gbc);
+		add(txtId);
+
+		gbc.gridx = 0;
+		gbc.gridy = 1;
+		labTitle = new JLabel("Title:");
+		layout.setConstraints(labTitle, gbc);
+		add(labTitle);
+
+		gbc.gridx = 1;
+		gbc.gridy = 1;
+		txtTitle = new JTextField(50);
+		layout.setConstraints(txtTitle, gbc);
+		add(txtTitle);
+
+		gbc.gridx = 0;
+		gbc.gridy = 2;
+		labYear = new JLabel("Year:");
+		layout.setConstraints(labYear, gbc);
+		add(labYear);
+
+		gbc.gridx = 1;
+		gbc.gridy = 2;
+		txtYear = new JTextField(4);
+		layout.setConstraints(txtYear, gbc);
+		add(txtYear);
+
+		gbc.gridx = 0;
+		gbc.gridy = 3;
+		labType = new JLabel("Type:");
+		layout.setConstraints(labType, gbc);
+		add(labType);
+
+		gbc.gridx = 1;
+		gbc.gridy = 3;
+		txtType = new JTextField(1);
+		layout.setConstraints(txtType, gbc);
+		add(txtType);
+
+		gbc.gridx = 0;
+		gbc.gridy = 4;
+		labGenre = new JLabel("Genres:");
+		layout.setConstraints(labGenre, gbc);
+		add(labGenre);
+
+		gbc.gridx = 1;
+		gbc.gridy = 4;
+		gbc.gridheight = 4;
+		lstGenre = new JList<String>();
+		scrGenre = new JScrollPane(lstGenre);
+		layout.setConstraints(scrGenre, gbc);
+		add(scrGenre);
+
+		gbc.gridx = 0;
+		gbc.gridy = 8;
+		gbc.gridheight = 1;
+		gbc.gridwidth = 4;
+		pnlButtons = new JPanel();
+		layout.setConstraints(pnlButtons, gbc);
+		add(pnlButtons);
+
+		btnOk = new JButton("OK");
+		pnlButtons.add(btnOk);
+		
+		btnOk.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				outcome = "ok";
+				updateMovie();
+				setVisible(false);
+			}
+		});
+
+		btnCancel = new JButton("Cancel");
+		pnlButtons.add(btnCancel);
+
+		btnCancel.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				outcome = "cancel";
+				setVisible(false);
+			}
+		});
+
+		lstGenre.setListData(allGenres.toArray(new String[0]));
+
+		gbc.gridx = 2;
+		gbc.gridy = 0;
+		gbc.gridheight = 8;
+		gbc.gridwidth = 1;
+		gbc.fill = GridBagConstraints.BOTH;
+		tabCharacters = new JTable();
+		tabCharacters.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
+		tabCharacters.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+		scrCharacters = new JScrollPane(tabCharacters);
+		layout.setConstraints(scrCharacters, gbc);
+		add(scrCharacters);
+
+		gbc.gridx = 3;
+		gbc.gridy = 0;
+		gbc.gridheight = 1;
+		btnUp = new JButton("Up");
+		layout.setConstraints(btnUp, gbc);
+		add(btnUp);
+
+		btnUp.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				moveCharacterUp();
+			}
+		});
+
+		gbc.gridx = 3;
+		gbc.gridy = 1;
+		gbc.gridheight = 1;
+		btnDown = new JButton("Down");
+		layout.setConstraints(btnDown, gbc);
+		add(btnDown);
+
+		btnDown.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				moveCharacterDown();
+			}
+		});
+
+		gbc.gridx = 3;
+		gbc.gridy = 2;
+		btnAdd = new JButton("Add");
+		layout.setConstraints(btnAdd, gbc);
+		add(btnAdd);
+
+		btnAdd.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				addCharacter();
+			}
+		});
+
+		gbc.gridx = 3;
+		gbc.gridy = 3;
+		btnEdit = new JButton("Edit");
+		layout.setConstraints(btnEdit, gbc);
+		add(btnEdit);
+
+		btnEdit.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				editCharacter();
+			}
+		});
+
+		gbc.gridx = 3;
+		gbc.gridy = 4;
+		btnDelete = new JButton("Delete");
+		layout.setConstraints(btnDelete, gbc);
+		add(btnDelete);
+
+		btnDelete.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				deleteCharacter();
+			}
+		});
+
+		tabCharacters.addMouseListener(new MouseAdapter() {
+			public void mouseClicked(MouseEvent e) {
+				if (e.getClickCount() == 2) {
+					editCharacter();
+				}
+			}
+		});
+
+		setResizable(false);
+		pack();
+		setLocationRelativeTo(null);
+	}
+
+	public void setMovie(MovieDTO movie) {
+		this.movie = movie;
+		txtId.setText(movie.getId() == null ? "" : ("" + movie.getId()) );
+		txtTitle.setText(movie.getTitle());
+		txtYear.setText("" + movie.getYear());
+		txtType.setText(("" + movie.getType()).trim());
+
+		int [] indices = new int[movie.getGenres().size()];
+		int j = 0;
+		for (String genre : movie.getGenres()) {
+			for (int i = 0; i < lstGenre.getModel().getSize(); i++) {
+				if (lstGenre.getModel().getElementAt(i).equals(genre))
+					indices[j++] = i;
+			}
+		}
+		lstGenre.setSelectedIndices(indices);
+		
+		tabModel = new TabModelCharacter(movie.getCharacters());
+		tabCharacters.setModel(tabModel);
+
+		tabCharacters.getColumnModel().getColumn(0).setPreferredWidth(150);
+		tabCharacters.getColumnModel().getColumn(1).setPreferredWidth(150);
+		tabCharacters.getColumnModel().getColumn(2).setPreferredWidth(150);
+
+		pack();
+	}
+
+	public void updateMovie() {
+		// Werte aus den Dialogfeldern in den Movie uebernehmen
+		movie.setTitle(txtTitle.getText());
+		movie.setYear(Integer.parseInt(txtYear.getText()));
+		movie.setType(txtType.getText());
+
+		// In der Liste selektiere Genres in die Liste im Movie uebernehmen
+		Set<String> genres = new HashSet<String>();
+		for (int i : lstGenre.getSelectedIndices()) {
+			String genre = lstGenre.getModel().getElementAt(i);
+			genres.add(genre);
+		}
+		movie.setGenres(genres);
+	}
+
+	public String getOutcome() {
+		return outcome;
+	}
+
+
+	public void moveCharacterUp() {
+		int sel = tabCharacters.getSelectedRow();
+		if (sel > 0) {
+			tabModel.up(sel);
+			tabModel.fireTableDataChanged();
+			tabCharacters.setRowSelectionInterval(sel - 1, sel - 1);
+		}
+	}
+	
+	public void moveCharacterDown() {
+		int sel = tabCharacters.getSelectedRow();
+		if (sel < tabCharacters.getRowCount() - 1) {
+			tabModel.down(tabCharacters.getSelectedRow());
+			tabModel.fireTableDataChanged();
+			tabCharacters.setRowSelectionInterval(sel + 1, sel + 1);
+		}
+	}
+	
+	public void addCharacter() {
+		CharacterDTO character = callback.addCharacter();
+		if (character != null) {
+			tabModel.addRow(character);
+			tabModel.fireTableDataChanged();
+		}
+	}
+	
+	public void editCharacter() {
+		int row = tabCharacters.getSelectedRow();
+		CharacterDTO mc = tabModel.getRow(row);
+		callback.editCharacter(mc);
+		tabModel.fireTableDataChanged();
+	}
+
+	public void deleteCharacter() {
+		int row = tabCharacters.getSelectedRow();
+		if (row >= 0) {
+			tabModel.deleteRow(tabCharacters.getSelectedRow());
+			tabModel.fireTableDataChanged();
+			if (row >= tabModel.getRowCount())
+				row--;
+			if (row >= 0)
+				tabCharacters.setRowSelectionInterval(row, row);
+		}
+	}
+}

bonus-1/src/de/hsh/dbs2/imdb/gui/MovieDialogCallback.java

@@ -0,0 +1,35 @@
+package de.hsh.dbs2.imdb.gui;
+
+import de.hsh.dbs2.imdb.logic.dto.CharacterDTO;
+
+public class MovieDialogCallback {
+
+	public CharacterDTO addCharacter() {
+		CharacterDialogCallback callback = new CharacterDialogCallback();
+		CharacterDialog cd = new CharacterDialog(callback);
+		cd.setVisible(true);
+		if (cd.getOutcome().equals("ok")) {
+			CharacterDTO mc = new CharacterDTO();
+			mc.setCharacter(cd.getCharacter());
+			mc.setAlias(cd.getAlias());
+			mc.setPlayer(cd.getPlayer());
+			return mc;
+		} else
+			return null;
+	}
+
+	public void editCharacter(CharacterDTO character) {
+		CharacterDialogCallback callback = new CharacterDialogCallback();
+		CharacterDialog cd = new CharacterDialog(callback);
+		cd.setCharacter(character.getCharacter());
+		cd.setAlias(character.getAlias());
+		cd.setPlayer(character.getPlayer());
+		cd.start();
+		if (cd.getOutcome().equals("ok")) {
+			character.setCharacter(cd.getCharacter());
+			character.setAlias(cd.getAlias());
+			character.setPlayer(cd.getPlayer());
+		}
+	}
+
+}

bonus-1/src/de/hsh/dbs2/imdb/gui/SearchMovieDialog.java

@@ -0,0 +1,192 @@
+package de.hsh.dbs2.imdb.gui;
+
+import java.awt.GridBagConstraints;
+import java.awt.GridBagLayout;
+import java.awt.Insets;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+import java.awt.event.WindowListener;
+import java.util.List;
+
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JOptionPane;
+import javax.swing.JScrollPane;
+import javax.swing.JTable;
+import javax.swing.JTextField;
+import javax.swing.ListSelectionModel;
+
+import de.hsh.dbs2.imdb.logic.dto.MovieDTO;
+
+
+public class SearchMovieDialog extends JFrame {
+	private static final long serialVersionUID = 1L;
+
+	private JTextField txtSearch;
+	private JButton btnSearch;
+
+	private JTable tabResult;
+	private JScrollPane scrResult;
+	
+	private JButton btnAdd;
+	private JButton btnEdit;
+	private JButton btnDelete;
+
+	private TabModelMovie tabModel;
+	
+	private SearchMovieDialogCallback callback;
+	
+	public SearchMovieDialog(SearchMovieDialogCallback callback) {
+		
+		this.callback = callback;
+		
+		setTitle("Search");
+		setSize(200, 200);
+
+		GridBagLayout layout = new GridBagLayout();
+		setLayout(layout);
+
+		GridBagConstraints gbc = new GridBagConstraints();
+
+		// Festlegen, dass die GUI-Elemente die Gitterfelder in
+		// waagerechter Richtung ausfuellen:
+		gbc.fill = GridBagConstraints.BOTH;
+
+		// Die Abstaende der einzelnen GUI-Elemente zu den gedachten
+		// Gitterlinien festgelegen:
+		gbc.insets = new Insets(2, 2, 2, 2);
+		gbc.gridx = 0;
+		gbc.gridy = 0;
+		txtSearch = new JTextField(50);
+		layout.setConstraints(txtSearch, gbc);
+		add(txtSearch);
+
+		gbc.gridx = 1;
+		gbc.gridy = 0;
+		btnSearch = new JButton("Search");
+		layout.setConstraints(btnSearch, gbc);
+		add(btnSearch);
+
+		gbc.gridx = 0;
+		gbc.gridy = 1;
+		gbc.gridwidth = 1;
+		gbc.gridheight = 8;
+		tabResult = new JTable();
+		tabResult.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
+		tabResult.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+		scrResult = new JScrollPane(tabResult);
+		layout.setConstraints(scrResult, gbc);
+		add(scrResult);
+
+		gbc.gridx = 1;
+		gbc.gridy = 1;
+		gbc.gridheight = 1;
+		btnAdd = new JButton("Add");
+		layout.setConstraints(btnAdd, gbc);
+		add(btnAdd);
+		
+		gbc.gridx = 1;
+		gbc.gridy = 2;
+		gbc.gridheight = 1;
+		btnEdit = new JButton("Edit");
+		layout.setConstraints(btnEdit, gbc);
+		add(btnEdit);
+
+		gbc.gridx = 1;
+		gbc.gridy = 3;
+		gbc.gridheight = 1;
+		btnDelete = new JButton("Delete");
+		layout.setConstraints(btnDelete, gbc);
+		add(btnDelete);
+
+		tabResult.addMouseListener(new MouseAdapter() {
+			public void mouseClicked(MouseEvent e) {
+				if (e.getClickCount() == 2) {
+					editMovie();
+				}
+			}
+		});
+
+		btnSearch.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				search();
+			}
+		});
+
+		btnAdd.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				addMovie();
+			}
+		});
+
+		btnEdit.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				editMovie();
+			}
+		});
+
+		btnDelete.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				deleteMovie();
+			}
+		});
+		
+		WindowListener windowListener = new WindowAdapter() {
+			public void windowClosing(WindowEvent w) {
+				System.exit(0);
+			}
+		};
+		this.addWindowListener(windowListener);
+
+		setResizable(false);
+		pack();
+		setLocationRelativeTo(null);
+	}
+
+	private MovieDTO getSelection() {
+		if (tabResult.getSelectedRow() != -1)
+			return tabModel.getRow(tabResult.getSelectedRow());
+		else
+			return null;
+	}
+
+	private void addMovie() {
+		callback.addMovie();
+		search();
+	}
+	
+	private void editMovie() {
+		if (getSelection() == null) 
+			JOptionPane.showMessageDialog(null, "Bitte zuerst einen Film auswaehlen!");
+		else {
+			callback.editMovie(getSelection().getId());
+			search();
+		}
+	}
+	
+	private void deleteMovie() {
+		callback.deleteMovie(getSelection().getId());
+		search();
+	}
+	
+	private void search() {
+		int row = tabResult.getSelectedRow();
+
+		List<MovieDTO> result = callback.runSearch(txtSearch.getText());
+		if (result != null) {
+			tabModel = new TabModelMovie(result);
+			tabResult.setModel(tabModel);
+			tabResult.getColumnModel().getColumn(0).setPreferredWidth(60);
+			tabResult.getColumnModel().getColumn(1).setPreferredWidth(300);
+			tabResult.getColumnModel().getColumn(2).setPreferredWidth(60);
+			tabResult.getColumnModel().getColumn(3).setPreferredWidth(60);
+			
+			tabResult.getSelectionModel().setSelectionInterval(row,  row);
+		}
+		pack();
+	}
+}

bonus-1/src/de/hsh/dbs2/imdb/gui/SearchMovieDialogCallback.java

@@ -0,0 +1,83 @@
+package de.hsh.dbs2.imdb.gui;
+
+import java.util.ArrayList;
+
+import java.util.List;
+
+import de.hsh.dbs2.imdb.logic.GenreManager;
+import de.hsh.dbs2.imdb.logic.MovieManager;
+import de.hsh.dbs2.imdb.logic.dto.MovieDTO;
+
+public class SearchMovieDialogCallback {
+	
+	private MovieManager mm = new MovieManager();
+	private GenreManager gm = new GenreManager();
+	
+	public List<MovieDTO> runSearch(String search) {
+		List<MovieDTO> movies;
+		try {
+			movies = mm.getMovieList(search);
+		} catch (Exception e) {
+			new ShowErrorDialog("Fehler beim der Suche", e);
+			movies = new ArrayList<MovieDTO>();
+		}
+		return movies;
+	}
+
+	public void addMovie() {
+		movieDialog(null);
+	}
+
+	public void editMovie(long movieId) {
+		movieDialog(movieId);
+	}
+
+	public void deleteMovie(long movieId) {
+		try {
+			mm.deleteMovie(movieId);
+		} catch (Exception e) {
+			new ShowErrorDialog("Fehler beim Löschen des Films", e);
+		}
+	}
+
+	private void movieDialog(Long movieId) {
+
+		MovieDTO movie;
+		if (movieId == null)
+			movie = new MovieDTO();
+		else {
+			try {
+				movie = mm.getMovie(movieId);
+			} catch (Exception e) {
+				new ShowErrorDialog("Fehler beim Laden des Films", e);
+				return;
+			}
+		}
+		
+		List<String> allGenres;
+		try {
+			allGenres = gm.getGenres();
+		} catch (Exception e) {
+			new ShowErrorDialog("Fehler beim Laden der Genres", e);
+			return;
+		}
+
+		MovieDialog movieDialog = new MovieDialog(new MovieDialogCallback(), allGenres);
+		movieDialog.setMovie(movie);
+		
+		boolean finished = false;
+		while (!finished) {
+			movieDialog.setVisible(true);
+			finished = true;
+
+			if (movieDialog.getOutcome().equals("ok")) {
+				try {
+					mm.insertUpdateMovie(movie);
+				} catch (Exception e) {
+					new ShowErrorDialog("Fehler beim Speichern des Films", e);
+					finished = false;  // Movie Dialog offen halten
+				}
+			}
+		}
+	}
+}

bonus-1/src/de/hsh/dbs2/imdb/gui/ShowErrorDialog.java

@@ -0,0 +1,77 @@
+package de.hsh.dbs2.imdb.gui;
+
+import java.awt.Dimension;
+import java.awt.GridBagConstraints;
+import java.awt.GridBagLayout;
+import java.awt.Insets;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+
+import javax.swing.JButton;
+import javax.swing.JDialog;
+import javax.swing.JScrollPane;
+import javax.swing.JTextArea;
+
+public class ShowErrorDialog extends JDialog {
+	private static final long serialVersionUID = 1L;
+
+	private JTextArea txtError;
+
+	private JButton btnOk;
+	
+	public ShowErrorDialog(String msg, Exception e) {
+		
+		StringWriter sw = new StringWriter();
+		e.printStackTrace(new PrintWriter(sw));
+
+		setTitle(msg);
+		setSize(200, 200);
+		setModal(true);
+
+		GridBagLayout layout = new GridBagLayout();
+		setLayout(layout);
+
+		GridBagConstraints gbc = new GridBagConstraints();
+
+		// Festlegen, dass die GUI-Elemente die Gitterfelder in
+		// waagerechter Richtung ausfuellen:
+		gbc.fill = GridBagConstraints.BOTH;
+
+		// Die Abstaende der einzelnen GUI-Elemente zu den gedachten
+		// Gitterlinien festgelegen:
+		gbc.insets = new Insets(2, 2, 2, 2);
+
+		gbc.gridx = 0;
+		gbc.gridy = 0;
+		txtError = new JTextArea(sw.toString());
+		JScrollPane scroll = new JScrollPane(txtError);
+		scroll.setPreferredSize(new Dimension(800, 400));
+		layout.setConstraints(scroll, gbc);
+		add(scroll);
+
+
+		gbc.gridx = 0;
+		gbc.gridy = 1;
+		btnOk = new JButton("OK");
+		layout.setConstraints(btnOk, gbc);
+		add(btnOk);
+		
+		btnOk.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				setVisible(false);
+			}
+		});
+
+		this.setResizable(false);
+		this.setSize(new Dimension(800, 400));
+
+		pack();
+		
+		setLocationRelativeTo(null);
+		setVisible(true);
+	}
+
+
+}

bonus-1/src/de/hsh/dbs2/imdb/gui/TabModelCharacter.java

@@ -0,0 +1,82 @@
+package de.hsh.dbs2.imdb.gui;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.swing.table.AbstractTableModel;
+
+import de.hsh.dbs2.imdb.logic.dto.CharacterDTO;
+
+/**
+ * Tabellenmodell, welches die Daten fuer eine Tabelle mit allen Characteren
+ * eines Movies bereitstellt und verwaltet
+ */
+public class TabModelCharacter extends AbstractTableModel {
+	private static final long serialVersionUID = 1L;
+
+	private List<CharacterDTO> data;
+	private List<String> columns = new ArrayList<String>();
+
+	public TabModelCharacter(List<CharacterDTO> data) {
+		this.data = data;
+		columns.add("Character");
+		columns.add("Alias");
+		columns.add("Player");
+	}
+
+	@Override
+	public int getColumnCount() {
+		return columns.size();
+	}
+
+	@Override
+	public int getRowCount() {
+		return data.size();
+	}
+
+	@Override
+	public Object getValueAt(int row, int column) {
+		if (column == 0)
+			return data.get(row).getCharacter();
+		else if (column == 1)
+			return data.get(row).getAlias();
+		else if (column == 2)
+			return data.get(row).getPlayer();
+		return null;
+	}
+
+	@Override
+	public String getColumnName(int column) {
+		return columns.get(column);
+	}
+	
+	public List<CharacterDTO> getData() {
+		return data;
+	}
+
+	public void up(int index) {
+		if (index > 0 && index < data.size()) {
+			CharacterDTO element = data.remove(index);
+			data.add(index-1, element);
+		}
+	}
+
+	public void down(int index) {
+		if (index >= 0 && index < data.size()-1) {
+			CharacterDTO element = data.remove(index);
+			data.add(index+1, element);
+		}
+	}
+
+	public CharacterDTO getRow(int row) {
+		return data.get(row);
+	}
+
+	public void addRow(CharacterDTO row) {
+		data.add(row);		
+	}
+
+	public void deleteRow(int row) {
+		data.remove(row);
+	}
+}

bonus-1/src/de/hsh/dbs2/imdb/gui/TabModelMovie.java

@@ -0,0 +1,89 @@
+package de.hsh.dbs2.imdb.gui;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.swing.table.AbstractTableModel;
+
+import de.hsh.dbs2.imdb.logic.dto.MovieDTO;
+
+/**
+ * Tabellenmodell fuer eine Tabelle mit allen Filmen
+ */
+public class TabModelMovie extends AbstractTableModel {
+	private static final long serialVersionUID = 1L;
+
+	private List<MovieDTO> data;
+	private List<String> columns = new ArrayList<String>();
+
+	public TabModelMovie(List<MovieDTO> data) {
+		this.data = data;
+		columns.add("Id");
+		columns.add("Title");
+		columns.add("Type");
+		columns.add("Year");
+	}
+
+	@Override
+	public int getColumnCount() {
+		return columns.size();
+	}
+
+	@Override
+	public int getRowCount() {
+		return data.size();
+	}
+
+	@Override
+	public Object getValueAt(int row, int column) {
+		if (column == 0)
+			return data.get(row).getId();
+		else if (column == 1)
+			return data.get(row).getTitle();
+		else if (column == 2)
+			return data.get(row).getType();
+		else if (column == 3)
+			return data.get(row).getYear();
+		return null;
+	}
+
+	@Override
+	public String getColumnName(int column) {
+		return columns.get(column);
+	}
+	
+	public List<MovieDTO> getData() {
+		return data;
+	}
+
+	public void up(int index) {
+		if (index > 0 && index < data.size()) {
+			MovieDTO element = data.remove(index);
+			data.add(index-1, element);
+		}
+	}
+
+	public void down(int index) {
+		if (index >= 0 && index < data.size()-1) {
+			MovieDTO element = data.remove(index);
+			data.add(index+1, element);
+		}
+	}
+
+	public MovieDTO getRow(int row) {
+		return data.get(row);
+	}
+
+	public void addRow(MovieDTO row) {
+		data.add(row);		
+	}
+
+	public void deleteRow(int row) {
+		data.remove(row);
+	}
+
+	public void changeRow(int row, MovieDTO rowData) {
+		data.set(row,  rowData);
+	}
+
+}

bonus-1/src/de/hsh/dbs2/imdb/gui/TabModelPerson.java

@@ -0,0 +1,78 @@
+package de.hsh.dbs2.imdb.gui;
+
+import java.util.ArrayList;
+
+import javax.swing.table.AbstractTableModel;
+
+/**
+ * Tabellenmodell mit allen Daten fuer einen Tabelle aus Personen
+ *
+ */
+public class TabModelPerson extends AbstractTableModel {
+	private static final long serialVersionUID = 1L;
+
+	private ArrayList<String> data;
+	private ArrayList<String> columns = new ArrayList<String>();
+
+	public TabModelPerson(ArrayList<String> data) {
+		this.data = data;
+		columns.add("Name");
+	}
+
+	@Override
+	public int getColumnCount() {
+		return columns.size();
+	}
+
+	@Override
+	public int getRowCount() {
+		return data.size();
+	}
+
+	@Override
+	public Object getValueAt(int row, int column) {
+		if (column == 0)
+			return data.get(row);
+		return null;
+	}
+
+	@Override
+	public String getColumnName(int column) {
+		return columns.get(column);
+	}
+	
+	public ArrayList<String> getData() {
+		return data;
+	}
+
+	public void up(int index) {
+		if (index > 0 && index < data.size()) {
+			String element = data.remove(index);
+			data.add(index-1, element);
+		}
+	}
+
+	public void down(int index) {
+		if (index >= 0 && index < data.size()-1) {
+			String element = data.remove(index);
+			data.add(index+1, element);
+		}
+	}
+
+	public String getRow(int row) {
+		return data.get(row);
+	}
+
+	public void addRow(String row) {
+		data.add(row);		
+	}
+
+	public void deleteRow(int row) {
+		data.remove(row);
+	}
+
+	public void changeRow(int row, String rowData) {
+		data.set(row,  rowData);
+	}
+
+}

bonus-1/src/de/hsh/dbs2/imdb/logic/GenreManager.java

@@ -0,0 +1,35 @@
+package de.hsh.dbs2.imdb.logic;
+
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+import de.hsh.dbs2.imdb.records.ConnectionManager;
+import de.hsh.dbs2.imdb.records.Genre;
+
+public class GenreManager {
+
+	/**
+	 * Ermittelt eine vollstaendige Liste aller in der Datenbank abgelegten Genres
+	 * Die Genres werden alphabetisch sortiert zurueckgeliefert.
+	 * @return Alle Genre-Namen als String-Liste
+	 * @throws Exception
+	 */
+	public List<String> getGenres() throws Exception {
+		try {			
+			ArrayList<String> genres = new ArrayList<String>();
+			
+			for (Genre genre : Genre.findAll()) {
+				genres.add(genre.getGenre());
+			}
+			
+			ConnectionManager.commit();
+			return genres;
+			
+		} catch (SQLException e) {
+			ConnectionManager.rollback();
+			throw e;
+		}
+	}
+
+}

bonus-1/src/de/hsh/dbs2/imdb/logic/MovieManager.java

@@ -0,0 +1,181 @@
+package de.hsh.dbs2.imdb.logic;
+
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+import de.hsh.dbs2.imdb.logic.dto.*;
+import de.hsh.dbs2.imdb.records.ConnectionManager;
+import de.hsh.dbs2.imdb.records.Genre;
+import de.hsh.dbs2.imdb.records.Movie;
+import de.hsh.dbs2.imdb.records.MovieCharacter;
+import de.hsh.dbs2.imdb.records.MovieGenre;
+import de.hsh.dbs2.imdb.records.Person;
+
+public class MovieManager {
+
+	/**
+	 * Ermittelt alle Filme, deren Filmtitel den Suchstring enthaelt.
+	 * Wenn der String leer ist, sollen alle Filme zurueckgegeben werden.
+	 * Der Suchstring soll ohne Ruecksicht auf Gross/Kleinschreibung verarbeitet werden.
+	 * @param search Suchstring. 
+	 * @return Liste aller passenden Filme als MovieDTO
+	 * @throws Exception
+	 */
+	public List<MovieDTO> getMovieList(String search) throws Exception {
+		try {
+			ArrayList<MovieDTO> movies = new ArrayList<MovieDTO>();
+			for (Movie movie : Movie.findAll()) {
+				if (movie.getTitle().toLowerCase().indexOf(search.toLowerCase()) == -1) continue;
+				
+				MovieDTO moviedto = new MovieDTO();
+				
+				moviedto.setId(movie.getMovieID());
+				moviedto.setTitle(movie.getTitle());
+				moviedto.setType("" + movie.getType());
+				moviedto.setYear(movie.getYear());
+				
+				for (MovieGenre mg : MovieGenre.findByMovieID(movie.getMovieID())) {
+					moviedto.addGenre(Genre.findById(mg.getGenreID()).getGenre());
+				}
+				
+				for (MovieCharacter mc : MovieCharacter.findByMovieID(movie.getMovieID())) {
+					CharacterDTO characterdto = new CharacterDTO();
+					
+					characterdto.setCharacter(mc.getCharacter());
+					characterdto.setAlias(mc.getAlias());
+					characterdto.setPlayer(Person.findById(mc.getPlayedBy()).getName());
+					
+					moviedto.addCharacter(characterdto);
+				}
+				
+				movies.add(moviedto);
+			}
+			
+			ConnectionManager.commit();
+			return movies;
+		} catch (SQLException e) {
+			ConnectionManager.rollback();
+			throw e;
+		}
+			
+	}
+
+	/**
+	 * Speichert die uebergebene Version des Films neu in der Datenbank oder aktualisiert den
+	 * existierenden Film.
+	 * Dazu werden die Daten des Films selbst (Titel, Jahr, Typ) beruecksichtigt,
+	 * aber auch alle Genres, die dem Film zugeordnet sind und die Liste der Charaktere
+	 * auf den neuen Stand gebracht.
+	 * @param movie Film-Objekt mit Genres und Charakteren.
+	 * @throws Exception
+	 */
+	public void insertUpdateMovie(MovieDTO movieDTO) throws Exception {
+		try {
+			Movie movie = new Movie(
+				movieDTO.getId(),
+				movieDTO.getTitle(),
+				movieDTO.getYear(),
+				movieDTO.getType().charAt(0)
+			);
+			if (movie.getMovieID() == null) {
+				movie.insert();
+			} else {
+				movie.update();
+			}
+			for (MovieGenre genre : MovieGenre.findByMovieID(movie.getMovieID())) {
+				genre.delete();
+			}
+			for (String genreName : movieDTO.getGenres()) {
+				Genre genre = Genre.findByGenre(genreName);
+				if (genre == null) {
+					genre = new Genre(null, genreName);
+					genre.insert();
+				}
+				
+				MovieGenre mg = new MovieGenre(movie.getMovieID(), genre.getGenreID());
+				mg.insert();
+			}
+			for (MovieCharacter character : MovieCharacter.findByMovieID(movie.getMovieID())) {
+				character.delete();
+			}
+			int position = 0;
+			for (CharacterDTO characterDTO : movieDTO.getCharacters()) {
+				Person player = Person.findByName(characterDTO.getPlayer());
+				if (player == null) {
+					player = new Person(null, characterDTO.getPlayer(), 'U');
+				}
+				MovieCharacter mc = new MovieCharacter(null, characterDTO.getCharacter(), characterDTO.getAlias(), position, player.getPersonID(), movie.getMovieID());
+				mc.insert();
+				++position;
+			}
+			
+			ConnectionManager.commit();
+			
+		} catch (SQLException e) {
+			ConnectionManager.rollback();
+			throw e;
+		}
+		
+	}
+
+	/**
+	 * Loescht einen Film aus der Datenbank. Es werden auch alle abhaengigen Objekte geloescht,
+	 * d.h. alle Charaktere und alle Genre-Zuordnungen.
+	 * @param movie
+	 * @throws Exception
+	 */
+	public void deleteMovie(long movieId) throws Exception {
+		try {			
+			Movie.findById(movieId).delete();
+			ConnectionManager.commit();
+			
+		} catch (SQLException e) {
+			ConnectionManager.rollback();
+			throw e;
+		}
+	}
+
+	/**
+	 * Liefert die Daten eines einzelnen Movies zurück
+	 * @param movieId
+	 * @return
+	 * @throws Exception
+	 */
+	public MovieDTO getMovie(long movieId) throws Exception {
+		try {
+			Movie movie = Movie.findById(movieId);
+			if (movie == null) {
+				throw new Exception("Movie not found");
+			}
+			MovieDTO moviedto = new MovieDTO();
+			
+			moviedto.setId(movie.getMovieID());
+			moviedto.setTitle(movie.getTitle());
+			moviedto.setType("" + movie.getType());
+			moviedto.setYear(movie.getYear());
+			
+			for (MovieGenre mg : MovieGenre.findByMovieID(movie.getMovieID())) {
+				moviedto.addGenre(Genre.findById(mg.getGenreID()).getGenre());
+			}
+			
+			for (MovieCharacter mc : MovieCharacter.findByMovieID(movie.getMovieID())) {
+				CharacterDTO characterdto = new CharacterDTO();
+				
+				characterdto.setCharacter(mc.getCharacter());
+				characterdto.setAlias(mc.getAlias());
+				characterdto.setPlayer(Person.findById(mc.getPlayedBy()).getName());
+				
+				moviedto.addCharacter(characterdto);
+			}
+			
+			ConnectionManager.commit();
+			return moviedto;
+			
+		} catch (SQLException e) {
+			ConnectionManager.rollback();
+			throw e;
+		}
+	}
+
+}

bonus-1/src/de/hsh/dbs2/imdb/logic/PersonManager.java

@@ -0,0 +1,37 @@
+package de.hsh.dbs2.imdb.logic;
+
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+import de.hsh.dbs2.imdb.records.ConnectionManager;
+import de.hsh.dbs2.imdb.records.Person;
+
+public class PersonManager {
+
+	/**
+	 * Liefert eine Liste aller Personen, deren Name den Suchstring enthaelt.
+	 * @param text Suchstring
+	 * @return Liste mit passenden Personennamen, die in der Datenbank eingetragen sind.
+	 * @throws Exception
+	 */
+	public List<String> getPersonList(String text) throws Exception {
+		try {			
+			ArrayList<String> personen = new ArrayList<String>();
+			
+			for (Person person : Person.findAll()) {
+				if (person.getName().toLowerCase().indexOf(text.toLowerCase()) == -1) continue;
+				
+				personen.add(person.getName());
+			}
+			
+			ConnectionManager.commit();
+			return personen;
+			
+		} catch (SQLException e) {
+			ConnectionManager.rollback();
+			throw e;
+		}
+	}
+
+}

bonus-1/src/de/hsh/dbs2/imdb/logic/dto/CharacterDTO.java

@@ -0,0 +1,45 @@
+package de.hsh.dbs2.imdb.logic.dto;
+
+/**
+ * Data Transfer Object (DTO) fuer Objekte der Klasse Character
+ * Enthaelt alles noetige fuer die Kommunikation GUI <-> Geschaeftslogik.
+ */
+public class CharacterDTO {
+	private String character;
+	private String alias;
+	private String player;
+	
+	public CharacterDTO(CharacterDTO that) {
+		this.character = that.character;
+		this.player = that.player;
+		this.alias = that.alias;
+	}
+	
+	public CharacterDTO() {		
+	}
+	
+	public String getCharacter() {
+		return character;
+	}
+	
+	public void setCharacter(String character) {
+		this.character = character;
+	}
+	
+	public String getPlayer() {
+		return player;
+	}
+	
+	public void setPlayer(String player) {
+		this.player = player;
+	}
+
+	public String getAlias() {
+		return alias;
+	}
+
+	public void setAlias(String alias) {
+		this.alias = alias;
+	}
+
+}

bonus-1/src/de/hsh/dbs2/imdb/logic/dto/MovieDTO.java

@@ -0,0 +1,69 @@
+package de.hsh.dbs2.imdb.logic.dto;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * Data Transfer Object (DTO) fuer Objekte der Klasse Movie
+ * Enthaelt alles noetige fuer die Kommunikation GUI <-> Geschaeftslogik.
+ * Dazue gehoeren auch alle dem Movie zugeordneten Genres und Charaktere.
+ * Enthaelt die ID; falls es sich um einen neuen Movie handelt, der noch nicht
+ * in der Datenbank vorhanden ist, ist die ID null.
+ * @author felix
+ */
+public class MovieDTO {
+
+	private Long id = null;
+	private String title = "";
+	private String type = "C";
+	private int year = 0;
+	private Set<String> genres = new HashSet<String>();
+	private List<CharacterDTO> characters = new ArrayList<CharacterDTO>();
+	
+	public Long getId() {
+		return id;
+	}
+	public void setId(Long id) {
+		this.id = id;
+	}
+	public String getTitle() {
+		return title;
+	}
+	public void setTitle(String title) {
+		this.title = title;
+	}
+	public String getType() {
+		return type;
+	}
+	public void setType(String type) {
+		this.type = type;
+	}
+	public int getYear() {
+		return year;
+	}
+	public void setYear(int year) {
+		this.year = year;
+	}
+	
+	public void addGenre(String genre) {
+		genres.add(genre);
+	}
+	public void addCharacter(CharacterDTO cdto) {
+		characters.add(cdto);
+		
+	}
+	public Set<String> getGenres() {
+		return genres;
+	}
+	public List<CharacterDTO> getCharacters() {
+		return characters;
+	}
+	public void setCharacters(List<CharacterDTO> characters) {
+		this.characters = characters;
+	}
+	public void setGenres(Set<String> genres2) {
+		this.genres = genres2;
+	}
+}

bonus-1/src/de/hsh/dbs2/imdb/records/ActiveRecord.java

@@ -1,3 +1,4 @@
+package de.hsh.dbs2.imdb.records;
 import java.sql.SQLException;
 
 public interface ActiveRecord {

bonus-1/src/de/hsh/dbs2/imdb/records/ConnectionManager.java

@@ -1,10 +1,15 @@
+package de.hsh.dbs2.imdb.records;
 import java.sql.*;
 
+import org.sqlite.SQLiteConfig;
+
 public class ConnectionManager {
 	private static Connection connection;
 	public static void connect() {
+		SQLiteConfig config = new SQLiteConfig();
+		config.enforceForeignKeys(true);
 		try {
-			connection = DriverManager.getConnection("jdbc:sqlite:sqlite-test.db");
+			connection = DriverManager.getConnection("jdbc:sqlite:sqlite-test.db", config.toProperties());
 			connection.setAutoCommit(false);
 		} catch (SQLException e) {
 			e.printStackTrace();
@@ -21,6 +26,22 @@ public class ConnectionManager {
 	}
 	
 	public static Connection getConnection() {
+		if (connection == null) {
+			connect();
+		}
 		return connection;
 	}
+	
+	public static void commit() throws SQLException {
+		if (connection == null) {
+			connect();
+		}
+		connection.commit();
+	}
+	public static void rollback() throws SQLException {
+		if (connection == null) {
+			connect();
+		}
+		connection.rollback();
+	}
 }

bonus-1/src/de/hsh/dbs2/imdb/records/Counter.java

@@ -0,0 +1,51 @@
+package de.hsh.dbs2.imdb.records;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+public class Counter {
+	
+	private String tableName;
+	private long counter = 0;
+	
+	public Counter(String tableName, long counter) {
+		this.tableName = tableName;
+		this.counter = counter;
+	}
+	
+	public static Counter get(String tableName) throws SQLException {
+		String sql = "SELECT * FROM `Counter` WHERE `TableName`=?";
+		try (PreparedStatement ps = ConnectionManager.getConnection().prepareStatement(sql)) {
+			ps.setString(1, tableName);
+			try (ResultSet rs = ps.executeQuery()) {
+				if (!rs.isBeforeFirst()) {
+					Counter c = new Counter(tableName, 0);
+					c.insert();
+					return c;
+				}
+				return new Counter(rs.getString("TableName"), rs.getLong("Counter"));
+			}
+		}
+	}
+	
+	private void insert() throws SQLException {
+		String sql = "INSERT INTO `Counter` VALUES (?, ?);";
+		try (PreparedStatement ps = ConnectionManager.getConnection().prepareStatement(sql)) {
+			ps.setString(1,  this.tableName);
+			ps.setLong(2,  this.counter);
+			ps.executeUpdate();
+		}
+	}
+	
+	public long next() throws SQLException {
+		++this.counter;
+		String sql = "UPDATE `Counter` SET `Counter`=? WHERE `TableName`=?";
+		try (PreparedStatement ps = ConnectionManager.getConnection().prepareStatement(sql)) {
+			ps.setLong(1, this.counter);
+			ps.setString(2, this.tableName);
+			ps.executeUpdate();
+		}
+		return this.counter - 1;
+	}
+}

bonus-1/src/de/hsh/dbs2/imdb/records/Genre.java

@@ -1,15 +1,22 @@
+package de.hsh.dbs2.imdb.records;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.ArrayList;
 
 public class Genre implements ActiveRecord {
-	private long genreId;
+	private Long genreId;
 	private String genre;
 	
-	public Genre(long genreId, String genre) {
+	private static Counter counter;
+	
+	public Genre(Long genreId, String genre) throws SQLException {
 		this.genreId = genreId;
 		this.genre = genre;
+		
+		if (counter == null) {
+			counter = Counter.get("Genre");
+		}
 	}
 
 	public String getGenre() {
@@ -20,12 +27,15 @@ public class Genre implements ActiveRecord {
 		this.genre = genre;
 	}
 
-	public long getGenreID() {
+	public Long getGenreID() {
 		return genreId;
 	}
 
 	@Override
 	public void insert() throws SQLException {
+		if (this.getGenreID() == null) {
+			this.genreId = counter.next();
+		}
 		String sql = "INSERT INTO `Genre` VALUES (?, ?);";
 		try (PreparedStatement ps = ConnectionManager.getConnection().prepareStatement(sql)) {
 			ps.setLong(1,  this.genreId);
@@ -59,7 +69,7 @@ public class Genre implements ActiveRecord {
 	}
 	
 	public static ArrayList<Genre> findAll() throws SQLException {
-		String sql = "SELECT * FROM Genre";
+		String sql = "SELECT * FROM `Genre` ORDER BY `Genre` ASC";
 		ArrayList<Genre> genres = new ArrayList<Genre>();
 		try (PreparedStatement ps = ConnectionManager.getConnection().prepareStatement(sql)) {
 			try (ResultSet rs = ps.executeQuery()) {
@@ -72,11 +82,23 @@ public class Genre implements ActiveRecord {
 		return genres;
 	}
 	
-	public static Genre findById(long genreId) throws SQLException {
+	public static Genre findById(Long genreId) throws SQLException {
 		String sql = "SELECT * FROM `Genre` WHERE `GenreID`=?";
 		try (PreparedStatement ps = ConnectionManager.getConnection().prepareStatement(sql)) {
 			ps.setLong(1, genreId);
 			try (ResultSet rs = ps.executeQuery()) {
+				if (!rs.isBeforeFirst()) return null;
+				return new Genre(rs.getLong("GenreID"), rs.getString("Genre"));
+			}
+		}
+	}
+	
+	public static Genre findByGenre(String genre) throws SQLException {
+		String sql = "SELECT * FROM `Genre` WHERE `Genre`=?";
+		try (PreparedStatement ps = ConnectionManager.getConnection().prepareStatement(sql)) {
+			ps.setString(1, genre);
+			try (ResultSet rs = ps.executeQuery()) {
+				if (!rs.isBeforeFirst()) return null;
 				return new Genre(rs.getLong("GenreID"), rs.getString("Genre"));
 			}
 		}

bonus-1/src/de/hsh/dbs2/imdb/records/Main.java

@@ -0,0 +1,8 @@
+package de.hsh.dbs2.imdb.records;
+import java.sql.*;
+
+public class Main {
+	public static void main(String[] args) throws SQLException {
+		
+	}
+}

bonus-1/src/de/hsh/dbs2/imdb/records/Movie.java

@@ -1,19 +1,26 @@
+package de.hsh.dbs2.imdb.records;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.ArrayList;
 
 public class Movie implements ActiveRecord {
-	private long movieId;
+	private Long movieId;
 	private String title;
 	private int year;
 	private char type;
 	
-	public Movie(long movieId, String title, int year, char type) {
+	private static Counter counter;
+	
+	public Movie(Long movieId, String title, int year, char type) throws SQLException {
 		this.movieId = movieId;
 		this.title = title;
 		this.year = year;
 		this.type = type;
+		
+		if (counter == null) {
+			counter = Counter.get("Movie");
+		}
 	}
 
 	public String getTitle() {
@@ -40,7 +47,7 @@ public class Movie implements ActiveRecord {
 		this.type = type;
 	}
 
-	public long getMovieID() {
+	public Long getMovieID() {
 		return movieId;
 	}
 	
@@ -51,14 +58,17 @@ public class Movie implements ActiveRecord {
 
 	@Override
 	public void insert() throws SQLException {
+		if (this.getMovieID() == null) {
+			this.movieId = counter.next();
+		}
 		String sql = "INSERT INTO `Movie` VALUES (?, ?, ?, ?);";
 		try (PreparedStatement ps = ConnectionManager.getConnection().prepareStatement(sql)) {
-			ps.setLong(1,  this.movieId);
+			ps.setLong(1, this.movieId);
-			ps.setString(2,  this.title);
+			ps.setString(2, this.title);
 			ps.setInt(3, this.year);
 			ps.setString(4, "" + this.type);
 			ps.executeUpdate();
-		}		
+		}
 	}
 
 	@Override
@@ -98,11 +108,12 @@ public class Movie implements ActiveRecord {
 		return movies;
 	}
 	
-	public static Movie findById(long movieId) throws SQLException {
+	public static Movie findById(Long movieId) throws SQLException {
 		String sql = "SELECT * FROM `Movie` WHERE `MovieID`=?";
 		try (PreparedStatement ps = ConnectionManager.getConnection().prepareStatement(sql)) {
 			ps.setLong(1, movieId);
 			try (ResultSet rs = ps.executeQuery()) {
+				if (!rs.isBeforeFirst()) return null;
 				return new Movie(rs.getLong("MovieID"), rs.getString("Title"), rs.getInt("Year"), rs.getString("Type").charAt(0));
 			}
 		}

bonus-1/src/de/hsh/dbs2/imdb/records/MovieCharacter.java

@@ -1,23 +1,30 @@
+package de.hsh.dbs2.imdb.records;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.ArrayList;
 
 public class MovieCharacter implements ActiveRecord {
-	private long movCharId;
+	private Long movCharId;
 	private String character;
 	private String alias;
 	private int position;
-	private long playedBy;
+	private Long playedBy;
-	private long movieId;
+	private Long movieId;
 	
-	public MovieCharacter(long movCharId, String character, String alias, int position, long playedBy, long movieId) {
+	private static Counter counter;
+	
+	public MovieCharacter(Long movCharId, String character, String alias, int position, Long playedBy, Long movieId) throws SQLException {
 		this.movCharId = movCharId;
 		this.character = character;
 		this.alias = alias;
 		this.position = position;
 		this.playedBy = playedBy;
 		this.movieId = movieId;
+		
+		if (counter == null) {
+			counter = Counter.get("MovieCharacter");
+		}
 	}
 	
 	public String getCharacter() {
@@ -44,28 +51,31 @@ public class MovieCharacter implements ActiveRecord {
 		this.position = position;
 	}
 
-	public long getPlayedBy() {
+	public Long getPlayedBy() {
 		return playedBy;
 	}
 
-	public void setPlayedBy(long playedBy) {
+	public void setPlayedBy(Long playedBy) {
 		this.playedBy = playedBy;
 	}
 
-	public long getMovCharId() {
+	public Long getMovCharID() {
 		return movCharId;
 	}
 
-	public long getMovieId() {
+	public Long getMovieID() {
 		return movieId;
 	}
 
-	public void setMovieId(long movieId) {
+	public void setMovieID(Long movieId) {
 		this.movieId = movieId;
 	}
 
 	@Override
 	public void insert() throws SQLException {
+		if (this.getMovCharID() == null) {
+			this.movCharId = counter.next();
+		}
 		String sql = "INSERT INTO `MovieCharacter` VALUES (?, ?, ?, ?, ?, ?);";
 		try (PreparedStatement ps = ConnectionManager.getConnection().prepareStatement(sql)) {
 			ps.setLong(1,  this.movCharId);
@@ -107,7 +117,7 @@ public class MovieCharacter implements ActiveRecord {
 	}
 	
 	public static ArrayList<MovieCharacter> findAll() throws SQLException {
-		String sql = "SELECT * FROM MovieCharacter";
+		String sql = "SELECT * FROM `MovieCharacter` ORDER BY `Position`";
 		ArrayList<MovieCharacter> movieCharacters = new ArrayList<MovieCharacter>();
 		try (PreparedStatement ps = ConnectionManager.getConnection().prepareStatement(sql)) {
 			try (ResultSet rs = ps.executeQuery()) {
@@ -120,4 +130,13 @@ public class MovieCharacter implements ActiveRecord {
 		return movieCharacters;
 	}
 	
+	public static ArrayList<MovieCharacter> findByMovieID(Long movieId) throws SQLException {
+		ArrayList<MovieCharacter> mcs = new ArrayList<MovieCharacter>();
+		for (MovieCharacter mc : MovieCharacter.findAll()) {
+			if (mc.getMovieID() == movieId) {
+				mcs.add(mc);
+			}
+		}
+		return mcs;
+	}
 }

bonus-1/src/de/hsh/dbs2/imdb/records/MovieGenre.java

@@ -1,3 +1,4 @@
+package de.hsh.dbs2.imdb.records;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
@@ -12,6 +13,14 @@ public class MovieGenre implements ActiveRecord {
 		this.genreId = genreId;
 	}
 	
+	public long getMovieID() {
+		return movieId;
+	}
+
+	public long getGenreID() {
+		return genreId;
+	}
+
 	@Override
 	public String toString() {
 		return "MovieGenre: " + this.movieId + " : " + this.genreId;

bonus-1/src/de/hsh/dbs2/imdb/records/Person.java

@@ -1,18 +1,25 @@
+package de.hsh.dbs2.imdb.records;
 import java.sql.*;
 import java.util.ArrayList;
 
 public class Person implements ActiveRecord {
-	private long personId;
+	private Long personId;
 	private String name;
 	private char sex;
 	
-	public Person(long personId, String name, char sex) {
+	private static Counter counter;
+	
+	public Person(Long personId, String name, char sex) throws SQLException {
 		this.personId = personId;
 		this.name = name;
-		this.sex = sex;		
+		this.sex = sex;
+		
+		if (counter == null) {
+			counter = Counter.get("Person");
+		}
 	}
 	
-	public long getPersonID() {
+	public Long getPersonID() {
 		return personId;
 	}
 	
@@ -34,6 +41,9 @@ public class Person implements ActiveRecord {
 
 	@Override
 	public void insert() throws SQLException {
+		if (this.getPersonID() == null) {
+			this.personId = counter.next();
+		}
 		String sql = "INSERT INTO `Person` VALUES (?, ?, ?);";
 		try (PreparedStatement ps = ConnectionManager.getConnection().prepareStatement(sql)) {
 			ps.setLong(1,  this.personId);
@@ -81,11 +91,23 @@ public class Person implements ActiveRecord {
 		return personen;
 	}
 	
-	public static Person findById(long personId) throws SQLException {
+	public static Person findById(Long personId) throws SQLException {
 		String sql = "SELECT * FROM `Person` WHERE `PersonId`=?";
 		try (PreparedStatement ps = ConnectionManager.getConnection().prepareStatement(sql)) {
 			ps.setLong(1, personId);
 			try (ResultSet rs = ps.executeQuery()) {
+				if (!rs.isBeforeFirst()) return null;
+				return new Person(rs.getLong("PersonID"), rs.getString("Name"), rs.getString("Sex").charAt(0));
+			}
+		}
+	}
+
+	public static Person findByName(String name) throws SQLException {
+		String sql = "SELECT * FROM `Person` WHERE `Name`=?";
+		try (PreparedStatement ps = ConnectionManager.getConnection().prepareStatement(sql)) {
+			ps.setString(1, name);
+			try (ResultSet rs = ps.executeQuery()) {
+				if (!rs.isBeforeFirst()) return null;
 				return new Person(rs.getLong("PersonID"), rs.getString("Name"), rs.getString("Sex").charAt(0));
 			}
 		}

bonus-1/src/de/hsh/dbs2/imdb/util/DBConnection.java

@@ -0,0 +1,28 @@
+package de.hsh.dbs2.imdb.util;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+
+public class DBConnection {
+	
+	private static Connection conn;
+	
+	static {
+		conn = null;
+		try {
+			// TODO: Connection to SQLite-DB
+			conn = DriverManager.getConnection(
+					"jdbc:oracle:thin:@dboracleserv.inform.hs-hannover.de:1521:db01", "user", "pwd");
+			conn.setAutoCommit(false);
+			System.out.println("Connect durchgefuehrt ....");
+		} catch (Exception e) {
+			System.err.println("Error while connecting to database");
+			e.printStackTrace();
+			System.exit(1);
+		} 
+	}
+		
+	public static Connection getConnection() {
+		return conn;
+	}
+}