package dataAccess;
import java.io.File;
-import java.rmi.RemoteException;
-import java.util.Date;
-import java.util.Vector;
//import java.util.Enumeration;
//import java.util.Vector;
-import businessLogic.BookingManager;
+import java.rmi.RemoteException;
+import java.sql.Date;
+import java.util.HashSet;
+import java.util.ListIterator;
+import java.util.Vector;
import com.db4o.*;
+import com.db4o.config.EmbeddedConfiguration;
+import com.db4o.cs.Db4oClientServer;
+import com.db4o.cs.config.ClientConfiguration;
-import configuration.Config;
-import domain.*;
+import configuration.ConfigXML;
+import domain.Account;
+import domain.Booking;
+import domain.Offer;
+//import dataModel.Offer;
+import domain.Owner;
+import domain.RuralHouse;
import exceptions.OfferCanNotBeBooked;
+import exceptions.OverlappingOfferExists;
public class DB4oManager {
private static ObjectContainer db;
- private static DB4oManager theDB4oManager = new DB4oManager();
+ private static EmbeddedConfiguration configuration;
+ private static ClientConfiguration configurationCS;
+ private int bookingNumber = 0; // if it is "static" then it is not
+ // serialized
+ private int offerNumber = 0; // if it is "static" then it is not serialized
+ private static DB4oManager theDB4oManager = null;
- /**
- *
- */
- private DB4oManager() {
- Config c = Config.getInstance();
- String dataBaseOpenMode = c.getDataBaseOpenMode();
- DB4oManager.openDatabase(dataBaseOpenMode);
+ private static DB4oManagerAux theDB4oManagerAux;
+ static ConfigXML c;
+
+ private DB4oManager() throws Exception {
+ theDB4oManagerAux = new DB4oManagerAux(0, 0);
+ c = ConfigXML.getInstance();
+ System.out.println("Creating DB4oManager instance => isDatabaseLocal: "
+ + c.isDatabaseLocal() + " getDatabBaseOpenMode: "
+ + c.getDataBaseOpenMode());
+
+ if ((c.getDataBaseOpenMode().equals("initialize"))
+ && (c.isDatabaseLocal()))
+ new File(c.getDb4oFilename()).delete();
+
+ if (c.isDatabaseLocal()) {
+ openDB();
+ System.out.println("DataBase opened");
+ } else // c.isDatabaseLocal==false
+ {
+ openSDB();
+ System.out.println("Remote DataBase opened");
+ }
+ if (c.getDataBaseOpenMode().equals("initialize")) {
+ initializeDB();
+ System.out.println("DataBase initialized");
+ } else // c.getDataBaseOpenMode().equals("open")
+
+ {
+ ObjectSet res = db.queryByExample(DB4oManagerAux.class);
+ ListIterator listIter = res.listIterator();
+ if (listIter.hasNext())
+ theDB4oManagerAux = (DB4oManagerAux) res.next();
+ }
}
- /**
- * @param mode
- */
- public static void openDatabase(String mode) {
- Config c = Config.getInstance();
- String db4oFileName = c.getDb4oFilename();
- if (mode.compareTo("open") == 0) {
- db = Db4o.openFile(Db4o.newConfiguration(), db4oFileName);
- db.ext().configure().updateDepth(5);
-
- } else if (mode.compareTo("initialize") == 0) {
- try {
- new File(db4oFileName).delete();
- db = Db4o.openFile(Db4o.newConfiguration(), db4oFileName);
- db.ext().configure().updateDepth(5);
- Owner jon = new Owner("Jon");
- Owner alfredo = new Owner("Alfredo");
- jon.addRuralHouse(1, "Ezkioko etxea", "Ezkio", 3, 3, 3, 3, 3);
- jon.addRuralHouse(2, "Eskiatzeko etxea", "Jaca", 4, 4, 4, 4, 4);
- jon.setBankAccount("1349 5677 21 2133567777");
- alfredo.addRuralHouse(3, "Casa del abuelo", "Pitillas", 5, 5,
- 5, 5, 5);
- alfredo.addRuralHouse(4, "Murgia", 6, 6, 6, 6, 6);
- alfredo.setBankAccount("4144 0087 23 9700002133");
- Account jonAcc = new Account("userJon", "passJon", jon);
- Account alfredoAcc = new Account("userAlfredo", "passAlfredo",
- alfredo);
- db.store(jon);
- db.store(alfredo);
- db.store(jonAcc);
- db.store(alfredoAcc);
- db.commit();
- System.out.println("DataBase Initialized");
- } finally {
- db.close();
- }
+ private static void openDB() {
+ configuration = Db4oEmbedded.newConfiguration();
+ configuration.common().activationDepth(c.getActivationDepth());
+ configuration.common().updateDepth(c.getUpdateDepth());
+ configuration.common().objectClass(Owner.class).cascadeOnDelete(true);
+ db = Db4oEmbedded.openFile(configuration, c.getDb4oFilename());
+ }
+ private void openSDB() {
+
+ configurationCS = Db4oClientServer.newClientConfiguration();
+ configurationCS.common().activationDepth(c.getActivationDepth());
+ configurationCS.common().updateDepth(c.getUpdateDepth());
+ configurationCS.common().objectClass(Owner.class).cascadeOnDelete(true);
+ db = Db4oClientServer.openClient(configurationCS, c.getDatabaseNode(),
+ c.getDatabasePort(), c.getUser(), c.getPassword());
+
+ }
+
+ class DB4oManagerAux {
+ int bookingNumber;
+ int offerNumber;
+
+ DB4oManagerAux(int bookingNumber, int offerNumber) {
+ this.bookingNumber = bookingNumber;
+ this.offerNumber = offerNumber;
}
}
- /**
- * @return
- */
- public static ObjectContainer getContainer() {
- return db;
+ public static DB4oManager getInstance() throws Exception {
+ if (theDB4oManager == null)
+ theDB4oManager = new DB4oManager();
+ return theDB4oManager;
}
- /**
- * @param rh
- */
- public boolean storeRuralHouses(RuralHouse rh) {
- DB4oManager.openDatabase("open");
- boolean stored = false;
- ObjectContainer db = DB4oManager.getContainer();
- RuralHouse house = new RuralHouse(rh.getHouseNumber(), null, null,
- null, null);
+ public void initializeDB() {
+
try {
- ObjectSet<Owner> result = db.queryByExample(house);
- if (result.isEmpty()) {
- db.store(rh);
- db.commit();
- stored = true;
+ Owner jon = new Owner("Jon");
+ Owner alfredo = new Owner("Alfredo");
+ jon.addRuralHouse("Ezkio", "Ezkioko etxea", "Ezkio", 3, 3, 3, 3, 3);
+ jon.addRuralHouse("Eskia", "Eskiatzeko etxea", "Jaca", 4, 4, 4, 4, 4);
+ jon.setBankAccount("1349 5677 21 2133567777");
+ alfredo.addRuralHouse("Aitonako", "Casa del abuelo", "Pitillas", 5, 5, 5, 5,
+ 5);
+ alfredo.addRuralHouse("Murgoitz", "", "Murgia", 6, 6, 6, 6, 6);
+ alfredo.setBankAccount("4144 0087 23 9700002133");
+ Account jonAcc = new Account("userJon", "passJon", jon);
+ Account alfredoAcc = new Account("userAlfredo", "passAlfredo",
+ alfredo);
+ db.store(jon);
+ db.store(alfredo);
+ db.store(jonAcc);
+ db.store(alfredoAcc);
+ db.commit();
+ } finally {
+ db.close();
+ }
+ }
+
+ public void deleteDB() {
+
+ if (c.isDatabaseLocal() == false)
+ openSDB();
+ else
+ openDB();
+
+ try {
+ Owner proto = new Owner(null, null);
+ ObjectSet result = db.queryByExample(proto);
+ Vector<Owner> owners = new Vector<Owner>();
+ while (result.hasNext()) {
+ Owner o = (Owner) result.next();
+ System.out.println("Deleted owner: " + o.toString());
+ db.delete(o);
}
+ db.commit();
} finally {
db.close();
}
- return stored;
}
+
+
+ @SuppressWarnings("finally")
+ public Offer createOffer(RuralHouse ruralHouse, Date firstDay,
+ Date lastDay, float price) throws RemoteException, Exception {
+ Offer o = null;
+
+ if (c.isDatabaseLocal() == false)
+ openSDB();
+ else
+ openDB();
+
+ try {
+
+ RuralHouse proto = new RuralHouse(ruralHouse.getHouseName(),
+ null, null, null, null);
+ ObjectSet result = db.queryByExample(proto);
+ RuralHouse rh = (RuralHouse) result.next();
+ o = rh.createOffer(theDB4oManagerAux.offerNumber++, firstDay,
+ lastDay, price);
+ db.store(theDB4oManagerAux); // To store the new value for
+ // offerNumber
+ db.store(o);
+ db.commit();
+
+ } catch (com.db4o.ext.ObjectNotStorableException e) {
+ System.out
+ .println("Error: com.db4o.ext.ObjectNotStorableException in createOffer");
+ } finally {
+ db.close();
+ }
+ return o;
+ }
+
+ @SuppressWarnings("finally")
+ public Offer modifyOffer(Offer offer) throws RemoteException, Exception {
+ if (c.isDatabaseLocal() == false)
+ openSDB();
+ else
+ openDB();
+
+ try {
+
+
+ db.store(offer);
+ db.commit();
+
+ } catch (com.db4o.ext.ObjectNotStorableException e) {
+ System.out
+ .println("Error: com.db4o.ext.ObjectNotStorableException in createOffer");
+ } finally {
+ db.close();
+ }
+ return offer;
+ }
+
+ @SuppressWarnings("finally")
+ public void deleteOffer(RuralHouse rh, Offer offer) throws RemoteException, Exception {
+ if (c.isDatabaseLocal() == false)
+ openSDB();
+ else
+ openDB();
+
+ try {
+
+ db.store(rh);
+ db.delete(offer);
+ db.commit();
+
+ } catch (com.db4o.ext.ObjectNotStorableException e) {
+ System.out
+ .println("Error: com.db4o.ext.ObjectNotStorableException in createOffer");
+ } finally {
+ db.close();
+ }
+ }
+
/**
- * This method finds all existing owners
+ * This method creates a book with a corresponding parameters
*
+ * @param First
+ * day, last day, house number and telephone
+ * @return a book
*/
- public Vector<Owner> getOwners() throws RemoteException, Exception {
- DB4oManager.openDatabase("open");
- ObjectContainer db = DB4oManager.getContainer();
+ public Booking createBooking(RuralHouse ruralHouse, Date firstDate,
+ Date lastDate, String bookTelephoneNumber)
+ throws OfferCanNotBeBooked {
+
+ if (c.isDatabaseLocal() == false)
+ openSDB();
+ else
+ openDB();
+
+ Booking bok = null;
try {
- Owner proto = new Owner(null, null);
- ObjectSet<Owner> result = db.queryByExample(proto);
- Vector<Owner> owners = new Vector<Owner>();
- while (result.hasNext())
- owners.add((Owner) result.next());
- return owners;
+
+ if (c.isDatabaseLocal() == false)
+ openSDB();
+
+ RuralHouse proto = new RuralHouse(ruralHouse.getHouseName(),
+ null, ruralHouse.getDescription(), ruralHouse.getTown(),
+ null);
+ ObjectSet result = db.queryByExample(proto);
+ RuralHouse rh = (RuralHouse) result.next();
+
+ Offer offer;
+ offer = rh.findOffer(firstDate, lastDate);
+
+ if (offer != null) {
+ offer.createBooking(theDB4oManagerAux.bookingNumber++,
+ bookTelephoneNumber);
+ db.store(theDB4oManagerAux); // To store the new value for
+ // bookingNumber
+ db.store(offer);
+ db.commit();
+ bok = offer.getBooking();
+ }
+
+ } catch (com.db4o.ext.ObjectNotStorableException e) {
+ System.out
+ .println("Error: com.db4o.ext.ObjectNotStorableException in createBooking");
+ } catch (Exception exc) {
+ exc.printStackTrace();
} finally {
db.close();
}
+ return bok;
}
/**
- * @param usr
- * @param pwd
- * @return
- * @throws RemoteException
- * @throws Exception
+ * This method existing owners
+ *
*/
- public Vector<Account> getAccount(String usr, String pwd)
- throws RemoteException, Exception {
- DB4oManager.openDatabase("open");
- ObjectContainer db = DB4oManager.getContainer();
+ public Vector<Owner> getOwners() throws RemoteException, Exception {
+
+ if (c.isDatabaseLocal() == false)
+ openSDB();
+ else
+ openDB();
try {
- Account proto = new Account(usr, pwd, new Owner(null, null));
- ObjectSet<Account> result = db.queryByExample(proto);
- Vector<Account> accounts = new Vector<Account>();
+ Owner proto = new Owner(null, null);
+ ObjectSet result = db.queryByExample(proto);
+ Vector<Owner> owners = new Vector<Owner>();
while (result.hasNext())
- accounts.add((Account) result.next());
- return accounts;
+ owners.add((Owner) result.next());
+ return owners;
} finally {
db.close();
}
}
- /**
- * @return
- * @throws RemoteException
- * @throws Exception
- */
public Vector<RuralHouse> getAllRuralHouses() throws RemoteException,
Exception {
- DB4oManager.openDatabase("open");
- ObjectContainer db = DB4oManager.getContainer();
+
+ if (c.isDatabaseLocal() == false)
+ openSDB();
+ else
+ openDB();
+
try {
- RuralHouse proto = new RuralHouse(0, null, null, null, null);
- ObjectSet<RuralHouse> result = db.queryByExample(proto);
+ RuralHouse proto = new RuralHouse(null, null, null, null, null);
+ ObjectSet result = db.queryByExample(proto);
Vector<RuralHouse> ruralHouses = new Vector<RuralHouse>();
while (result.hasNext())
ruralHouses.add((RuralHouse) result.next());
}
}
- /**
- * This method creates an offer with a house number, first day, last day and
- * price precondition: There are no overlapping offers
- *
- * @param House
- * number, start day, last day and price
- * @return None
- */
- public Offer createOffer(RuralHouse ruralHouse, Date firstDay,
- Date lastDay, float price) throws RemoteException, Exception {
- DB4oManager.openDatabase("open");
- ObjectContainer db = DB4oManager.getContainer();
- Offer o;
+ public boolean existsOverlappingOffer(RuralHouse rh, Date firstDay,
+ Date lastDay) throws RemoteException, OverlappingOfferExists {
+
+ if (c.isDatabaseLocal() == false)
+ openSDB();
+ else
+ openDB();
+
try {
- RuralHouse proto = new RuralHouse(ruralHouse.getHouseNumber(),
- null, ruralHouse.getDescription(), ruralHouse.getTown(),
- ruralHouse.getFeatures());
- ObjectSet<RuralHouse> result = db.queryByExample(proto);
- RuralHouse rh = (RuralHouse) result.next();
- o = rh.createOffer(firstDay, lastDay, price);
- db.store(o);
- db.commit();
+
+ RuralHouse rhn = (RuralHouse) db
+ .queryByExample(
+ new RuralHouse(rh.getHouseName(), null, null,
+ null, null)).next();
+ if (rhn.overlapsWith(firstDay, lastDay) != null)
+ throw new OverlappingOfferExists();
+ else
+ return false;
} finally {
db.close();
}
- return o;
+ }
+
+ public static ObjectContainer getContainer() {
+ return db;
+ }
+
+ public void close() {
+ db.close();
+ System.out.println("DataBase closed");
+ }
+
+ public String toString() {
+ return "bookingNumber=" + bookingNumber + " offerNumber=" + offerNumber;
}
/**
- * @param rh
+ * @param usr
+ * @param pwd
* @return
+ * @throws RemoteException
+ * @throws Exception
*/
- public RuralHouse getRuralHouse(RuralHouse rh) {
+ public Vector<Account> getAccount(String usr, String pwd)
+ throws RemoteException, Exception {
+
+ if (c.isDatabaseLocal() == false)
+ openSDB();
+ else
+ openDB();
- DB4oManager.openDatabase("open");
try {
- ObjectContainer db = DB4oManager.getContainer();
- RuralHouse proto = new RuralHouse(rh.getHouseNumber(), null,
- rh.getDescription(), rh.getTown(), rh.getFeatures());
- ObjectSet<RuralHouse> result = db.queryByExample(proto);
- return rh = (RuralHouse) result.next();
- } catch (Exception exc) {
- exc.printStackTrace();
- return null;
+ Account proto = new Account(usr, pwd, new Owner(null, null));
+ ObjectSet<Account> result = db.queryByExample(proto);
+ Vector<Account> accounts = new Vector<Account>();
+ while (result.hasNext())
+ accounts.add((Account) result.next());
+ return accounts;
} finally {
db.close();
}
}
/**
- * @param offer
- * @param clientTelephoneNumber
- * @return
- * @throws OfferCanNotBeBooked
+ * @param rh
*/
- public Booking createBooking(Offer offer, String clientTelephoneNumber)
- throws OfferCanNotBeBooked {
- DB4oManager.openDatabase("open");
+ public boolean storeRuralHouses(RuralHouse rh) {
+
+ if (c.isDatabaseLocal() == false)
+ openSDB();
+ else
+ openDB();
+
+ boolean stored = false;
+ RuralHouse house = new RuralHouse(rh.getHouseName(), null, null,
+ null, null);
try {
- Booking b = null;
- if (offer != null) {
- b = offer.createBook(clientTelephoneNumber);
- db.store(b);
- db.store(offer);
+ ObjectSet<Owner> result = db.queryByExample(house);
+ if (result.isEmpty()) {
+ db.store(rh);
db.commit();
+ stored = true;
}
- return b;
- } catch (Exception exc) {
- exc.printStackTrace();
- return null;
} finally {
db.close();
}
+ return stored;
}
- public void removeHouse(int houseNumber) {
- ObjectContainer db = DB4oManager.getContainer();
- RuralHouse house = new RuralHouse(houseNumber, null, null, null, null);
+
+ public void removeHouse(RuralHouse rh, Owner owner) {
+
+ if (c.isDatabaseLocal() == false)
+ openSDB();
+ else
+ openDB();
try {
- ObjectSet<RuralHouse> result = db.queryByExample(house);
+ ObjectSet<RuralHouse> result = db.queryByExample(rh);
if (!result.isEmpty()) {
RuralHouse found = (RuralHouse) result.get(0);
+// db.delete(found.getOwner());
+ db.store(owner);
db.delete(found);
db.commit();
}
}
}
+
+ public Vector<RuralHouse> getRuralHousesByTown(String town){
+ RuralHouse rh = new RuralHouse(null,null,null,town,null);
+
+ if (c.isDatabaseLocal() == false)
+ openSDB();
+ else
+ openDB();
- /**
- * This method returns the instance of the DB4oManager class
- *
- * @return the db4o manager
- */
- public static DB4oManager getInstance() {
- return theDB4oManager;
- }
+ try {
+ ObjectSet<RuralHouse> result = db.queryByExample(rh);
+ Vector<RuralHouse> ruralHouses = new Vector<RuralHouse>();
+ while (result.hasNext())
+ ruralHouses.add(result.next());
+ return ruralHouses;
+ } finally {
+ db.close();
+ }
+ }
+ public RuralHouse getRuralHouseByName(String name){
+ RuralHouse rh = new RuralHouse(name,null,null,null,null);
+
+ if (c.isDatabaseLocal() == false)
+ openSDB();
+ else
+ openDB();
+
+ try{
+ ObjectSet<RuralHouse> result = db.queryByExample(rh);
+ Vector<RuralHouse> ruralHouses = new Vector<RuralHouse>();
+ while(result.hasNext())
+ ruralHouses.add(result.next());
+ db.close();
+ return ruralHouses.get(0);
+ } catch (NullPointerException e){
+ return null;
+ }
+
+
+
+ }
}
projects / RRRRHHHH_Code / blobdiff