Added Exercise 3 Example Project

Added Exercise 3 Example Project

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/<project>=UTF-8

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

03/src/admin.properties

@@ -0,0 +1,2 @@
+username=admin
+password=geheim

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;
+			}
+		}
+	}
+}

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();
+}

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;
+	}
+}

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;
+		}
+	}
+
+}

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> makler = new HashSet<Makler>();
+	private Set<Person> personen = new HashSet<Person>();
+	private Set<Haus> haeuser = new HashSet<Haus>();
+	private Set<Wohnung> wohnungen = new HashSet<Wohnung>();
+	private Set<Mietvertrag> mietvertraege = new HashSet<Mietvertrag>();
+	private Set<Kaufvertrag> kaufvertraege = new HashSet<Kaufvertrag>();
+	
+	//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<Makler> 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<Makler> 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<Makler> 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<Person> 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<Person> 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<Haus> getAllHaeuserForMakler(Makler m) {
+		Set<Haus> ret = new HashSet<Haus>();
+		Iterator<Haus> 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<Haus> 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<Wohnung> getAllWohnungenForMakler(Makler m) {
+		Set<Wohnung> ret = new HashSet<Wohnung>();
+		Iterator<Wohnung> 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<Wohnung> 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<Mietvertrag> getAllMietvertraegeForMakler(Makler m) {
+		Set<Mietvertrag> ret = new HashSet<Mietvertrag>();
+		Iterator<Mietvertrag> 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<Kaufvertrag> getAllKaufvertraegeForMakler(Makler m) {
+		Set<Kaufvertrag> ret = new HashSet<Kaufvertrag>();
+		Iterator<Kaufvertrag> 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<Mietvertrag> 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<Mietvertrag> getMietvertragByVerwalter(Makler m) {
+		Set<Mietvertrag> ret = new HashSet<Mietvertrag>();
+		Iterator<Mietvertrag> 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<Kaufvertrag> getKaufvertragByVerwalter(Makler m) {
+		Set<Kaufvertrag> ret = new HashSet<Kaufvertrag>();
+		Iterator<Kaufvertrag> 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<Kaufvertrag> 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<Immobilie> immos = m2.getImmobilien();
+		Iterator<Immobilie> 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);
+	}
+}

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;
+	}
+}

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;
+	}
+}

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;
+	}
+}

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<Immobilie> 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<Immobilie> getImmobilien() {
+		return immobilien;
+	}
+
+	public void setImmobilien(Set<Immobilie> 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;
+	}
+}

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;
+	}
+}

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;
+	}
+}

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;
+	}
+}

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;
+	}
+}

03/src/de/dis2013/data/mapping/Immobilie.hbm.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0"?>
+<!DOCTYPE hibernate-mapping PUBLIC
+        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
+        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
+<hibernate-mapping>
+	<class name="de.dis2013.data.Immobilie" abstract="true">
+		<id name="id" column="id">
+			<generator class="increment" />
+		</id>
+		<property name="ort" type="string" column="ort" />
+		<property name="plz" type="integer" column="plz" />
+		<property name="strasse" type="string" column="strasse" />
+		<property name="hausnummer" type="string" column="hausnummer" />
+		<property name="flaeche" type="integer" column="flaeche" />
+		<many-to-one name="verwalter" class="de.dis2013.data.Makler" column="verwalter" not-null="true" />
+		
+		<union-subclass name="de.dis2013.data.Haus" table="haeuser">
+			<property name="stockwerke" type="integer" column="stockwerke" />
+			<property name="kaufpreis" type="integer" column="kaufpreis" />
+			<property name="garten" type="boolean" column="garten" />
+		</union-subclass>
+	</class>
+</hibernate-mapping>

03/src/de/dis2013/data/mapping/Makler.hbm.xml

