diff --git a/03/.settings/org.eclipse.core.resources.prefs b/03/.settings/org.eclipse.core.resources.prefs new file mode 100644 index 0000000..96dfc09 --- /dev/null +++ b/03/.settings/org.eclipse.core.resources.prefs @@ -0,0 +1,7 @@ +eclipse.preferences.version=1 +encoding//src/de/dis2013/Main.java=UTF-8 +encoding//src/de/dis2013/core/ImmoService.java=UTF-8 +encoding//src/de/dis2013/data/Makler.java=UTF-8 +encoding//src/de/dis2013/menu/Menu.java=UTF-8 +encoding//src/de/dis2013/util/FormUtil.java=UTF-8 +encoding/=UTF-8 diff --git a/03/.settings/org.eclipse.jdt.core.prefs b/03/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 0000000..d81d163 --- /dev/null +++ b/03/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,12 @@ +#Fri Mar 18 13:14:09 GMT+01:00 2011 +org.eclipse.jdt.core.compiler.debug.localVariable=generate +org.eclipse.jdt.core.compiler.debug.sourceFile=generate +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=1.6 +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6 +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.source=1.6 +eclipse.preferences.version=1 diff --git a/03/src/admin.properties b/03/src/admin.properties new file mode 100644 index 0000000..f5e6f9f --- /dev/null +++ b/03/src/admin.properties @@ -0,0 +1,2 @@ +username=admin +password=geheim \ No newline at end of file diff --git a/03/src/de/dis2013/Main.java b/03/src/de/dis2013/Main.java new file mode 100644 index 0000000..0768d1e --- /dev/null +++ b/03/src/de/dis2013/Main.java @@ -0,0 +1,85 @@ +package de.dis2013; + +import de.dis2013.authentication.MaklerAuthenticator; +import de.dis2013.authentication.PropertiesFileAuthenticator; +import de.dis2013.core.ImmoService; +import de.dis2013.editor.ImmobilienEditor; +import de.dis2013.editor.MaklerEditor; +import de.dis2013.editor.PersonEditor; +import de.dis2013.editor.VertragsEditor; +import de.dis2013.menu.Menu; + +/** + * Hauptklasse, die das Hauptmenü zeigt + */ +public class Main { + private static ImmoService service; + /** + * Startet die Anwendung + */ + public static void main(String[] args) { + service = new ImmoService(); + showMainMenu(); + } + + /** + * Zeigt das Hauptmenü + */ + public static void showMainMenu() { + //Menüoptionen + final int MENU_MAKLER = 0; + final int MENU_PERSON= 1; + final int MENU_IMMO = 2; + final int MENU_VERTRAG = 3; + final int QUIT = 4; + + //Erzeuge Menü + Menu mainMenu = new Menu("Hauptmenü"); + mainMenu.addEntry("Makler-Verwaltung", MENU_MAKLER); + mainMenu.addEntry("Personen-Verwaltung", MENU_PERSON); + mainMenu.addEntry("Immobilien-Verwaltung", MENU_IMMO); + mainMenu.addEntry("Vertragsmenü", MENU_VERTRAG); + mainMenu.addEntry("Beenden", QUIT); + + //Authentifizierungsmöglichkeiten + PropertiesFileAuthenticator pfa = new PropertiesFileAuthenticator("admin.properties"); + MaklerAuthenticator ma = new MaklerAuthenticator(service); + + //Testdaten + service.addTestData(); + + //Verarbeite Eingabe + while(true) { + int response = mainMenu.show(); + + switch(response) { + case MENU_MAKLER: + if(pfa.authenticate()) { + MaklerEditor me = new MaklerEditor(service); + me.showMaklerMenu(); + } + break; + case MENU_PERSON: + if(ma.authenticate()) { + PersonEditor pe = new PersonEditor(service); + pe.showPersonMenu(); + } + break; + case MENU_IMMO: + if(ma.authenticate()) { + ImmobilienEditor ie = new ImmobilienEditor(service, ma.getLastAuthenticatedMakler()); + ie.showImmoMenu(); + } + break; + case MENU_VERTRAG: + if(ma.authenticate()) { + VertragsEditor ve = new VertragsEditor(service, ma.getLastAuthenticatedMakler()); + ve.showVertragsMenu(); + } + break; + case QUIT: + return; + } + } + } +} diff --git a/03/src/de/dis2013/authentication/Authenticator.java b/03/src/de/dis2013/authentication/Authenticator.java new file mode 100644 index 0000000..92c0b05 --- /dev/null +++ b/03/src/de/dis2013/authentication/Authenticator.java @@ -0,0 +1,13 @@ +package de.dis2013.authentication; + +/** + * Kleine Helferklasse zum Authentifizieren + */ +public interface Authenticator { + + /** + * Liest die Authentifizierungsdaten ein und gibt zurück, ob + * die Authentifikation erfolgreich war. + */ + public boolean authenticate(); +} diff --git a/03/src/de/dis2013/authentication/MaklerAuthenticator.java b/03/src/de/dis2013/authentication/MaklerAuthenticator.java new file mode 100644 index 0000000..1b54bc8 --- /dev/null +++ b/03/src/de/dis2013/authentication/MaklerAuthenticator.java @@ -0,0 +1,52 @@ +package de.dis2013.authentication; + +import de.dis2013.core.ImmoService; +import de.dis2013.data.Makler; +import de.dis2013.util.FormUtil; + +/** + * Authentifiziert einen Makler + */ +public class MaklerAuthenticator implements Authenticator { + private ImmoService service; + private Makler lastAuthenticatedMakler; + + /** + * Konstruktor + * @param service Immobilien-Service zum Auffinden des entsprechenden Maklers + */ + public MaklerAuthenticator(ImmoService service) { + this.service = service; + } + + /** + * Gibt das Makler-Objekt zum letzten erfolgreich authentisierten Makler zurück + */ + public Makler getLastAuthenticatedMakler() { + return this.lastAuthenticatedMakler; + } + + /** + * Fragt nach Makler-Login und -Passwort und überprüft die Eingabe + */ + public boolean authenticate() { + boolean ret; + + String login = FormUtil.readString("Makler-Login"); + String password = FormUtil.readPassword("Passwort"); + + Makler m = service.getMaklerByLogin(login); + + if(m == null) + ret = false; + else + ret = password.equals(m.getPasswort()); + + lastAuthenticatedMakler = m; + + if(!ret) + FormUtil.showMessage("Benutzername oder Passwort falsch!"); + + return ret; + } +} diff --git a/03/src/de/dis2013/authentication/PropertiesFileAuthenticator.java b/03/src/de/dis2013/authentication/PropertiesFileAuthenticator.java new file mode 100644 index 0000000..5a3e125 --- /dev/null +++ b/03/src/de/dis2013/authentication/PropertiesFileAuthenticator.java @@ -0,0 +1,61 @@ +package de.dis2013.authentication; + +import java.io.File; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.IOException; +import java.net.URISyntaxException; +import java.net.URL; +import java.util.Properties; + +import de.dis2013.util.FormUtil; + +/** + * Authentifiziert einen Benutzer anhand der Daten aus einer Properties-Datei. + * Die Datei muss die beiden Einträge username=... und password=... enthalten. + */ +public class PropertiesFileAuthenticator implements Authenticator { + private String username; + private String password; + + /** + * Konstruktor. + * @param propertiesFile Der Dateiname der Properties-Datei, die die + * Benutzerdaten enthält + */ + public PropertiesFileAuthenticator(String propertiesFile) { + try { + Properties properties = new Properties(); + URL url = ClassLoader.getSystemResource(propertiesFile); + FileInputStream stream = new FileInputStream(new File(url.toURI())); + properties.load(stream); + stream.close(); + + this.username = properties.getProperty("username"); + this.password = properties.getProperty("password"); + } catch (FileNotFoundException e1) { + e1.printStackTrace(); + } catch (IOException e) { + e.printStackTrace(); + } catch (URISyntaxException e) { + e.printStackTrace(); + } + } + + /** + * Fragt nach Benutzernamen und Passwort und vergleicht mit den Daten + * aus der Properties-Datei + */ + public boolean authenticate() { + String username = FormUtil.readString("Benutzername"); + String password = FormUtil.readPassword("Passwort"); + + if(this.username.equals(username) && this.password.equals(password)) { + return true; + } else { + FormUtil.showMessage("Benutzername oder Passwort falsch!"); + return false; + } + } + +} diff --git a/03/src/de/dis2013/core/ImmoService.java b/03/src/de/dis2013/core/ImmoService.java new file mode 100644 index 0000000..9293c86 --- /dev/null +++ b/03/src/de/dis2013/core/ImmoService.java @@ -0,0 +1,506 @@ +package de.dis2013.core; + +import java.util.Date; +import java.util.HashSet; +import java.util.Iterator; +import java.util.Set; + +import org.hibernate.Session; +import org.hibernate.SessionFactory; +import org.hibernate.cfg.Configuration; + +import de.dis2013.data.Haus; +import de.dis2013.data.Immobilie; +import de.dis2013.data.Kaufvertrag; +import de.dis2013.data.Makler; +import de.dis2013.data.Mietvertrag; +import de.dis2013.data.Person; +import de.dis2013.data.Wohnung; + +/** + * Klasse zur Verwaltung aller Datenbank-Entitäten. + * + * TODO: Aktuell werden alle Daten im Speicher gehalten. Ziel der Ãœbung + * ist es, schrittweise die Datenverwaltung in die Datenbank auszulagern. + * Wenn die Arbeit erledigt ist, werden alle Sets dieser Klasse überflüssig. + */ +public class ImmoService { + //Datensätze im Speicher + private Set makler = new HashSet(); + private Set personen = new HashSet(); + private Set haeuser = new HashSet(); + private Set wohnungen = new HashSet(); + private Set mietvertraege = new HashSet(); + private Set kaufvertraege = new HashSet(); + + //Hibernate Session + private SessionFactory sessionFactory; + + public ImmoService() { + sessionFactory = new Configuration().configure().buildSessionFactory(); + } + + /** + * Finde einen Makler mit gegebener Id + * @param id Die ID des Maklers + * @return Makler mit der ID oder null + */ + public Makler getMaklerById(int id) { + Iterator it = makler.iterator(); + + while(it.hasNext()) { + Makler m = it.next(); + + if(m.getId() == id) + return m; + } + + return null; + } + + /** + * Finde einen Makler mit gegebenem Login + * @param login Der Login des Maklers + * @return Makler mit der ID oder null + */ + public Makler getMaklerByLogin(String login) { + Iterator it = makler.iterator(); + + while(it.hasNext()) { + Makler m = it.next(); + + if(m.getLogin().equals(login)) + return m; + } + + return null; + } + + /** + * Gibt alle Makler zurück + */ + public Set getAllMakler() { + return makler; + } + + /** + * Finde eine Person mit gegebener Id + * @param id Die ID der Person + * @return Person mit der ID oder null + */ + public Person getPersonById(int id) { + Iterator it = personen.iterator(); + + while(it.hasNext()) { + Person p = it.next(); + + if(p.getId() == id) + return p; + } + + return null; + } + + /** + * Fügt einen Makler hinzu + * @param m Der Makler + */ + public void addMakler(Makler m) { + makler.add(m); + } + + /** + * Löscht einen Makler + * @param m Der Makler + */ + public void deleteMakler(Makler m) { + makler.remove(m); + } + + /** + * Fügt eine Person hinzu + * @param p Die Person + */ + public void addPerson(Person p) { + personen.add(p); + } + + /** + * Gibt alle Personen zurück + */ + public Set getAllPersons() { + return personen; + } + + /** + * Löscht eine Person + * @param p Die Person + */ + public void deletePerson(Person p) { + personen.remove(p); + } + + /** + * Fügt ein Haus hinzu + * @param h Das Haus + */ + public void addHaus(Haus h) { + haeuser.add(h); + } + + /** + * Gibt alle Häuser eines Maklers zurück + * @param m Der Makler + * @return Alle Häuser, die vom Makler verwaltet werden + */ + public Set getAllHaeuserForMakler(Makler m) { + Set ret = new HashSet(); + Iterator it = haeuser.iterator(); + + while(it.hasNext()) { + Haus h = it.next(); + + if(h.getVerwalter().equals(m)) + ret.add(h); + } + + return ret; + } + + /** + * Findet ein Haus mit gegebener ID + * @param m Der Makler + * @return Das Haus oder null, falls nicht gefunden + */ + public Haus getHausById(int id) { + Iterator it = haeuser.iterator(); + + while(it.hasNext()) { + Haus h = it.next(); + + if(h.getId() == id) + return h; + } + + return null; + } + + /** + * Löscht ein Haus + * @param p Das Haus + */ + public void deleteHouse(Haus h) { + haeuser.remove(h); + } + + /** + * Fügt eine Wohnung hinzu + * @param w die Wohnung + */ + public void addWohnung(Wohnung w) { + wohnungen.add(w); + } + + /** + * Gibt alle Wohnungen eines Maklers zurück + * @param m Der Makler + * @return Alle Wohnungen, die vom Makler verwaltet werden + */ + public Set getAllWohnungenForMakler(Makler m) { + Set ret = new HashSet(); + Iterator it = wohnungen.iterator(); + + while(it.hasNext()) { + Wohnung w = it.next(); + + if(w.getVerwalter().equals(m)) + ret.add(w); + } + + return ret; + } + + /** + * Findet eine Wohnung mit gegebener ID + * @param id Die ID + * @return Die Wohnung oder null, falls nicht gefunden + */ + public Wohnung getWohnungById(int id) { + Iterator it = wohnungen.iterator(); + + while(it.hasNext()) { + Wohnung w = it.next(); + + if(w.getId() == id) + return w; + } + + return null; + } + + /** + * Löscht eine Wohnung + * @param p Die Wohnung + */ + public void deleteWohnung(Wohnung w) { + wohnungen.remove(w); + } + + + /** + * Fügt einen Mietvertrag hinzu + * @param w Der Mietvertrag + */ + public void addMietvertrag(Mietvertrag m) { + mietvertraege.add(m); + } + + /** + * Fügt einen Kaufvertrag hinzu + * @param w Der Kaufvertrag + */ + public void addKaufvertrag(Kaufvertrag k) { + kaufvertraege.add(k); + } + + /** + * Gibt alle Mietverträge zu Wohnungen eines Maklers zurück + * @param m Der Makler + * @return Alle Mietverträge, die zu Wohnungen gehören, die vom Makler verwaltet werden + */ + public Set getAllMietvertraegeForMakler(Makler m) { + Set ret = new HashSet(); + Iterator it = mietvertraege.iterator(); + + while(it.hasNext()) { + Mietvertrag v = it.next(); + + if(v.getWohnung().getVerwalter().equals(m)) + ret.add(v); + } + + return ret; + } + + /** + * Gibt alle Kaufverträge zu Wohnungen eines Maklers zurück + * @param m Der Makler + * @return Alle Kaufverträge, die zu Häusern gehören, die vom Makler verwaltet werden + */ + public Set getAllKaufvertraegeForMakler(Makler m) { + Set ret = new HashSet(); + Iterator it = kaufvertraege.iterator(); + + while(it.hasNext()) { + Kaufvertrag k = it.next(); + + if(k.getHaus().getVerwalter().equals(m)) + ret.add(k); + } + + return ret; + } + + /** + * Findet einen Mietvertrag mit gegebener ID + * @param id Die ID + * @return Der Mietvertrag oder null, falls nicht gefunden + */ + public Mietvertrag getMietvertragById(int id) { + Iterator it = mietvertraege.iterator(); + + while(it.hasNext()) { + Mietvertrag m = it.next(); + + if(m.getId() == id) + return m; + } + + return null; + } + + /** + * Findet alle Mietverträge, die Wohnungen eines gegebenen Verwalters betreffen + * @param id Der Verwalter + * @return Set aus Mietverträgen + */ + public Set getMietvertragByVerwalter(Makler m) { + Set ret = new HashSet(); + Iterator it = mietvertraege.iterator(); + + while(it.hasNext()) { + Mietvertrag mv = it.next(); + + if(mv.getWohnung().getVerwalter().getId() == m.getId()) + ret.add(mv); + } + + return ret; + } + + /** + * Findet alle Kaufverträge, die Häuser eines gegebenen Verwalters betreffen + * @param id Der Verwalter + * @return Set aus Kaufverträgen + */ + public Set getKaufvertragByVerwalter(Makler m) { + Set ret = new HashSet(); + Iterator it = kaufvertraege.iterator(); + + while(it.hasNext()) { + Kaufvertrag k = it.next(); + + if(k.getHaus().getVerwalter().getId() == m.getId()) + ret.add(k); + } + + return ret; + } + + /** + * Findet einen Kaufvertrag mit gegebener ID + * @param id Die ID + * @return Der Kaufvertrag oder null, falls nicht gefunden + */ + public Kaufvertrag getKaufvertragById(int id) { + Iterator it = kaufvertraege.iterator(); + + while(it.hasNext()) { + Kaufvertrag k = it.next(); + + if(k.getId() == id) + return k; + } + + return null; + } + + /** + * Löscht einen Mietvertrag + * @param m Der Mietvertrag + */ + public void deleteMietvertrag(Mietvertrag m) { + wohnungen.remove(m); + } + + /** + * Fügt einige Testdaten hinzu + */ + public void addTestData() { + //Hibernate Session erzeugen + Session session = sessionFactory.openSession(); + + session.beginTransaction(); + + Makler m = new Makler(); + m.setName("Max Mustermann"); + m.setAdresse("Am Informatikum 9"); + m.setLogin("max"); + m.setPasswort("max"); + + //TODO: Dieser Makler wird im Speicher und der DB gehalten + this.addMakler(m); + session.save(m); + session.getTransaction().commit(); + + session.beginTransaction(); + + Person p1 = new Person(); + p1.setAdresse("Informatikum"); + p1.setNachname("Mustermann"); + p1.setVorname("Erika"); + + + Person p2 = new Person(); + p2.setAdresse("Reeperbahn 9"); + p2.setNachname("Albers"); + p2.setVorname("Hans"); + + session.save(p1); + session.save(p2); + + //TODO: Diese Personen werden im Speicher und der DB gehalten + this.addPerson(p1); + this.addPerson(p2); + session.getTransaction().commit(); + + //Hibernate Session erzeugen + session.beginTransaction(); + Haus h = new Haus(); + h.setOrt("Hamburg"); + h.setPlz(22527); + h.setStrasse("Vogt-Kölln-Straße"); + h.setHausnummer("2a"); + h.setFlaeche(384); + h.setStockwerke(5); + h.setKaufpreis(10000000); + h.setGarten(true); + h.setVerwalter(m); + + session.save(h); + + //TODO: Dieses Haus wird im Speicher und der DB gehalten + this.addHaus(h); + session.getTransaction().commit(); + + //Hibernate Session erzeugen + session = sessionFactory.openSession(); + session.beginTransaction(); + Makler m2 = (Makler)session.get(Makler.class, m.getId()); + Set immos = m2.getImmobilien(); + Iterator it = immos.iterator(); + + while(it.hasNext()) { + Immobilie i = it.next(); + System.out.println("Immo: "+i.getOrt()); + } + session.close(); + + Wohnung w = new Wohnung(); + w.setOrt("Hamburg"); + w.setPlz(22527); + w.setStrasse("Vogt-Kölln-Straße"); + w.setHausnummer("3"); + w.setFlaeche(120); + w.setStockwerk(4); + w.setMietpreis(790); + w.setEbk(true); + w.setBalkon(false); + w.setVerwalter(m); + this.addWohnung(w); + + w = new Wohnung(); + w.setOrt("Berlin"); + w.setPlz(22527); + w.setStrasse("Vogt-Kölln-Straße"); + w.setHausnummer("3"); + w.setFlaeche(120); + w.setStockwerk(4); + w.setMietpreis(790); + w.setEbk(true); + w.setBalkon(false); + w.setVerwalter(m); + this.addWohnung(w); + + Kaufvertrag kv = new Kaufvertrag(); + kv.setHaus(h); + kv.setVertragspartner(p1); + kv.setVertragsnummer(9234); + kv.setDatum(new Date(System.currentTimeMillis())); + kv.setOrt("Hamburg"); + kv.setAnzahlRaten(5); + kv.setRatenzins(4); + this.addKaufvertrag(kv); + + Mietvertrag mv = new Mietvertrag(); + mv.setWohnung(w); + mv.setVertragspartner(p2); + mv.setVertragsnummer(23112); + mv.setDatum(new Date(System.currentTimeMillis()-1000000000)); + mv.setOrt("Berlin"); + mv.setMietbeginn(new Date(System.currentTimeMillis())); + mv.setNebenkosten(65); + mv.setDauer(36); + this.addMietvertrag(mv); + } +} diff --git a/03/src/de/dis2013/data/Haus.java b/03/src/de/dis2013/data/Haus.java new file mode 100644 index 0000000..40f52ec --- /dev/null +++ b/03/src/de/dis2013/data/Haus.java @@ -0,0 +1,71 @@ +package de.dis2013.data; + +import de.dis2013.util.Helper; + +/** + * Haus-Bean + */ +public class Haus extends Immobilie { + private int stockwerke; + private int kaufpreis; + private boolean garten; + + public Haus() { + super(); + } + + public int getStockwerke() { + return stockwerke; + } + public void setStockwerke(int stockwerke) { + this.stockwerke = stockwerke; + } + public int getKaufpreis() { + return kaufpreis; + } + public void setKaufpreis(int kaufpreis) { + this.kaufpreis = kaufpreis; + } + public boolean isGarten() { + return garten; + } + public void setGarten(boolean garten) { + this.garten = garten; + } + + public int hashCode() { + final int prime = 31; + int result = super.hashCode(); + + result = prime * result + getStockwerke(); + result = prime * result + getKaufpreis(); + result = prime * result + ((isGarten()) ? 1 : 0); + + return result; + } + + public boolean equals(Object obj) { + if (this == obj) + return true; + + if (obj == null || !(obj instanceof Haus)) + return false; + + Haus other = (Haus)obj; + + if(other.getId() != getId() || + other.getPlz() != getPlz() || + other.getFlaeche() != getFlaeche() || + !Helper.compareObjects(this.getOrt(), other.getOrt()) || + !Helper.compareObjects(this.getStrasse(), other.getStrasse()) || + !Helper.compareObjects(this.getHausnummer(), other.getHausnummer()) || + getStockwerke() != other.getStockwerke() || + getKaufpreis() != other.getKaufpreis() || + isGarten() != other.isGarten()) + { + return false; + } + + return true; + } +} diff --git a/03/src/de/dis2013/data/Immobilie.java b/03/src/de/dis2013/data/Immobilie.java new file mode 100644 index 0000000..102c846 --- /dev/null +++ b/03/src/de/dis2013/data/Immobilie.java @@ -0,0 +1,99 @@ +package de.dis2013.data; + +import de.dis2013.util.Helper; + +/** + * Immobilien-Bean + */ +public abstract class Immobilie { + private int id = -1; + private String ort; + private int plz; + private String strasse; + private String hausnummer; + private int flaeche; + private Makler verwalter; + static int currentId = 0; + + public Immobilie() { + this.id = currentId++; + } + + public int getId() { + return id; + } + public void setId(int id) { + this.id = id; + } + public String getOrt() { + return ort; + } + public void setOrt(String ort) { + this.ort = ort; + } + public int getPlz() { + return plz; + } + public void setPlz(int plz) { + this.plz = plz; + } + public String getStrasse() { + return strasse; + } + public void setStrasse(String strasse) { + this.strasse = strasse; + } + public String getHausnummer() { + return hausnummer; + } + public void setHausnummer(String hausnummer) { + this.hausnummer = hausnummer; + } + public int getFlaeche() { + return flaeche; + } + public void setFlaeche(int flaeche) { + this.flaeche = flaeche; + } + + public void setVerwalter(Makler verwalter) { + this.verwalter = verwalter; + } + + public Makler getVerwalter() { + return verwalter; + } + + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((getOrt() == null) ? 0 : getOrt().hashCode()); + result = prime * result + ((getStrasse() == null) ? 0 : getStrasse().hashCode()); + result = prime * result + ((getHausnummer() == null) ? 0 : getHausnummer().hashCode()); + + return result; + } + + public boolean equals(Object obj) { + if (this == obj) + return true; + + if (obj == null || !(obj instanceof Immobilie)) + return false; + + Immobilie other = (Immobilie)obj; + + if(other.getId() != getId() || + other.getPlz() != getPlz() || + other.getFlaeche() != getFlaeche() || + !Helper.compareObjects(this.getOrt(), other.getOrt()) || + !Helper.compareObjects(this.getStrasse(), other.getStrasse()) || + !Helper.compareObjects(this.getHausnummer(), other.getHausnummer())) + { + return false; + } + + return true; + } +} diff --git a/03/src/de/dis2013/data/Kaufvertrag.java b/03/src/de/dis2013/data/Kaufvertrag.java new file mode 100644 index 0000000..b953697 --- /dev/null +++ b/03/src/de/dis2013/data/Kaufvertrag.java @@ -0,0 +1,68 @@ +package de.dis2013.data; + +import de.dis2013.util.Helper; + +/** + * Kaufvertrags-Bean + */ +public class Kaufvertrag extends Vertrag { + private int anzahlRaten; + private int ratenzins; + private Haus haus; + + public Kaufvertrag() { + super(); + } + + public int getAnzahlRaten() { + return anzahlRaten; + } + public void setAnzahlRaten(int anzahlRaten) { + this.anzahlRaten = anzahlRaten; + } + public int getRatenzins() { + return ratenzins; + } + public void setRatenzins(int ratenzins) { + this.ratenzins = ratenzins; + } + + public Haus getHaus() { + return haus; + } + + public void setHaus(Haus haus) { + this.haus = haus; + } + + public int hashCode() { + final int prime = 31; + int result = super.hashCode(); + + result = prime * result + getAnzahlRaten(); + result = prime * result + getRatenzins(); + + return result; + } + + public boolean equals(Object obj) { + if (this == obj) + return true; + + if (obj == null || !(obj instanceof Kaufvertrag)) + return false; + + Kaufvertrag other = (Kaufvertrag)obj; + + if(other.getVertragsnummer() != getVertragsnummer() || + !Helper.compareObjects(this.getDatum(), other.getDatum()) || + !Helper.compareObjects(this.getOrt(), other.getOrt()) || + other.getAnzahlRaten() != getAnzahlRaten() || + other.getRatenzins() != getRatenzins()) + { + return false; + } + + return true; + } +} diff --git a/03/src/de/dis2013/data/Makler.java b/03/src/de/dis2013/data/Makler.java new file mode 100644 index 0000000..a3c02b5 --- /dev/null +++ b/03/src/de/dis2013/data/Makler.java @@ -0,0 +1,102 @@ +package de.dis2013.data; + +import java.util.Set; + +import de.dis2013.util.Helper; + +/** + * Makler-Bean + */ +public class Makler { + private int id; + private String name; + private String adresse; + private String login; + private String passwort; + static int currentId = 0; + private Set immobilien; + + public Makler() { + } + + public int getId() { + return id; + } + + public void setId(int id) { + this.id = id; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getAdresse() { + return adresse; + } + + public void setAdresse(String adresse) { + this.adresse = adresse; + } + + public String getLogin() { + return login; + } + + public void setLogin(String login) { + this.login = login; + } + + public String getPasswort() { + return passwort; + } + + public void setPasswort(String passwort) { + this.passwort = passwort; + } + + public Set getImmobilien() { + return immobilien; + } + + public void setImmobilien(Set immobilien) { + this.immobilien = immobilien; + } + + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((getName() == null) ? 0 : getName().hashCode()); + result = prime * result + ((getAdresse() == null) ? 0 : getAdresse().hashCode()); + result = prime * result + ((getLogin() == null) ? 0 : getLogin().hashCode()); + result = prime * result + ((getPasswort() == null) ? 0 : getPasswort().hashCode()); + + return result; + } + + public boolean equals(Object obj) { + if (this == obj) + return true; + + if (obj == null || !(obj instanceof Makler)) + return false; + + Makler other = (Makler)obj; + + if(other.getId() != getId() || + !Helper.compareObjects(getName(), other.getName()) || + !Helper.compareObjects(getAdresse(), other.getAdresse()) || + !Helper.compareObjects(getLogin(), other.getLogin()) || + !Helper.compareObjects(getPasswort(), other.getPasswort())) + { + return false; + } + + return true; + } +} diff --git a/03/src/de/dis2013/data/Mietvertrag.java b/03/src/de/dis2013/data/Mietvertrag.java new file mode 100644 index 0000000..81d0150 --- /dev/null +++ b/03/src/de/dis2013/data/Mietvertrag.java @@ -0,0 +1,79 @@ +package de.dis2013.data; + +import java.util.Date; + +import de.dis2013.util.Helper; + +/** + * Mietvertrags-Bean + */ +public class Mietvertrag extends Vertrag { + private Date mietbeginn; + private int dauer; + private int nebenkosten; + private Wohnung wohnung; + + public Mietvertrag() { + super(); + } + + public Date getMietbeginn() { + return mietbeginn; + } + public void setMietbeginn(Date mietbeginn) { + this.mietbeginn = mietbeginn; + } + public int getDauer() { + return dauer; + } + public void setDauer(int dauer) { + this.dauer = dauer; + } + public int getNebenkosten() { + return nebenkosten; + } + public void setNebenkosten(int nebenkosten) { + this.nebenkosten = nebenkosten; + } + + public Wohnung getWohnung() { + return wohnung; + } + + public void setWohnung(Wohnung wohnung) { + this.wohnung = wohnung; + } + + public int hashCode() { + final int prime = 31; + int result = super.hashCode(); + + result = prime * result + ((getMietbeginn() == null) ? 0 : getMietbeginn().hashCode()); + result = prime * result + getDauer(); + result = prime * result + getNebenkosten(); + + return result; + } + + public boolean equals(Object obj) { + if (this == obj) + return true; + + if (obj == null || !(obj instanceof Mietvertrag)) + return false; + + Mietvertrag other = (Mietvertrag)obj; + + if(other.getVertragsnummer() != getVertragsnummer() || + !Helper.compareObjects(this.getDatum(), other.getDatum()) || + !Helper.compareObjects(this.getOrt(), other.getOrt()) || + other.getDauer() != getDauer() || + other.getNebenkosten() != getNebenkosten() || + !Helper.compareObjects(other.getMietbeginn(), getMietbeginn())) + { + return false; + } + + return true; + } +} diff --git a/03/src/de/dis2013/data/Person.java b/03/src/de/dis2013/data/Person.java new file mode 100644 index 0000000..a3cf8e1 --- /dev/null +++ b/03/src/de/dis2013/data/Person.java @@ -0,0 +1,72 @@ +package de.dis2013.data; + +import de.dis2013.util.Helper; + +/** + * Personen-Bean + */ +public class Person { + private int id; + private String vorname; + private String nachname; + private String adresse; + + public Person() { + } + + public int getId() { + return id; + } + public void setId(int id) { + this.id = id; + } + public String getVorname() { + return vorname; + } + public void setVorname(String vorname) { + this.vorname = vorname; + } + public String getNachname() { + return nachname; + } + public void setNachname(String nachname) { + this.nachname = nachname; + } + public String getAdresse() { + return adresse; + } + public void setAdresse(String adresse) { + this.adresse = adresse; + } + + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((getVorname() == null) ? 0 : getVorname().hashCode()); + result = prime * result + ((getNachname() == null) ? 0 : getNachname().hashCode()); + result = prime * result + ((getAdresse() == null) ? 0 : getAdresse().hashCode()); + + return result; + } + + public boolean equals(Object obj) { + if (this == obj) + return true; + + if (obj == null || !(obj instanceof Person)) + return false; + + Person other = (Person)obj; + + if(other.getId() != getId() || + !Helper.compareObjects(this.getVorname(), other.getVorname()) || + !Helper.compareObjects(this.getNachname(), other.getNachname()) || + !Helper.compareObjects(this.getAdresse(), other.getAdresse())) + { + return false; + } + + return true; + } +} diff --git a/03/src/de/dis2013/data/Vertrag.java b/03/src/de/dis2013/data/Vertrag.java new file mode 100644 index 0000000..9dfebb2 --- /dev/null +++ b/03/src/de/dis2013/data/Vertrag.java @@ -0,0 +1,85 @@ +package de.dis2013.data; + +import java.util.Date; + +import de.dis2013.util.Helper; + +/** + * Vertrags-Bean + */ +public abstract class Vertrag { + private int vertragsnummer = -1; + private Date datum; + private String ort; + static int currentId = 0; + int id; + Person vertragspartner; + + public Vertrag() { + this.id = currentId++; + } + + public int getVertragsnummer() { + return vertragsnummer; + } + public void setVertragsnummer(int vertragsnummer) { + this.vertragsnummer = vertragsnummer; + } + public Date getDatum() { + return datum; + } + public void setDatum(Date datum) { + this.datum = datum; + } + public String getOrt() { + return ort; + } + public void setOrt(String ort) { + this.ort = ort; + } + + public int getId() { + return id; + } + + public void setId(int id) { + this.id = id; + } + + public Person getVertragspartner() { + return vertragspartner; + } + + public void setVertragspartner(Person vertragspartner) { + this.vertragspartner = vertragspartner; + } + + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((getDatum() == null) ? 0 : getDatum().hashCode()); + result = prime * result + ((getOrt() == null) ? 0 : getOrt().hashCode()); + + return result; + } + + public boolean equals(Object obj) { + if (this == obj) + return true; + + if (obj == null || !(obj instanceof Vertrag)) + return false; + + Vertrag other = (Vertrag)obj; + + if(other.getVertragsnummer() != getVertragsnummer() || + !Helper.compareObjects(this.getDatum(), other.getDatum()) || + !Helper.compareObjects(this.getOrt(), other.getOrt())) + { + return false; + } + + return true; + } +} diff --git a/03/src/de/dis2013/data/Wohnung.java b/03/src/de/dis2013/data/Wohnung.java new file mode 100644 index 0000000..f40167c --- /dev/null +++ b/03/src/de/dis2013/data/Wohnung.java @@ -0,0 +1,90 @@ +package de.dis2013.data; + +import de.dis2013.util.Helper; + + +/** + * Wohnungs-Bean + */ +public class Wohnung extends Immobilie { + private int stockwerk; + private int mietpreis; + private int zimmer; + private boolean balkon; + private boolean ebk; + + public Wohnung() { + super(); + } + + public int getStockwerk() { + return stockwerk; + } + public void setStockwerk(int stockwerk) { + this.stockwerk = stockwerk; + } + public int getMietpreis() { + return mietpreis; + } + public void setMietpreis(int mietpreis) { + this.mietpreis = mietpreis; + } + public int getZimmer() { + return zimmer; + } + public void setZimmer(int zimmer) { + this.zimmer = zimmer; + } + public boolean isBalkon() { + return balkon; + } + public void setBalkon(boolean balkon) { + this.balkon = balkon; + } + public boolean isEbk() { + return ebk; + } + public void setEbk(boolean ebk) { + this.ebk = ebk; + } + + public int hashCode() { + final int prime = 31; + int result = super.hashCode(); + + result = prime * result + getStockwerk(); + result = prime * result + getMietpreis(); + result = prime * result + getZimmer(); + result = prime * result + ((isBalkon()) ? 1 : 0); + result = prime * result + ((isEbk()) ? 1 : 0); + + return result; + } + + public boolean equals(Object obj) { + if (this == obj) + return true; + + if (obj == null || !(obj instanceof Wohnung)) + return false; + + Wohnung other = (Wohnung)obj; + + if(other.getId() != getId() || + other.getPlz() != getPlz() || + other.getFlaeche() != getFlaeche() || + !Helper.compareObjects(this.getOrt(), other.getOrt()) || + !Helper.compareObjects(this.getStrasse(), other.getStrasse()) || + !Helper.compareObjects(this.getHausnummer(), other.getHausnummer()) || + getStockwerk() != other.getStockwerk() || + getMietpreis() != other.getMietpreis() || + getZimmer() != other.getZimmer() || + isBalkon() != other.isBalkon() || + isEbk() != other.isEbk()) + { + return false; + } + + return true; + } +} diff --git a/03/src/de/dis2013/data/mapping/Immobilie.hbm.xml b/03/src/de/dis2013/data/mapping/Immobilie.hbm.xml new file mode 100644 index 0000000..11369b0 --- /dev/null +++ b/03/src/de/dis2013/data/mapping/Immobilie.hbm.xml @@ -0,0 +1,23 @@ + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/03/src/de/dis2013/data/mapping/Makler.hbm.xml b/03/src/de/dis2013/data/mapping/Makler.hbm.xml new file mode 100644 index 0000000..f793c1f --- /dev/null +++ b/03/src/de/dis2013/data/mapping/Makler.hbm.xml @@ -0,0 +1,20 @@ + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/03/src/de/dis2013/data/mapping/Person.hbm.xml b/03/src/de/dis2013/data/mapping/Person.hbm.xml new file mode 100644 index 0000000..3394181 --- /dev/null +++ b/03/src/de/dis2013/data/mapping/Person.hbm.xml @@ -0,0 +1,14 @@ + + + + + + + + + + + + \ No newline at end of file diff --git a/03/src/de/dis2013/editor/ImmobilienEditor.java b/03/src/de/dis2013/editor/ImmobilienEditor.java new file mode 100644 index 0000000..3796b88 --- /dev/null +++ b/03/src/de/dis2013/editor/ImmobilienEditor.java @@ -0,0 +1,271 @@ +package de.dis2013.editor; + +import java.util.Set; + +import de.dis2013.core.ImmoService; +import de.dis2013.data.Haus; +import de.dis2013.data.Makler; +import de.dis2013.data.Wohnung; +import de.dis2013.menu.AppartmentSelectionMenu; +import de.dis2013.menu.HouseSelectionMenu; +import de.dis2013.menu.Menu; +import de.dis2013.util.FormUtil; + +/** + * Klasse für die Menüs zur Verwaltung von Immobilien + */ +public class ImmobilienEditor { + ///Immobilienservice, der genutzt werden soll + private ImmoService service; + + ///Wird als Verwalter für die Immobilien eingetragen + private Makler verwalter; + + public ImmobilienEditor(ImmoService service, Makler verwalter) { + this.service = service; + this.verwalter = verwalter; + } + + /** + * Zeigt das Immobilien-Hauptmenü + */ + public void showImmoMenu() { + //Menüoptionen + final int NEW_HOUSE = 0; + final int EDIT_HOUSE = 1; + final int DELETE_HOUSE = 2; + final int NEW_APPARTMENT = 3; + final int EDIT_APPARTMENT = 4; + final int DELETE_APPARTMENT = 5; + final int BACK = 6; + + //Immobilienverwaltungsmenü + Menu maklerMenu = new Menu("Immobilien-Verwaltung"); + maklerMenu.addEntry("Neues Haus anlegen", NEW_HOUSE); + maklerMenu.addEntry("Haus bearbeiten", EDIT_HOUSE); + maklerMenu.addEntry("Haus löschen", DELETE_HOUSE); + + maklerMenu.addEntry("Neue Wohnung anlegen", NEW_APPARTMENT); + maklerMenu.addEntry("Wohnung bearbeiten", EDIT_APPARTMENT); + maklerMenu.addEntry("Wohnung löschen", DELETE_APPARTMENT); + + maklerMenu.addEntry("Zurück zum Hauptmenü", BACK); + + //Verarbeite Eingabe + while(true) { + int response = maklerMenu.show(); + + switch(response) { + case NEW_HOUSE: + newHouse(); + break; + case EDIT_HOUSE: + editHouse(); + break; + case DELETE_HOUSE: + deleteHouse(); + break; + case NEW_APPARTMENT: + newAppartment(); + break; + case EDIT_APPARTMENT: + editAppartment(); + break; + case DELETE_APPARTMENT: + deleteAppartment(); + break; + case BACK: + return; + } + } + } + + /** + * Abfrage der Daten für ein neues Haus + */ + public void newHouse() { + Haus h = new Haus(); + + h.setOrt(FormUtil.readString("Ort")); + h.setPlz(FormUtil.readInt("PLZ")); + h.setStrasse(FormUtil.readString("Straße")); + h.setHausnummer(FormUtil.readString("Hausnummer")); + h.setFlaeche(FormUtil.readInt("Fläche")); + h.setStockwerke(FormUtil.readInt("Stockwerke")); + h.setKaufpreis(FormUtil.readInt("Kaufpreis")); + h.setGarten(FormUtil.readBoolean("Garten")); + h.setVerwalter(this.verwalter); + + service.addHaus(h); + } + + /** + * Lässt den Benutzer ein Haus zum bearbeiten auswählen + * und fragt anschließend die neuen Daten ab. + */ + public void editHouse() { + //Alle Häuser suchen, die vom Makler verwaltet werden + Set haeuser = service.getAllHaeuserForMakler(verwalter); + + //Auswahlmenü für das zu bearbeitende Haus + HouseSelectionMenu hsm = new HouseSelectionMenu("Liste der verwalteten Häuser", haeuser); + int id = hsm.show(); + + //Falls nicht der Eintrag "zurück" gewählt wurde, Haus bearbeiten + if(id != HouseSelectionMenu.BACK) { + //Gewähltes Haus laden + Haus h = service.getHausById(id); + + System.out.println("Haus "+h.getStrasse()+" "+h.getHausnummer()+", "+h.getPlz()+" "+h.getOrt()+" wird bearbeitet. Leere Felder bzw. Eingabe von 0 lässt Feld unverändert."); + + //Neue Daten abfragen + String newOrt = FormUtil.readString("Ort ("+h.getOrt()+")"); + int newPlz = FormUtil.readInt("PLZ ("+h.getPlz()+")"); + String newStrasse = FormUtil.readString("Straße ("+h.getStrasse()+")"); + String newHausNummer = FormUtil.readString("Hausnummer ("+h.getHausnummer()+")"); + int newFlaeche = FormUtil.readInt("Fläche ("+h.getFlaeche()+")"); + int newStockwerke = FormUtil.readInt("Stockwerke ("+h.getStockwerke()+")"); + int newKaufpreis = FormUtil.readInt("Kaufpreis ("+h.getKaufpreis()+")"); + boolean newGarten = FormUtil.readBoolean("Garten ("+(h.isGarten() ? "j" : "n")+")"); + + //Neue Daten setzen + if(!newOrt.equals("")) + h.setOrt(newOrt); + + if(!newStrasse.equals("")) + h.setStrasse(newStrasse); + + if(!newHausNummer.equals("")) + h.setHausnummer(newHausNummer); + + if(newPlz != 0) + h.setPlz(newPlz); + + if(newFlaeche != 0) + h.setFlaeche(newFlaeche); + + if(newStockwerke != 0) + h.setStockwerke(newStockwerke); + + if(newKaufpreis != 0) + h.setKaufpreis(newKaufpreis); + + h.setGarten(newGarten); + } + } + + /** + * Zeigt die Liste von verwalteten Häusern und löscht das + * entsprechende Haus nach Auswahl + */ + public void deleteHouse() { + //Alle Häuser suchen, die vom Makler verwaltet werden + Set haeuser = service.getAllHaeuserForMakler(verwalter); + + //Auswahlmenü für das zu bearbeitende Haus + HouseSelectionMenu hsm = new HouseSelectionMenu("Liste der verwalteten Häuser", haeuser); + int id = hsm.show(); + + //Falls nicht der Eintrag "zurück" gewählt wurde, Haus löschen + if(id != HouseSelectionMenu.BACK) { + Haus h = service.getHausById(id); + service.deleteHouse(h); + } + } + + /** + * Abfrage der Daten für eine neue Wohnung + */ + public void newAppartment() { + Wohnung w = new Wohnung(); + + w.setOrt(FormUtil.readString("Ort")); + w.setPlz(FormUtil.readInt("PLZ")); + w.setStrasse(FormUtil.readString("Straße")); + w.setHausnummer(FormUtil.readString("Hausnummer")); + w.setFlaeche(FormUtil.readInt("Fläche")); + w.setStockwerk(FormUtil.readInt("Stockwerk")); + w.setMietpreis(FormUtil.readInt("Mietpreis")); + w.setEbk(FormUtil.readBoolean("EBK")); + w.setBalkon(FormUtil.readBoolean("Balkon")); + w.setVerwalter(this.verwalter); + + service.addWohnung(w); + } + + /** + * Lässt den Benutzer eine Wohnung zum bearbeiten auswählen + * und fragt anschließend die neuen Daten ab. + */ + public void editAppartment() { + //Alle Wohnungen suchen, die vom Makler verwaltet werden + Set wohnungen = service.getAllWohnungenForMakler(verwalter); + + //Auswahlmenü für die zu bearbeitende Wohnung + AppartmentSelectionMenu asm = new AppartmentSelectionMenu("Liste der verwalteten Wohnungen", wohnungen); + int id = asm.show(); + + //Falls nicht der Eintrag "zurück" gewählt wurde, Wohnung bearbeiten + if(id != AppartmentSelectionMenu.BACK) { + //Wohnung laden + Wohnung w = service.getWohnungById(id); + + System.out.println("Haus "+w.getStrasse()+" "+w.getHausnummer()+", "+w.getPlz()+" "+w.getOrt()+" wird bearbeitet. Leere Felder bzw. Eingabe von 0 lässt Feld unverändert."); + + //Neue Daten abfragen + String newOrt = FormUtil.readString("Ort ("+w.getOrt()+")"); + int newPlz = FormUtil.readInt("PLZ ("+w.getPlz()+")"); + String newStrasse = FormUtil.readString("Straße ("+w.getStrasse()+")"); + String newHausNummer = FormUtil.readString("Hausnummer ("+w.getHausnummer()+")"); + int newFlaeche = FormUtil.readInt("Fläche ("+w.getFlaeche()+")"); + int newStockwerk = FormUtil.readInt("Stockwerk ("+w.getStockwerk()+")"); + int newMietpreis = FormUtil.readInt("Mietpreis ("+w.getMietpreis()+")"); + boolean newEbk = FormUtil.readBoolean("EBK ("+(w.isEbk() ? "j" : "n")+")"); + boolean newBalkon = FormUtil.readBoolean("Balkon ("+(w.isBalkon() ? "j" : "n")+")"); + + //Neue Daten setzen + if(!newOrt.equals("")) + w.setOrt(newOrt); + + if(!newStrasse.equals("")) + w.setStrasse(newStrasse); + + if(!newHausNummer.equals("")) + w.setHausnummer(newHausNummer); + + if(newPlz != 0) + w.setPlz(newPlz); + + if(newFlaeche != 0) + w.setFlaeche(newFlaeche); + + if(newStockwerk != 0) + w.setStockwerk(newStockwerk); + + if(newMietpreis != 0) + w.setMietpreis(newMietpreis); + + w.setEbk(newEbk); + w.setBalkon(newBalkon); + } + } + + /** + * Zeigt die Liste von verwalteten Wohnungen und löscht die + * entsprechende Wohnung nach Auswahl + */ + public void deleteAppartment() { + //Alle Wohnungen suchen, die vom Makler verwaltet werden + Set wohnungen = service.getAllWohnungenForMakler(verwalter); + + //Auswahlmenü für die zu bearbeitende Wohnung + AppartmentSelectionMenu asm = new AppartmentSelectionMenu("Liste der verwalteten Wohnungen", wohnungen); + int id = asm.show(); + + //Falls nicht der Eintrag "zurück" gewählt wurde, Wohnung löschen + if(id != HouseSelectionMenu.BACK) { + Wohnung w = service.getWohnungById(id); + service.deleteWohnung(w); + } + } +} diff --git a/03/src/de/dis2013/editor/MaklerEditor.java b/03/src/de/dis2013/editor/MaklerEditor.java new file mode 100644 index 0000000..07c243f --- /dev/null +++ b/03/src/de/dis2013/editor/MaklerEditor.java @@ -0,0 +1,120 @@ +package de.dis2013.editor; + +import de.dis2013.core.ImmoService; +import de.dis2013.data.Makler; +import de.dis2013.menu.MaklerSelectionMenu; +import de.dis2013.menu.Menu; +import de.dis2013.util.FormUtil; + +/** + * Klasse für die Menüs zur Verwaltung von Immobilien + */ +public class MaklerEditor { + ///Immobilienservice, der genutzt werden soll + private ImmoService service; + + public MaklerEditor(ImmoService service) { + this.service = service; + } + + /** + * Zeigt die Maklerverwaltung + */ + public void showMaklerMenu() { + //Menüoptionen + final int NEW_MAKLER = 0; + final int EDIT_MAKLER = 1; + final int DELETE_MAKLER = 2; + final int BACK = 3; + + //Maklerverwaltungsmenü + Menu maklerMenu = new Menu("Makler-Verwaltung"); + maklerMenu.addEntry("Neuer Makler", NEW_MAKLER); + maklerMenu.addEntry("Makler bearbeiten", EDIT_MAKLER); + maklerMenu.addEntry("Makler löschen", DELETE_MAKLER); + maklerMenu.addEntry("Zurück zum Hauptmenü", BACK); + + //Verarbeite Eingabe + while(true) { + int response = maklerMenu.show(); + + switch(response) { + case NEW_MAKLER: + newMakler(); + break; + case EDIT_MAKLER: + editMakler(); + break; + case DELETE_MAKLER: + deleteMakler(); + break; + case BACK: + return; + } + } + } + + /** + * Legt einen neuen Makler an, nachdem der Benutzer + * die entprechenden Daten eingegeben hat. + */ + public void newMakler() { + Makler m = new Makler(); + + m.setName(FormUtil.readString("Name")); + m.setAdresse(FormUtil.readString("Adresse")); + m.setLogin(FormUtil.readString("Login")); + m.setPasswort(FormUtil.readString("Passwort")); + service.addMakler(m); + + System.out.println("Makler mit der ID "+m.getId()+" wurde erzeugt."); + } + + /** + * Berarbeitet einen Makler, nachdem der Benutzer ihn ausgewählt hat + */ + public void editMakler() { + //Menü zum selektieren des Maklers + Menu maklerSelectionMenu = new MaklerSelectionMenu("Makler editieren", service.getAllMakler()); + int id = maklerSelectionMenu.show(); + + //Falls nicht "zurück" gewählt, Makler bearbeiten + if(id != MaklerSelectionMenu.BACK) { + //Makler laden + Makler m = service.getMaklerById(id); + System.out.println("Makler "+m.getName()+" wird bearbeitet. Leere Felder bleiben unverändert."); + + //Neue Daten abfragen + String new_name = FormUtil.readString("Name ("+m.getName()+")"); + String new_address = FormUtil.readString("Adresse ("+m.getAdresse()+")"); + String new_login = FormUtil.readString("Login ("+m.getLogin()+")"); + String new_password = FormUtil.readString("Passwort ("+m.getPasswort()+")"); + + //Neue Daten setzen + if(!new_name.equals("")) + m.setName(new_name); + if(!new_address.equals("")) + m.setAdresse(new_address); + if(!new_login.equals("")) + m.setLogin(new_login); + if(!new_password.equals("")) + m.setPasswort(new_password); + } + } + + /** + * Löscht einen Makler, nachdem der Benutzer + * ihn ausgewählt hat. + */ + public void deleteMakler() { + //Menü zum selektieren des Maklers + Menu maklerSelectionMenu = new MaklerSelectionMenu("Makler löschen", service.getAllMakler()); + int id = maklerSelectionMenu.show(); + + //Makler löschen falls nicht "zurück" ausgewählt wurde + if(id != MaklerSelectionMenu.BACK) { + Makler m = service.getMaklerById(id); + service.deleteMakler(m); + } + } +} diff --git a/03/src/de/dis2013/editor/PersonEditor.java b/03/src/de/dis2013/editor/PersonEditor.java new file mode 100644 index 0000000..4b17b11 --- /dev/null +++ b/03/src/de/dis2013/editor/PersonEditor.java @@ -0,0 +1,116 @@ +package de.dis2013.editor; + +import de.dis2013.core.ImmoService; +import de.dis2013.data.Person; +import de.dis2013.menu.Menu; +import de.dis2013.menu.PersonSelectionMenu; +import de.dis2013.util.FormUtil; + +/** + * Klasse für die Menüs zur Verwaltung von Personen + */ +public class PersonEditor { + ///Immobilienservice, der genutzt werden soll + private ImmoService service; + + public PersonEditor(ImmoService service) { + this.service = service; + } + + /** + * Zeigt die Personenverwaltung + */ + public void showPersonMenu() { + //Menüoptionen + final int NEW_PERSON = 0; + final int EDIT_PERSON = 1; + final int DELETE_PERSON = 2; + final int BACK = 3; + + //Personenverwaltungsmenü + Menu maklerMenu = new Menu("Personen-Verwaltung"); + maklerMenu.addEntry("Neue Person", NEW_PERSON); + maklerMenu.addEntry("Person bearbeiten", EDIT_PERSON); + maklerMenu.addEntry("Person löschen", DELETE_PERSON); + maklerMenu.addEntry("Zurück zum Hauptmenü", BACK); + + //Verarbeite Eingabe + while(true) { + int response = maklerMenu.show(); + + switch(response) { + case NEW_PERSON: + newPerson(); + break; + case EDIT_PERSON: + editPerson(); + break; + case DELETE_PERSON: + deletePerson(); + break; + case BACK: + return; + } + } + } + + /** + * Legt eine neue Person an, nachdem der Benutzer + * die entprechenden Daten eingegeben hat. + */ + public void newPerson() { + Person p = new Person(); + + p.setVorname(FormUtil.readString("Vorname")); + p.setNachname(FormUtil.readString("Nachname")); + p.setAdresse(FormUtil.readString("Adresse")); + service.addPerson(p); + + System.out.println("Person mit der ID "+p.getId()+" wurde erzeugt."); + } + + /** + * Editiert eine Person, nachdem der Benutzer sie ausgewählt hat + */ + public void editPerson() { + //Personenauswahlmenü + Menu personSelectionMenu = new PersonSelectionMenu("Person bearbeiten", service.getAllPersons()); + int id = personSelectionMenu.show(); + + //Person barbeiten? + if(id != PersonSelectionMenu.BACK) { + //Person laden + Person p = service.getPersonById(id); + System.out.println("Person "+p.getVorname()+" "+p.getNachname()+" wird bearbeitet. Leere Felder bleiben unverändert."); + + //Neue Daten einlesen + String newVorname = FormUtil.readString("Vorname ("+p.getVorname()+")"); + String newNachname = FormUtil.readString("Nachname ("+p.getNachname()+")"); + String newAddress = FormUtil.readString("Adresse ("+p.getAdresse()+")"); + + //Neue Daten setzen + if(!newVorname.equals("")) + p.setVorname(newVorname); + if(!newNachname.equals("")) + p.setNachname(newNachname); + if(!newAddress.equals("")) + p.setAdresse(newAddress); + } + } + + /** + * Löscht eine Person, nachdem der Benutzer + * die entprechende ID eingegeben hat. + */ + public void deletePerson() { + //Auswahl der Person + Menu personSelectionMenu = new PersonSelectionMenu("Person bearbeiten", service.getAllPersons()); + int id = personSelectionMenu.show(); + + //Löschen, falls nicht "zurück" gewählt wurde + if(id != PersonSelectionMenu.BACK) { + Person p = service.getPersonById(id); + service.deletePerson(p); + } + } +} diff --git a/03/src/de/dis2013/editor/VertragsEditor.java b/03/src/de/dis2013/editor/VertragsEditor.java new file mode 100644 index 0000000..0d305e7 --- /dev/null +++ b/03/src/de/dis2013/editor/VertragsEditor.java @@ -0,0 +1,184 @@ +package de.dis2013.editor; + +import java.util.Iterator; +import java.util.Set; + +import de.dis2013.core.ImmoService; +import de.dis2013.data.Haus; +import de.dis2013.data.Kaufvertrag; +import de.dis2013.data.Makler; +import de.dis2013.data.Mietvertrag; +import de.dis2013.data.Person; +import de.dis2013.data.Wohnung; +import de.dis2013.menu.AppartmentSelectionMenu; +import de.dis2013.menu.HouseSelectionMenu; +import de.dis2013.menu.Menu; +import de.dis2013.menu.PersonSelectionMenu; +import de.dis2013.util.FormUtil; +import de.dis2013.util.Helper; + +/** + * Klasse für die Menüs zur Verwaltung von Verträgen + */ +public class VertragsEditor { + ///Immobilien-Service, der genutzt werden soll + private ImmoService service; + + ///Makler, zu dessen Immobilien Verträge geschlossen werden dürfen + private Makler verwalter; + + public VertragsEditor(ImmoService service, Makler verwalter) { + this.service = service; + this.verwalter = verwalter; + } + + /** + * Vertragsmenü + */ + public void showVertragsMenu() { + //Menüoptionen + final int NEW_LEASING_CONTRACT = 0; + final int NEW_SALE_CONTRACT = 1; + final int SHOW_CONTRACTS = 2; + final int BACK = 3; + + //Vertragsverwaltung + Menu maklerMenu = new Menu("Vertrags-Verwaltung"); + maklerMenu.addEntry("Neuer Mietvertrag", NEW_LEASING_CONTRACT); + maklerMenu.addEntry("Neuer Kaufvertrag", NEW_SALE_CONTRACT); + maklerMenu.addEntry("Verträge ansehen", SHOW_CONTRACTS); + + maklerMenu.addEntry("Zurück zum Hauptmenü", BACK); + + //Verarbeite Eingabe + while(true) { + int response = maklerMenu.show(); + + switch(response) { + case NEW_LEASING_CONTRACT: + newMietvertrag(); + break; + case NEW_SALE_CONTRACT: + newKaufvertrag(); + break; + case SHOW_CONTRACTS: + zeigeVertraege(); + break; + case BACK: + return; + } + } + } + + public void zeigeVertraege() { + //Mietverträge anzeigen + System.out.println("Mietverträge\n-----------------"); + Set mvs = service.getAllMietvertraegeForMakler(verwalter); + Iterator itmv = mvs.iterator(); + while(itmv.hasNext()) { + Mietvertrag mv = itmv.next(); + System.out.println("Mietvertrag "+mv.getVertragsnummer()+"\n"+ + "\tGeschlossen am "+Helper.dateToString(mv.getDatum())+" in "+mv.getOrt()+"\n"+ + "\tMieter: "+mv.getVertragspartner().getVorname()+" "+mv.getVertragspartner().getNachname()+"\n"+ + "\tWohnung: "+mv.getWohnung().getStrasse()+" "+mv.getWohnung().getHausnummer()+", "+mv.getWohnung().getPlz()+" "+mv.getWohnung().getOrt()+"\n"+ + "\tMietbeginn: "+Helper.dateToString(mv.getMietbeginn())+", Dauer: "+mv.getDauer()+" Monate\n"+ + "\tMietpreis: "+mv.getWohnung().getMietpreis()+" Euro, Nebenkosten: "+mv.getNebenkosten()+" Euro\n"); + } + + System.out.println(""); + + //Kaufverträge anzeigen + System.out.println("Kaufverträge\n-----------------"); + Set kvs = service.getAllKaufvertraegeForMakler(verwalter); + Iterator itkv = kvs.iterator(); + while(itkv.hasNext()) { + Kaufvertrag kv = itkv.next(); + System.out.println("Kaufvertrag "+kv.getVertragsnummer()+"\n"+ + "\tGeschlossen am "+Helper.dateToString(kv.getDatum())+" in "+kv.getOrt()+"\n"+ + "\tMieter: "+kv.getVertragspartner().getVorname()+" "+kv.getVertragspartner().getNachname()+"\n"+ + "\tHaus: "+kv.getHaus().getStrasse()+" "+kv.getHaus().getHausnummer()+", "+kv.getHaus().getPlz()+" "+kv.getHaus().getOrt()+"\n"+ + "\tKaufpreis: "+kv.getHaus().getKaufpreis()+" Euro\n"+ + "\tRaten: "+kv.getAnzahlRaten()+", Ratenzins: "+kv.getRatenzins()+"%\n"); + } + } + + + /** + * Menü zum anlegen eines neuen Mietvertrags + */ + public void newMietvertrag() { + //Alle Wohnungen des Maklers finden + Set wohnungen = service.getAllWohnungenForMakler(verwalter); + + //Auswahlmenü für die Wohnungen + AppartmentSelectionMenu asm = new AppartmentSelectionMenu("Wohnung für Vertrag auswählen", wohnungen); + int wid = asm.show(); + + //Falls kein Abbruch: Auswahl der Person + if(wid != AppartmentSelectionMenu.BACK) { + //Alle Personen laden + Set personen = service.getAllPersons(); + + //Menü zur Auswahl der Person + PersonSelectionMenu psm = new PersonSelectionMenu("Person für Vertrag auswählen", personen); + int pid = psm.show(); + + //Falls kein Abbruch: Vertragsdaten abfragen und Vertrag anlegen + if(pid != PersonSelectionMenu.BACK) { + Mietvertrag m = new Mietvertrag(); + + m.setWohnung(service.getWohnungById(wid)); + m.setVertragspartner(service.getPersonById(pid)); + m.setVertragsnummer(FormUtil.readInt("Vertragsnummer")); + m.setDatum(FormUtil.readDate("Datum")); + m.setOrt(FormUtil.readString("Ort")); + m.setMietbeginn(FormUtil.readDate("Mietbeginn")); + m.setDauer(FormUtil.readInt("Dauer in Monaten")); + m.setNebenkosten(FormUtil.readInt("Nebenkosten")); + + service.addMietvertrag(m); + + System.out.println("Mietvertrag mit der ID "+m.getId()+" wurde erzeugt."); + } + } + } + + /** + * Menü zum anlegen eines neuen Kaufvertrags + */ + public void newKaufvertrag() { + //Alle Häuser des Maklers finden + Set haeuser = service.getAllHaeuserForMakler(verwalter); + + //Auswahlmenü für das Haus + HouseSelectionMenu asm = new HouseSelectionMenu("Haus für Vertrag auswählen", haeuser); + int hid = asm.show(); + + //Falls kein Abbruch: Auswahl der Person + if(hid != AppartmentSelectionMenu.BACK) { + //Alle Personen laden + Set personen = service.getAllPersons(); + + //Menü zur Auswahl der Person + PersonSelectionMenu psm = new PersonSelectionMenu("Person für Vertrag auswählen", personen); + int pid = psm.show(); + + //Falls kein Abbruch: Vertragsdaten abfragen und Vertrag anlegen + if(pid != PersonSelectionMenu.BACK) { + Kaufvertrag k = new Kaufvertrag(); + + k.setHaus(service.getHausById(hid)); + k.setVertragspartner(service.getPersonById(pid)); + k.setVertragsnummer(FormUtil.readInt("Vertragsnummer")); + k.setDatum(FormUtil.readDate("Datum")); + k.setOrt(FormUtil.readString("Ort")); + k.setAnzahlRaten(FormUtil.readInt("Anzahl Raten")); + k.setRatenzins(FormUtil.readInt("Ratenzins")); + + service.addKaufvertrag(k); + + System.out.println("Kaufvertrag mit der ID "+k.getId()+" wurde erzeugt."); + } + } + } +} diff --git a/03/src/de/dis2013/menu/AppartmentSelectionMenu.java b/03/src/de/dis2013/menu/AppartmentSelectionMenu.java new file mode 100644 index 0000000..aad950d --- /dev/null +++ b/03/src/de/dis2013/menu/AppartmentSelectionMenu.java @@ -0,0 +1,24 @@ +package de.dis2013.menu; + +import java.util.Iterator; +import java.util.Set; + +import de.dis2013.data.Wohnung; + +/** + * Ein kleines Menü, dass alle Wohnungen aus einem Set zur Auswahl anzeigt + */ +public class AppartmentSelectionMenu extends Menu { + public static final int BACK = -1; + + public AppartmentSelectionMenu(String title, Set wohnungen) { + super(title); + + Iterator it = wohnungen.iterator(); + while(it.hasNext()) { + Wohnung w = it.next(); + addEntry(w.getStrasse()+" "+w.getHausnummer()+", "+w.getPlz()+" "+w.getOrt(), w.getId()); + } + addEntry("Zurück", BACK); + } +} diff --git a/03/src/de/dis2013/menu/HouseSelectionMenu.java b/03/src/de/dis2013/menu/HouseSelectionMenu.java new file mode 100644 index 0000000..611498f --- /dev/null +++ b/03/src/de/dis2013/menu/HouseSelectionMenu.java @@ -0,0 +1,24 @@ +package de.dis2013.menu; + +import java.util.Iterator; +import java.util.Set; + +import de.dis2013.data.Haus; + +/** + * Ein kleines Menü, dass alle Häuser aus einem Set zur Auswahl anzeigt + */ +public class HouseSelectionMenu extends Menu { + public static final int BACK = -1; + + public HouseSelectionMenu(String title, Set haeuser) { + super(title); + + Iterator it = haeuser.iterator(); + while(it.hasNext()) { + Haus h = it.next(); + addEntry(h.getStrasse()+" "+h.getHausnummer()+", "+h.getPlz()+" "+h.getOrt(), h.getId()); + } + addEntry("Zurück", BACK); + } +} diff --git a/03/src/de/dis2013/menu/MaklerSelectionMenu.java b/03/src/de/dis2013/menu/MaklerSelectionMenu.java new file mode 100644 index 0000000..e39d303 --- /dev/null +++ b/03/src/de/dis2013/menu/MaklerSelectionMenu.java @@ -0,0 +1,24 @@ +package de.dis2013.menu; + +import java.util.Iterator; +import java.util.Set; + +import de.dis2013.data.Makler; + +/** + * Ein kleines Menü, dass alle Makler aus einem Set zur Auswahl anzeigt + */ +public class MaklerSelectionMenu extends Menu { + public static final int BACK = -1; + + public MaklerSelectionMenu(String title, Set makler) { + super(title); + + Iterator it = makler.iterator(); + while(it.hasNext()) { + Makler m = it.next(); + addEntry(m.getName(), m.getId()); + } + addEntry("Zurück", BACK); + } +} diff --git a/03/src/de/dis2013/menu/Menu.java b/03/src/de/dis2013/menu/Menu.java new file mode 100644 index 0000000..def21c9 --- /dev/null +++ b/03/src/de/dis2013/menu/Menu.java @@ -0,0 +1,90 @@ +package de.dis2013.menu; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +import java.util.ArrayList; + +/** + * Kleine Helferklasse für Menüs + * Zuvor müssen mit addEntry Menüoptionen hinzugefügt werden. Mit + * der Methode show() wird das Menü angezeigt und die mit der Option + * angegebene Konstante zurückgeliefert. + * + * Beispiel: + * Menu m = new Menu("Hauptmenü"); + * m.addEntry("Hart arbeiten", 0); + * m.addEntry("Ausruhen", 1); + * m.addEntry("Nach Hause gehen", 2); + * int wahl = m.show(); + * + * Angezeigt wird dann das Menü: + * Hauptmenü: + * [1] Hart arbeiten + * [2] Ausruhen + * [3] Nach Hause gehen + * -- + * + * Wählt der Benutzer nun den ersten Eintrag durch Eingabe + * von 1 und anschließendem Drücken der Enter-Taste, so wird + * 0 zurückgegeben. + */ +public class Menu { + private String title; + private ArrayList labels = new ArrayList(); + private ArrayList returnValues = new ArrayList(); + + /** + * Konstruktor. + * @param title Titel des Menüs z.B. "Hauptmenü" + */ + public Menu(String title) { + super(); + this.title = title; + } + + /** + * Fügt einen Menüeintrag zum Menü hinzu + * @param label Name des Eintrags + * @param returnValue Konstante, die bei Wahl dieses Eintrags zurückgegeben wird + */ + public void addEntry(String label, int returnValue) { + this.labels.add(label); + this.returnValues.add(new Integer(returnValue)); + } + + /** + * Zeigt das Menü an + * @return Die Konstante des ausgewählten Menüeintrags + */ + public int show() { + int selection = -1; + + System.out.println(); + BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in)); + + while(selection == -1) { + System.out.println(title+":"); + + for(int i = 0; i < labels.size(); ++i) { + System.out.println("["+(i+1)+"] "+labels.get(i)); + } + + System.out.print("-- "); + try { + selection = Integer.parseInt(stdin.readLine()); + } catch (NumberFormatException e) { + e.printStackTrace(); + } catch (IOException e) { + e.printStackTrace(); + } + + if(selection < 1 || selection > returnValues.size()) { + System.err.println("Ungültige Eingabe!"); + selection = -1; + } + } + + return returnValues.get(selection-1); + } +} diff --git a/03/src/de/dis2013/menu/PersonSelectionMenu.java b/03/src/de/dis2013/menu/PersonSelectionMenu.java new file mode 100644 index 0000000..d477393 --- /dev/null +++ b/03/src/de/dis2013/menu/PersonSelectionMenu.java @@ -0,0 +1,24 @@ +package de.dis2013.menu; + +import java.util.Iterator; +import java.util.Set; + +import de.dis2013.data.Person; + +/** + * Ein kleines Menü, dass alle Personen aus einem Set zur Auswahl anzeigt + */ +public class PersonSelectionMenu extends Menu { + public static final int BACK = -1; + + public PersonSelectionMenu(String title, Set personen) { + super(title); + + Iterator it = personen.iterator(); + while(it.hasNext()) { + Person p = it.next(); + addEntry(p.getVorname()+" "+p.getNachname(), p.getId()); + } + addEntry("Zurück", BACK); + } +} diff --git a/03/src/de/dis2013/util/FormUtil.java b/03/src/de/dis2013/util/FormUtil.java new file mode 100644 index 0000000..e3f3251 --- /dev/null +++ b/03/src/de/dis2013/util/FormUtil.java @@ -0,0 +1,147 @@ +package de.dis2013.util; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.Date; + +/** + * Kleine Helferklasse zum Einlesen von Formulardaten + */ +public class FormUtil { + /** + * Liest einen String vom standard input ein + * @param label Zeile, die vor der Eingabe gezeigt wird + * @return eingelesene Zeile + */ + public static String readString(String label) { + String ret = null; + BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in)); + + try { + System.out.print(label+": "); + ret = stdin.readLine(); + } catch (IOException e) { + e.printStackTrace(); + } + + return ret; + } + + /** + * Liest ein Passwort vom standard input ein + * @param label Zeile, die vor der Eingabe gezeigt wird + * @return eingelesene Zeile + */ + public static String readPassword(String label) { + String ret = null; + BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in)); + + try { + System.out.print(label+": "); + ret = stdin.readLine(); + } catch (IOException e) { + e.printStackTrace(); + } + return ret; + } + + /** + * Zeigt eine Nachricht an und wartet auf Bestätigung des Benutzers + * @param msg Nachricht + */ + public static void showMessage(String msg) { + BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in)); + + try { + System.out.print(msg); + stdin.readLine(); + } catch (IOException e) { + e.printStackTrace(); + } + } + + /** + * Liest einen Integer vom standard input ein + * @param label Zeile, die vor der Eingabe gezeigt wird + * @return eingelesener Integer + */ + public static int readInt(String label) { + int ret = 0; + boolean finished = false; + + while(!finished) { + String line = readString(label); + + try { + ret = Integer.parseInt(line); + finished = true; + } catch (NumberFormatException e) { + System.err.println("Ungültige Eingabe: Bitte geben Sie eine Zahl an!"); + } + } + + return ret; + } + + /** + * Liest ein Datum vom standard input im Format dd.MM.yyyy ein + * @param label Zeile, die vor der Eingabe gezeigt wird + * @return eingelesenes Datum + */ + public static Date readDate(String label) { + SimpleDateFormat parser = new SimpleDateFormat("dd.MM.yyyy"); + Date ret = null; + boolean finished = false; + + while(!finished) { + String line = readString(label); + + + + try { + ret = parser.parse(line); + finished = true; + } catch (ParseException e) { + System.err.println("Ungültige Eingabe: Bitte geben Sie ein Datum im Format dd.MM.yyyy an!"); + } + } + + return ret; + } + + /** + * Stellt eine Ja/Nein-Frage und gibt das Ergebnis zurück + * @param label Zeile, die vor der Eingabe gezeigt wird + * @return true, falls ja, false, falls nein + */ + public static boolean readBoolean(String label) { + String line = null; + boolean finished = false; + boolean ret = false; + BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in)); + + try { + while(!finished) { + System.out.print(label+" [j/n]: "); + line = stdin.readLine().toLowerCase(); + + if(line.equals("j") || line.equals("ja")) { + ret = true; + finished = true; + } else if(line.equals("n") || line.equals("nein")) { + ret = false; + finished = true; + } else { + System.err.println("Bitte geben Sie ja oder nein bzw. j oder n ein!"); + } + } + } catch (IOException e) { + e.printStackTrace(); + } + + return ret; + } +} diff --git a/03/src/de/dis2013/util/Helper.java b/03/src/de/dis2013/util/Helper.java new file mode 100644 index 0000000..a8ac9fc --- /dev/null +++ b/03/src/de/dis2013/util/Helper.java @@ -0,0 +1,38 @@ +package de.dis2013.util; + +import java.text.SimpleDateFormat; +import java.util.Date; + +public class Helper { + /** + * Compares two objects. A and B may be null + * @param a First object + * @param b Second object + * @return True if the objects are both null or if they are equal + */ + public static boolean compareObjects(Object a, Object b) { + if(a == null) { + if(b == null) + return true; //a and b both null + + return false; //a null, b not null + } + + if(b == null) + return false; //a not null, b null + + //neither a nor b null + return a.equals(b); + } + + /** + * Gibt ein Datum als String im Format dd.MM.yyyy zurück + * @param date Das zu konvertierende Datum + * @return Datum als String + */ + public static String dateToString(Date date) { + SimpleDateFormat dateFormatter = new SimpleDateFormat("dd.MM.yyyy"); + StringBuilder sb = new StringBuilder(dateFormatter.format(date)); + return sb.toString(); + } +} diff --git a/03/src/hibernate.cfg.xml b/03/src/hibernate.cfg.xml new file mode 100644 index 0000000..4a21b18 --- /dev/null +++ b/03/src/hibernate.cfg.xml @@ -0,0 +1,25 @@ + + + + + + com.ibm.db2.jcc.DB2Driver + jdbc:db2://vsisls4.informatik.uni-hamburg.de:50001/VSISP + vsisp** + ******** + + org.hibernate.dialect.DB2Dialect + thread + org.hibernate.cache.NoCacheProvider + true + + + create + + + + + + diff --git a/03/src/log4j.properties b/03/src/log4j.properties new file mode 100644 index 0000000..e572dc7 --- /dev/null +++ b/03/src/log4j.properties @@ -0,0 +1,11 @@ +# Set root category priority to INFO and its only appender to CONSOLE. +log4j.rootCategory=INFO, CONSOLE + +# nur wirkliche Fehler für Hibernate anzeigen... +log4j.logger.org.hibernate=FATAL +#log4j.logger.org.hibernate=DEBUG + +# CONSOLE is set to be a ConsoleAppender using a PatternLayout. +log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender +log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout +log4j.appender.CONSOLE.layout.ConversionPattern=%d [%t] %-5p %c %x - %m%n \ No newline at end of file