diff --git a/bonus-1/.classpath b/bonus-1/.classpath index cb52869..be05986 100644 --- a/bonus-1/.classpath +++ b/bonus-1/.classpath @@ -6,12 +6,12 @@ - + - + diff --git a/bonus-1/schema-and-data.sql b/bonus-1/schema-and-data.sql new file mode 100644 index 0000000..1ca3efa --- /dev/null +++ b/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); diff --git a/bonus-1/sqlite-test.db b/bonus-1/sqlite-test.db index 2efbbec..08f71be 100644 Binary files a/bonus-1/sqlite-test.db and b/bonus-1/sqlite-test.db differ diff --git a/bonus-1/src/.DS_Store b/bonus-1/src/.DS_Store new file mode 100644 index 0000000..27d858f Binary files /dev/null and b/bonus-1/src/.DS_Store differ diff --git a/bonus-1/src/Main.java b/bonus-1/src/Main.java deleted file mode 100644 index 63c51e6..0000000 --- a/bonus-1/src/Main.java +++ /dev/null @@ -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(); - } -} diff --git a/bonus-1/src/de/.DS_Store b/bonus-1/src/de/.DS_Store new file mode 100644 index 0000000..3370e75 Binary files /dev/null and b/bonus-1/src/de/.DS_Store differ diff --git a/bonus-1/src/de/hsh/.DS_Store b/bonus-1/src/de/hsh/.DS_Store new file mode 100644 index 0000000..f87dcb7 Binary files /dev/null and b/bonus-1/src/de/hsh/.DS_Store differ diff --git a/bonus-1/src/de/hsh/dbs2/.DS_Store b/bonus-1/src/de/hsh/dbs2/.DS_Store new file mode 100644 index 0000000..5c36e68 Binary files /dev/null and b/bonus-1/src/de/hsh/dbs2/.DS_Store differ diff --git a/bonus-1/src/de/hsh/dbs2/imdb/Starter.java b/bonus-1/src/de/hsh/dbs2/imdb/Starter.java new file mode 100644 index 0000000..6958339 --- /dev/null +++ b/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); + } + +} diff --git a/bonus-1/src/de/hsh/dbs2/imdb/gui/CharacterDialog.java b/bonus-1/src/de/hsh/dbs2/imdb/gui/CharacterDialog.java new file mode 100644 index 0000000..1bbaabd --- /dev/null +++ b/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 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(); + 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 p; + if (txtPlayer.getText().isEmpty()) { + p = new ArrayList(); + } else { + p = callback.getPersonList(txtPlayer.getText()); + } + lstPersons.setListData(p.toArray(new String[0])); + } + + +} diff --git a/bonus-1/src/de/hsh/dbs2/imdb/gui/CharacterDialogCallback.java b/bonus-1/src/de/hsh/dbs2/imdb/gui/CharacterDialogCallback.java new file mode 100644 index 0000000..a365729 --- /dev/null +++ b/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 getPersonList(String text) { + try { + List persons = pm.getPersonList(text); + return persons; + } catch (Exception e) { + JOptionPane.showMessageDialog(null, "Fehler bei der Personensuche: \n" + e.getMessage()); + e.printStackTrace(); + return null; + } + } +} diff --git a/bonus-1/src/de/hsh/dbs2/imdb/gui/MovieDialog.java b/bonus-1/src/de/hsh/dbs2/imdb/gui/MovieDialog.java new file mode 100644 index 0000000..1a8e913 --- /dev/null +++ b/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 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 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(); + 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 genres = new HashSet(); + 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); + } + } +} diff --git a/bonus-1/src/de/hsh/dbs2/imdb/gui/MovieDialogCallback.java b/bonus-1/src/de/hsh/dbs2/imdb/gui/MovieDialogCallback.java new file mode 100644 index 0000000..c89b846 --- /dev/null +++ b/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()); + } + } + +} diff --git a/bonus-1/src/de/hsh/dbs2/imdb/gui/SearchMovieDialog.java b/bonus-1/src/de/hsh/dbs2/imdb/gui/SearchMovieDialog.java new file mode 100644 index 0000000..35cc9ca --- /dev/null +++ b/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 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(); + } +} diff --git a/bonus-1/src/de/hsh/dbs2/imdb/gui/SearchMovieDialogCallback.java b/bonus-1/src/de/hsh/dbs2/imdb/gui/SearchMovieDialogCallback.java new file mode 100644 index 0000000..480a03d --- /dev/null +++ b/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 runSearch(String search) { + List movies; + try { + movies = mm.getMovieList(search); + } catch (Exception e) { + new ShowErrorDialog("Fehler beim der Suche", e); + movies = new ArrayList(); + } + 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 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 + } + } + } + } +} diff --git a/bonus-1/src/de/hsh/dbs2/imdb/gui/ShowErrorDialog.java b/bonus-1/src/de/hsh/dbs2/imdb/gui/ShowErrorDialog.java new file mode 100644 index 0000000..92fb7dd --- /dev/null +++ b/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); + } + + +} diff --git a/bonus-1/src/de/hsh/dbs2/imdb/gui/TabModelCharacter.java b/bonus-1/src/de/hsh/dbs2/imdb/gui/TabModelCharacter.java new file mode 100644 index 0000000..bcfcef7 --- /dev/null +++ b/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 data; + private List columns = new ArrayList(); + + public TabModelCharacter(List 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 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); + } +} diff --git a/bonus-1/src/de/hsh/dbs2/imdb/gui/TabModelMovie.java b/bonus-1/src/de/hsh/dbs2/imdb/gui/TabModelMovie.java new file mode 100644 index 0000000..74f4545 --- /dev/null +++ b/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 data; + private List columns = new ArrayList(); + + public TabModelMovie(List 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 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); + } + +} diff --git a/bonus-1/src/de/hsh/dbs2/imdb/gui/TabModelPerson.java b/bonus-1/src/de/hsh/dbs2/imdb/gui/TabModelPerson.java new file mode 100644 index 0000000..6c2f950 --- /dev/null +++ b/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 data; + private ArrayList columns = new ArrayList(); + + public TabModelPerson(ArrayList 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 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); + } + +} diff --git a/bonus-1/src/de/hsh/dbs2/imdb/logic/GenreManager.java b/bonus-1/src/de/hsh/dbs2/imdb/logic/GenreManager.java new file mode 100644 index 0000000..c95df78 --- /dev/null +++ b/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 getGenres() throws Exception { + try { + ArrayList genres = new ArrayList(); + + for (Genre genre : Genre.findAll()) { + genres.add(genre.getGenre()); + } + + ConnectionManager.commit(); + return genres; + + } catch (SQLException e) { + ConnectionManager.rollback(); + throw e; + } + } + +} diff --git a/bonus-1/src/de/hsh/dbs2/imdb/logic/MovieManager.java b/bonus-1/src/de/hsh/dbs2/imdb/logic/MovieManager.java new file mode 100644 index 0000000..b2c48c3 --- /dev/null +++ b/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 getMovieList(String search) throws Exception { + try { + ArrayList movies = new ArrayList(); + 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; + } + } + +} diff --git a/bonus-1/src/de/hsh/dbs2/imdb/logic/PersonManager.java b/bonus-1/src/de/hsh/dbs2/imdb/logic/PersonManager.java new file mode 100644 index 0000000..b5f0647 --- /dev/null +++ b/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 getPersonList(String text) throws Exception { + try { + ArrayList personen = new ArrayList(); + + 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; + } + } + +} diff --git a/bonus-1/src/de/hsh/dbs2/imdb/logic/dto/CharacterDTO.java b/bonus-1/src/de/hsh/dbs2/imdb/logic/dto/CharacterDTO.java new file mode 100644 index 0000000..9cc8ed2 --- /dev/null +++ b/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; + } + +} diff --git a/bonus-1/src/de/hsh/dbs2/imdb/logic/dto/MovieDTO.java b/bonus-1/src/de/hsh/dbs2/imdb/logic/dto/MovieDTO.java new file mode 100644 index 0000000..6e97bd8 --- /dev/null +++ b/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 genres = new HashSet(); + private List characters = new ArrayList(); + + 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 getGenres() { + return genres; + } + public List getCharacters() { + return characters; + } + public void setCharacters(List characters) { + this.characters = characters; + } + public void setGenres(Set genres2) { + this.genres = genres2; + } +} diff --git a/bonus-1/src/ActiveRecord.java b/bonus-1/src/de/hsh/dbs2/imdb/records/ActiveRecord.java similarity index 85% rename from bonus-1/src/ActiveRecord.java rename to bonus-1/src/de/hsh/dbs2/imdb/records/ActiveRecord.java index e647c66..f9e0936 100644 --- a/bonus-1/src/ActiveRecord.java +++ b/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 { diff --git a/bonus-1/src/ConnectionManager.java b/bonus-1/src/de/hsh/dbs2/imdb/records/ConnectionManager.java similarity index 52% rename from bonus-1/src/ConnectionManager.java rename to bonus-1/src/de/hsh/dbs2/imdb/records/ConnectionManager.java index 13e9b09..74a07d8 100644 --- a/bonus-1/src/ConnectionManager.java +++ b/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(); + } } diff --git a/bonus-1/src/de/hsh/dbs2/imdb/records/Counter.java b/bonus-1/src/de/hsh/dbs2/imdb/records/Counter.java new file mode 100644 index 0000000..0f8bc5a --- /dev/null +++ b/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; + } +} diff --git a/bonus-1/src/Genre.java b/bonus-1/src/de/hsh/dbs2/imdb/records/Genre.java similarity index 69% rename from bonus-1/src/Genre.java rename to bonus-1/src/de/hsh/dbs2/imdb/records/Genre.java index 2edb1ac..9c63463 100644 --- a/bonus-1/src/Genre.java +++ b/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 findAll() throws SQLException { - String sql = "SELECT * FROM Genre"; + String sql = "SELECT * FROM `Genre` ORDER BY `Genre` ASC"; ArrayList genres = new ArrayList(); 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")); } } diff --git a/bonus-1/src/de/hsh/dbs2/imdb/records/Main.java b/bonus-1/src/de/hsh/dbs2/imdb/records/Main.java new file mode 100644 index 0000000..13c6a9d --- /dev/null +++ b/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 { + + } +} diff --git a/bonus-1/src/Movie.java b/bonus-1/src/de/hsh/dbs2/imdb/records/Movie.java similarity index 83% rename from bonus-1/src/Movie.java rename to bonus-1/src/de/hsh/dbs2/imdb/records/Movie.java index d6a64c8..efd189e 100644 --- a/bonus-1/src/Movie.java +++ b/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.setString(2, this.title); + ps.setLong(1, this.movieId); + 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)); } } diff --git a/bonus-1/src/MovieCharacter.java b/bonus-1/src/de/hsh/dbs2/imdb/records/MovieCharacter.java similarity index 75% rename from bonus-1/src/MovieCharacter.java rename to bonus-1/src/de/hsh/dbs2/imdb/records/MovieCharacter.java index 9060c40..bc88d84 100644 --- a/bonus-1/src/MovieCharacter.java +++ b/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 movieId; + private Long playedBy; + 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 findAll() throws SQLException { - String sql = "SELECT * FROM MovieCharacter"; + String sql = "SELECT * FROM `MovieCharacter` ORDER BY `Position`"; ArrayList movieCharacters = new ArrayList(); 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 findByMovieID(Long movieId) throws SQLException { + ArrayList mcs = new ArrayList(); + for (MovieCharacter mc : MovieCharacter.findAll()) { + if (mc.getMovieID() == movieId) { + mcs.add(mc); + } + } + return mcs; + } } diff --git a/bonus-1/src/MovieGenre.java b/bonus-1/src/de/hsh/dbs2/imdb/records/MovieGenre.java similarity index 95% rename from bonus-1/src/MovieGenre.java rename to bonus-1/src/de/hsh/dbs2/imdb/records/MovieGenre.java index f034ab8..ec1a3a7 100644 --- a/bonus-1/src/MovieGenre.java +++ b/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; diff --git a/bonus-1/src/Person.java b/bonus-1/src/de/hsh/dbs2/imdb/records/Person.java similarity index 71% rename from bonus-1/src/Person.java rename to bonus-1/src/de/hsh/dbs2/imdb/records/Person.java index e994ead..0e6baf8 100644 --- a/bonus-1/src/Person.java +++ b/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)); } } diff --git a/bonus-1/src/de/hsh/dbs2/imdb/util/DBConnection.java b/bonus-1/src/de/hsh/dbs2/imdb/util/DBConnection.java new file mode 100644 index 0000000..b180e68 --- /dev/null +++ b/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; + } +}