@@ -0,0 +1,20 @@
+<?xml version="1.0"?>
+<!DOCTYPE hibernate-mapping PUBLIC
+        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
+        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
+<hibernate-mapping>
+	<class name="de.dis2013.data.Makler" table="makler">
+		<id name="id" column="id">
+			<generator class="native" />
+		</id>
+		<property name="name" type="string" column="name" />
+		<property name="adresse" type="string" column="adresse" />
+		<property name="login" type="string" column="login" />
+		<property name="passwort" type="string" column="passwort" />
+		
+		<set name="immobilien" inverse="true">
+			<key column="verwalter" />
+			<one-to-many class="de.dis2013.data.Immobilie" />
+		</set>
+	</class>
+</hibernate-mapping>

03/src/de/dis2013/data/mapping/Person.hbm.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0"?>
+<!DOCTYPE hibernate-mapping PUBLIC
+        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
+        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
+<hibernate-mapping>
+	<class name="de.dis2013.data.Person" table="personen">
+		<id name="id" column="id">
+			<generator class="native" />
+		</id>
+		<property name="vorname" type="string" column="vorname" />
+		<property name="nachname" type="string" column="nachname" />
+		<property name="adresse" type="string" column="adresse" />
+	</class>
+</hibernate-mapping>

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<Haus> 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<Haus> 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<Wohnung> 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<Wohnung> 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);
+		}
+	}
+}

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);
+		}
+	}
+}

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);
+		}
+	}
+}

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<Mietvertrag> mvs = service.getAllMietvertraegeForMakler(verwalter);
+		Iterator<Mietvertrag> 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<Kaufvertrag> kvs = service.getAllKaufvertraegeForMakler(verwalter);
+		Iterator<Kaufvertrag> 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<Wohnung> 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<Person> 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<Haus> 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<Person> 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.");
+			}
+		}
+	}
+}

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<Wohnung> wohnungen) {
+		super(title);
+		
+		Iterator<Wohnung> 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);
+	}
+}

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<Haus> haeuser) {
+		super(title);
+		
+		Iterator<Haus> 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);
+	}
+}

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> makler) {
+		super(title);
+		
+		Iterator<Makler> it = makler.iterator();
+		while(it.hasNext()) {
+			Makler m = it.next();
+			addEntry(m.getName(), m.getId());
+		}
+		addEntry("Zurück", BACK);
+	}
+}

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<String> labels = new ArrayList<String>();
+	private ArrayList<Integer> returnValues = new ArrayList<Integer>();
+	
+	/**
+	 * 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);
+	}
+}

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<Person> personen) {
+		super(title);
+		
+		Iterator<Person> it = personen.iterator();
+		while(it.hasNext()) {
+			Person p = it.next();
+			addEntry(p.getVorname()+" "+p.getNachname(), p.getId());
+		}
+		addEntry("Zurück", BACK);
+	}
+}

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;
+	}
+}

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();
+	}
+}

03/src/hibernate.cfg.xml

@@ -0,0 +1,25 @@
+<?xml version='1.0' encoding='utf-8'?>
+<!DOCTYPE hibernate-configuration PUBLIC
+        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
+        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
+
+<hibernate-configuration>
+	<session-factory>
+		<property name="connection.driver_class">com.ibm.db2.jcc.DB2Driver</property>
+		<property name="connection.url">jdbc:db2://vsisls4.informatik.uni-hamburg.de:50001/VSISP</property>
+		<property name="connection.username">vsisp**</property>
+		<property name="connection.password">********</property>
+
+		<property name="dialect">org.hibernate.dialect.DB2Dialect</property>
+		<property name="current_session_context_class">thread</property>
+		<property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
+		<property name="show_sql">true</property>
+
+		<!-- Drop and re-create the database schema on startup -->
+		<property name="hbm2ddl.auto">create</property>
+
+		<mapping resource="de/dis2013/data/mapping/Person.hbm.xml" />
+		<mapping resource="de/dis2013/data/mapping/Makler.hbm.xml" />
+		<mapping resource="de/dis2013/data/mapping/Immobilie.hbm.xml" />
+	</session-factory>
+</hibernate-configuration>

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