--- /dev/null
+package dataAccess;
+
+import java.util.ArrayList;
+//hello
+import java.util.Calendar;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.ResourceBundle;
+import java.util.Vector;
+
+import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.Persistence;
+import javax.persistence.Query;
+import javax.persistence.TypedQuery;
+import javax.swing.JOptionPane;
+
+import configuration.ConfigXML;
+import configuration.UtilDate;
+import domain.AdminUser;
+import domain.Bet;
+import domain.Event;
+import domain.Forecast;
+import domain.Question;
+import domain.RegularUser;
+import domain.User;
+import exceptions.IncorrectPassException;
+import exceptions.QuestionAlreadyExist;
+import exceptions.UserAlreadyExistException;
+import exceptions.UserDoesNotExistException;
+
+/**
+ * It implements the data access to the objectDb database
+ */
+public class DataAccess {
+ protected static EntityManager db;
+ protected static EntityManagerFactory emf;
+
+ ConfigXML c = ConfigXML.getInstance();
+
+ public DataAccess(boolean initializeMode) {
+
+ System.out.println("Creating DataAccess instance => isDatabaseLocal: " + c.isDatabaseLocal()
+ + " getDatabBaseOpenMode: " + c.getDataBaseOpenMode());
+
+ open(initializeMode);
+
+ }
+
+ public DataAccess() {
+ new DataAccess(false);
+ }
+
+ /**
+ * This is the data access method that initializes the database with some events
+ * and questions. This method is invoked by the business logic (constructor of
+ * BLFacadeImplementation) when the option "initialize" is declared in the tag
+ * dataBaseOpenMode of resources/config.xml file
+ */
+ public void initializeDB() {
+
+ db.getTransaction().begin();
+ try {
+
+ Calendar today = Calendar.getInstance();
+
+ int month = today.get(Calendar.MONTH);
+ month += 1;
+ int year = today.get(Calendar.YEAR);
+ if (month == 12) {
+ month = 0;
+ year += 1;
+ }
+
+ Event ev1 = new Event(1, "Atlético-Athletic", UtilDate.newDate(year, month, 17));
+ Event ev2 = new Event(2, "Eibar-Barcelona", UtilDate.newDate(year, month, 17));
+ Event ev3 = new Event(3, "Getafe-Celta", UtilDate.newDate(year, month, 17));
+ Event ev4 = new Event(4, "Alavés-Deportivo", UtilDate.newDate(year, month, 17));
+ Event ev5 = new Event(5, "Español-Villareal", UtilDate.newDate(year, month, 17));
+ Event ev6 = new Event(6, "Las Palmas-Sevilla", UtilDate.newDate(year, month, 17));
+ Event ev7 = new Event(7, "Malaga-Valencia", UtilDate.newDate(year, month, 17));
+ Event ev8 = new Event(8, "Girona-Leganés", UtilDate.newDate(year, month, 17));
+ Event ev9 = new Event(9, "Real Sociedad-Levante", UtilDate.newDate(year, month, 17));
+ Event ev10 = new Event(10, "Betis-Real Madrid", UtilDate.newDate(year, month, 17));
+
+ Event ev11 = new Event(11, "Atletico-Athletic", UtilDate.newDate(year, month, 1));
+ Event ev12 = new Event(12, "Eibar-Barcelona", UtilDate.newDate(year, month, 1));
+ Event ev13 = new Event(13, "Getafe-Celta", UtilDate.newDate(year, month, 1));
+ Event ev14 = new Event(14, "Alavés-Deportivo", UtilDate.newDate(year, month, 1));
+ Event ev15 = new Event(15, "Español-Villareal", UtilDate.newDate(year, month, 1));
+ Event ev16 = new Event(16, "Las Palmas-Sevilla", UtilDate.newDate(year, month, 1));
+
+ Event ev17 = new Event(17, "Málaga-Valencia", UtilDate.newDate(year, month + 1, 28));
+ Event ev18 = new Event(18, "Girona-Leganés", UtilDate.newDate(year, month + 1, 28));
+ Event ev19 = new Event(19, "Real Sociedad-Levante", UtilDate.newDate(year, month + 1, 28));
+ Event ev20 = new Event(20, "Betis-Real Madrid", UtilDate.newDate(year, month + 1, 28));
+
+ Event ev21 = new Event(21, "Universidad-Mauri", UtilDate.newDate(year, month, 22));
+ Event ev22 = new Event(22, "Universidad-Bryan", UtilDate.newDate(year, month, 20));
+ Event ev23 = new Event(23, "Universidad-Melisa", UtilDate.newDate(year, month, 21));
+ Event ev24 = new Event(24, "Universidad-Jorshua", UtilDate.newDate(year, month, 23));
+ Event ev25 = new Event(25, "Ermua - Eibar", UtilDate.newDate(year, month, 24));
+ Event ev26 = new Event(26, "Ermua - Donostia", UtilDate.newDate(year, month, 25));
+ Event ev27 = new Event(27, "Grandes - Pequeñas", UtilDate.newDate(year, month, 26));
+ Event ev28 = new Event(28, "Baloncesto - Basketball", UtilDate.newDate(year, month, 27));
+ Event ev29 = new Event(29, "Cristiano - Messi", UtilDate.newDate(year, month, 20));
+ Event ev30 = new Event(30, "Vinicius - Messi", UtilDate.newDate(year, month, 20));
+ Event ev31 = new Event(31, "Yo - Tu", UtilDate.newDate(year, month, 21));
+ Event ev32 = new Event(32, "La perra - La guarra", UtilDate.newDate(year, month, 21));
+ Event ev33 = new Event(33, "Madrid - Barcelona", UtilDate.newDate(year, month, 22));
+ Event ev34 = new Event(34, "Cibeles - Canaletas", UtilDate.newDate(year, month, 22));
+ Event ev35 = new Event(35, "Playa - Montaña", UtilDate.newDate(year, month, 23));
+ Event ev36 = new Event(36, "Betis - Sevilla", UtilDate.newDate(year, month, 23));
+ Event ev37 = new Event(37, "Eibar - Alaves", UtilDate.newDate(year, month, 22));
+ Event ev38 = new Event(38, "Manchester United - Manchester City", UtilDate.newDate(year, month, 21));
+ Event ev39 = new Event(39, "Fifa - Uefa", UtilDate.newDate(year, month, 20));
+ Event ev40 = new Event(40, "Juventus - Napoli", UtilDate.newDate(year, month, 23));
+ Event ev41 = new Event(41, "Psg - Manchester City", UtilDate.newDate(year, month, 20));
+ Event ev42 = new Event(42, "Leganes - Espanyol", UtilDate.newDate(year, month, 23));
+ Event ev43 = new Event(43, "Liverpool - Everton", UtilDate.newDate(year, month, 21));
+ Event ev44 = new Event(44, "Bayern Munich - Schalke", UtilDate.newDate(year, month, 22));
+ Event ev45 = new Event(45, "Bayer Leverkusen - Friburgo", UtilDate.newDate(year, month, 20));
+ Event ev46 = new Event(46, "Castellon - Lugo", UtilDate.newDate(year, month, 21));
+ Event ev47 = new Event(47, "Albacete - Real Madrid", UtilDate.newDate(year, month, 22));
+
+ Question q7;
+ Question q8;
+ Question q9;
+ Question q10;
+ Question q11;
+ Question q12;
+ Question q13;
+ Question q14;
+ Question q15;
+ Question q16;
+ Question q17;
+ Question q18;
+ Question q19;
+ Question q20;
+ Question q21;
+ Question q22;
+ Question q23;
+ Question q24;
+ Question q25;
+ Question q26;
+ Question q27;
+ Question q28;
+ Question q29;
+ Question q30;
+ Question q31;
+ Question q32;
+ Question q33;
+ Question q34;
+ Question q35;
+ Question q36;
+ Question q37;
+ Question q38;
+ Question q39;
+ Question q40;
+ Question q41;
+ Question q42;
+ Question q43;
+ Question q44;
+ Question q45;
+ Question q46;
+ Question q47;
+ Question q48;
+ Question q49;
+ Question q50;
+ Question q51;
+ Question q52;
+ Question q53;
+ Question q54;
+ Question q55;
+ Question q56;
+ Question q57;
+ Question q58;
+ Question q59;
+ Question q60;
+ Question q61;
+ Question q62;
+ Question q63;
+ Question q64;
+ Question q65;
+ Question q66;
+ Question q67;
+ Question q68;
+ Question q69;
+ Question q70;
+
+ q7 = ev21.addQuestion("¿Quién ganará?", 1);
+ q8 = ev22.addQuestion("¿Quién ganará?", 1);
+ q9 = ev23.addQuestion("¿Quién ganará?", 1);
+ q10 = ev24.addQuestion("¿Quién ganará?", 1);
+ q11 = ev25.addQuestion("¿Quién ganará?", 1);
+ q12 = ev25.addQuestion("¿Quién marcará primero?", 1);
+ q13 = ev25.addQuestion("¿Quién marcará más goles?", 1);
+ q14 = ev26.addQuestion("¿Cuál es más grande?", 1);
+ q15 = ev26.addQuestion("¿Cuál es más bonito?", 1);
+ q16 = ev26.addQuestion("¿Cuál tiene playa?", 1);
+ q17 = ev27.addQuestion("¿Grandes o pequeñas?", 1);
+ q18 = ev27.addQuestion("¿Cuál es más común?", 1);
+ q19 = ev27.addQuestion("¿De cuál has probado más?", 1);
+ q20 = ev28.addQuestion("¿Cómo se dice en castellano?", 1);
+ q21 = ev28.addQuestion("¿Cómo lo diría Sergio Ramos?", 1);
+ q22 = ev28.addQuestion("¿Cuál suele gustar más?", 1);
+ q23 = ev29.addQuestion("¿Quién es mejor?", 1);
+ q24 = ev29.addQuestion("¿Quíen cobra más?", 1);
+ q25 = ev29.addQuestion("¿Quién está jugando en España?", 1);
+ q26 = ev30.addQuestion("¿Quién es mejor?", 1);
+ q27 = ev30.addQuestion("¿Quién es argentino?", 1);
+ q28 = ev30.addQuestion("¿Quién juega en el Madrid?", 1);
+ q29 = ev31.addQuestion("¿Quién eres tú?", 1);
+ q30 = ev31.addQuestion("¿Quién será ingeniero?", 1);
+ q31 = ev31.addQuestion("¿Quién aprobará IS?", 1);
+ q32 = ev32.addQuestion("¿Cuál frecuenta más la esquina?", 1);
+ q33 = ev32.addQuestion("¿Cuál es la más sexy?", 1);
+ q34 = ev32.addQuestion("¿Cuál es más frecuente en las esquinas?", 1);
+ q35 = ev33.addQuestion("¿Cuál tiene playa?", 1);
+ q36 = ev33.addQuestion("¿Donde reside el gobierno de España?", 1);
+ q37 = ev33.addQuestion("¿Cuál es más poblada?", 1);
+ q38 = ev34.addQuestion("¿Cuál está en Madrid?", 1);
+ q39 = ev34.addQuestion("¿Cuál está en Cataluña?", 1);
+ q40 = ev34.addQuestion("¿A dónde suele ir el Madrid?", 1);
+ q41 = ev35.addQuestion("¿Cuál prefieres?", 1);
+ q42 = ev35.addQuestion("¿Cuál tiene agua?", 1);
+ q43 = ev35.addQuestion("¿A donde sueles ir más?", 1);
+ q44 = ev36.addQuestion("¿Qué equipo tiene más aficionados?", 1);
+ q45 = ev36.addQuestion("¿Qué equipo viste de blanco y rojo?", 1);
+ q46 = ev36.addQuestion("¿Cuál es una ciudad?", 1);
+ q47 = ev37.addQuestion("¿Qué equipo es de Guipuzcoa?", 1);
+ q48 = ev37.addQuestion("¿Cuántos goles se marcarán en el partido?", 1);
+ q49 = ev37.addQuestion("¿Quién marcará primero?", 1);
+ q50 = ev38.addQuestion("¿Qué equipo tiene más trofeos?", 1);
+ q51 = ev38.addQuestion("¿Cuántos goles se marcarán en el partido?", 1);
+ q52 = ev38.addQuestion("¿Qué equipo es más antiguo?", 1);
+ q53 = ev39.addQuestion("¿Cuál es más corrupta?", 1);
+ q54 = ev39.addQuestion("¿Cuál es más antigua?", 1);
+ q55 = ev40.addQuestion("¿Dónde juega Cristiano Ronaldo?", 1);
+ q56 = ev40.addQuestion("¿Cuál tiene más trofeos?", 1);
+ q57 = ev40.addQuestion("¿Quién ganara la liga este año?", 1);
+ q58 = ev41.addQuestion("¿Qué equipo es francés?", 1);
+ q59 = ev41.addQuestion("¿Qué equipo ganará la champions?", 1);
+ q60 = ev42.addQuestion("¿Qué equipo es de Madrid?", 1);
+ q61 = ev42.addQuestion("¿Qué equipo es de Cataluña?", 1);
+ q62 = ev43.addQuestion("¿Quién ganará?", 1);
+ q63 = ev43.addQuestion("¿Cuál tiene más trofeo?", 1);
+ q64 = ev44.addQuestion("¿Quién tiene más trofeos?", 1);
+ q65 = ev44.addQuestion("¿Quién ganará?", 1);
+ q66 = ev45.addQuestion("¿Quién tiene más ligas ganadas?", 1);
+ q67 = ev45.addQuestion("¿Cuál ha estado más temporadas en primera?", 1);
+ q68 = ev46.addQuestion("¿Quién ha estado más en primera?", 1);
+ q69 = ev46.addQuestion("¿Quién quedará mejor en liga?", 1);
+ q70 = ev47.addQuestion("¿Quién ganará?", 1);
+
+ Forecast f1 = new Forecast(1, "Mauri", 1.2f, q7);
+ Forecast f2 = new Forecast(2, "Universidad", 1.3f, q7);
+ Forecast f3 = new Forecast(3, "Bryan", 1.2f, q8);
+ Forecast f4 = new Forecast(4, "Universidad", 1.2f, q8);
+ Forecast f5 = new Forecast(5, "Melisa", 1.4f, q9);
+ Forecast f6 = new Forecast(6, "Universidad", 1.2f, q9);
+ Forecast f7 = new Forecast(7, "Jorshua", 1.3f, q10);
+ Forecast f8 = new Forecast(8, "Universidad", 1.8f, q10);
+ Forecast f9 = new Forecast(9, "Ermua", 1.8f, q11);
+ Forecast f10 = new Forecast(10, "Eibar", 1.2f, q11);
+ Forecast f11 = new Forecast(11, "Ermua", 1.9f, q12);
+ Forecast f12 = new Forecast(12, "Eibar", 1.2f, q12);
+ Forecast f13 = new Forecast(13, "Ermua", 1.6f, q13);
+ Forecast f14 = new Forecast(14, "Eibar", 1.5f, q13);
+ Forecast f15 = new Forecast(15, "Ermua", 1.4f, q14);
+ Forecast f16 = new Forecast(16, "Donostia", 1.1f, q14);
+ Forecast f17 = new Forecast(17, "Ermua", 1.2f, q15);
+ Forecast f18 = new Forecast(18, "Donostia", 2f, q15);
+ Forecast f19 = new Forecast(19, "Ermua", 2f, q16);
+ Forecast f20 = new Forecast(20, "Donostia", 1.8f, q16);
+ Forecast f21 = new Forecast(21, "Grandes", 2.1f, q17);
+ Forecast f22 = new Forecast(22, "Pequeñas", 2.4f, q17);
+ Forecast f23 = new Forecast(23, "Grandes", 2.7f, q18);
+ Forecast f24 = new Forecast(24, "Pequeñas", 2.7f, q18);
+ Forecast f25 = new Forecast(25, "Grandes", 1.2f, q19);
+ Forecast f26 = new Forecast(26, "Pequeñas", 1.2f, q19);
+ Forecast f27 = new Forecast(27, "Baloncesto", 1.2f, q20);
+ Forecast f28 = new Forecast(28, "Basketball", 1.9f, q20);
+ Forecast f29 = new Forecast(29, "Baloncesto", 1.2f, q21);
+ Forecast f30 = new Forecast(30, "Basketball", 1.2f, q21);
+ Forecast f31 = new Forecast(31, "Baloncesto", 1.2f, q22);
+ Forecast f32 = new Forecast(32, "Basketball", 1.6f, q22);
+ Forecast f33 = new Forecast(33, "Cristiano", 1.2f, q23);
+ Forecast f34 = new Forecast(34, "Messi", 1.2f, q23);
+ Forecast f35 = new Forecast(35, "Cristiano", 1.2f, q24);
+ Forecast f36 = new Forecast(36, "Messi", 1.4f, q24);
+ Forecast f37 = new Forecast(37, "Cristiano", 1.2f, q25);
+ Forecast f38 = new Forecast(38, "Messi", 1.3f, q25);
+ Forecast f39 = new Forecast(39, "Vinicius", 1.2f, q26);
+ Forecast f40 = new Forecast(40, "Messi", 1.2f, q26);
+ Forecast f41 = new Forecast(41, "Vinicius", 2.5f, q27);
+ Forecast f42 = new Forecast(42, "Messi", 1.2f, q27);
+ Forecast f43 = new Forecast(43, "Vinicius", 1.2f, q28);
+ Forecast f44 = new Forecast(44, "Messi", 1.2f, q28);
+ Forecast f45 = new Forecast(45, "Yo", 1.2f, q29);
+ Forecast f46 = new Forecast(46, "Tu", 2.6f, q29);
+ Forecast f47 = new Forecast(47, "Yo", 1.2f, q30);
+ Forecast f48 = new Forecast(48, "Tu", 2.8f, q30);
+ Forecast f49 = new Forecast(49, "Yo", 1.2f, q31);
+ Forecast f50 = new Forecast(50, "Tu", 2.7f, q31);
+ Forecast f51 = new Forecast(51, "La perra", 1.2f, q32);
+ Forecast f52 = new Forecast(52, "La guarra", 1.2f, q32);
+ Forecast f53 = new Forecast(53, "La perra", 1.2f, q33);
+ Forecast f54 = new Forecast(54, "La guarra", 2.3f, q33);
+ Forecast f55 = new Forecast(55, "La perra", 1.2f, q34);
+ Forecast f56 = new Forecast(56, "La guarra", 2.8f, q34);
+ Forecast f57 = new Forecast(57, "Madrid", 1.2f, q35);
+ Forecast f58 = new Forecast(58, "Barcelona", 1.2f, q35);
+ Forecast f59 = new Forecast(59, "Madrid", 3f, q36);
+ Forecast f60 = new Forecast(60, "Barcelona", 1.2f, q36);
+ Forecast f61 = new Forecast(61, "Madrid", 3.2f, q37);
+ Forecast f62 = new Forecast(62, "Barcelona", 1.2f, q37);
+ Forecast f63 = new Forecast(63, "Cibeles", 1.2f, q38);
+ Forecast f64 = new Forecast(64, "Canaletas", 1.2f, q38);
+ Forecast f65 = new Forecast(65, "Cibeles", 3.6f, q39);
+ Forecast f66 = new Forecast(66, "Canaletas", 1.2f, q39);
+ Forecast f67 = new Forecast(67, "Cibeles", 1.2f, q40);
+ Forecast f68 = new Forecast(68, "Canaletas", 3.5f, q40);
+ Forecast f69 = new Forecast(69, "Playa", 1.2f, q41);
+ Forecast f70 = new Forecast(70, "Montaña", 1.2f, q41);
+ Forecast f71 = new Forecast(71, "Playa", 1.2f, q42);
+ Forecast f72 = new Forecast(72, "Montaña", 3.7f, q42);
+ Forecast f73 = new Forecast(73, "Playa", 1.2f, q43);
+ Forecast f74 = new Forecast(74, "Montaña", 1.2f, q43);
+ Forecast f75 = new Forecast(75, "Betis", 3.9f, q44);
+ Forecast f76 = new Forecast(76, "Sevilla", 1.2f, q44);
+ Forecast f77 = new Forecast(77, "Betis", 1.2f, q45);
+ Forecast f78 = new Forecast(78, "Sevilla", 1.2f, q45);
+ Forecast f79 = new Forecast(79, "Betis", 1.2f, q46);
+ Forecast f80 = new Forecast(80, "Sevilla", 3.7f, q46);
+ Forecast f81 = new Forecast(81, "Eibar", 1.2f, q47);
+ Forecast f82 = new Forecast(82, "Alaves", 1.2f, q47);
+ Forecast f83 = new Forecast(83, "0", 1.2f, q48);
+ Forecast f84 = new Forecast(84, "1", 3.5f, q48);
+ Forecast f85 = new Forecast(85, "2", 1.2f, q48);
+ Forecast f86 = new Forecast(86, "3", 1.2f, q48);
+ Forecast f87 = new Forecast(87, "4", 1.2f, q48);
+ Forecast f88 = new Forecast(88, "5", 4f, q48);
+ Forecast f89 = new Forecast(89, "Eibar", 1.2f, q49);
+ Forecast f90 = new Forecast(90, "Alaves", 1.2f, q49);
+ Forecast f91 = new Forecast(91, "Manchester United", 4.2f, q50);
+ Forecast f92 = new Forecast(92, "Manchester City", 1.2f, q50);
+ Forecast f93 = new Forecast(93, "0", 1.2f, q51);
+ Forecast f94 = new Forecast(94, "1", 4.7f, q51);
+ Forecast f95 = new Forecast(95, "2", 1.2f, q51);
+ Forecast f96 = new Forecast(96, "3", 5.6f, q51);
+ Forecast f97 = new Forecast(97, "4", 1.2f, q51);
+ Forecast f98 = new Forecast(98, "5", 1.2f, q51);
+ Forecast f99 = new Forecast(99, "Manchester United", 3.7f, q52);
+ Forecast f100 = new Forecast(100, "Manchester City", 1.2f, q52);
+ Forecast f101 = new Forecast(101, "Fifa", 1.2f, q53);
+ Forecast f102 = new Forecast(102, "Uefa", 4.8f, q53);
+ Forecast f103 = new Forecast(103, "Fifa", 1.2f, q54);
+ Forecast f104 = new Forecast(104, "Uefa", 4.9f, q54);
+ Forecast f105 = new Forecast(105, "Juventus", 1.2f, q55);
+ Forecast f106 = new Forecast(106, "Napoli", 1.2f, q55);
+ Forecast f107 = new Forecast(107, "Juventus", 4.2f, q56);
+ Forecast f108 = new Forecast(108, "Napoli", 1.2f, q56);
+ Forecast f109 = new Forecast(109, "Juventus", 4.6f, q57);
+ Forecast f110 = new Forecast(110, "Napoli", 1.2f, q57);
+ Forecast f111 = new Forecast(111, "Psg", 1.2f, q58);
+ Forecast f112 = new Forecast(112, "Manchester City", 1.2f, q58);
+ Forecast f113 = new Forecast(113, "Psg", 1.2f, q59);
+ Forecast f114 = new Forecast(114, "Manchester City", 1.2f, q59);
+ Forecast f115 = new Forecast(115, "Leganes", 4.4f, q60);
+ Forecast f116 = new Forecast(116, "Espanyol", 1.2f, q60);
+ Forecast f117 = new Forecast(117, "Leganes", 1.2f, q61);
+ Forecast f118 = new Forecast(118, "Espanyol", 4.1f, q61);
+ Forecast f119 = new Forecast(119, "Liverpool", 5f, q62);
+ Forecast f120 = new Forecast(120, "Everton", 1.2f, q62);
+ Forecast f121 = new Forecast(121, "Liverpool", 1.2f, q63);
+ Forecast f122 = new Forecast(122, "Everton", 1.9f, q63);
+ Forecast f123 = new Forecast(123, "Bayern Munich", 1.2f, q64);
+ Forecast f124 = new Forecast(124, "Schalke", 2.9f, q64);
+ Forecast f125 = new Forecast(125, "Bayern Munich", 1.2f, q65);
+ Forecast f126 = new Forecast(126, "Schalke", 1.2f, q65);
+ Forecast f127 = new Forecast(127, "Bayer Leverkusen", 1.2f, q66);
+ Forecast f128 = new Forecast(128, "Friburgo", 1.2f, q66);
+ Forecast f129 = new Forecast(129, "Bayer Leverkusen", 1.2f, q67);
+ Forecast f130 = new Forecast(130, "Friburgo", 1.2f, q67);
+ Forecast f131 = new Forecast(131, "Castellon", 2.7f, q68);
+ Forecast f132 = new Forecast(132, "Lugo", 1.2f, q68);
+ Forecast f133 = new Forecast(133, "Castellon", 1.2f, q69);
+ Forecast f134 = new Forecast(134, "Lugo", 3.9f, q69);
+ Forecast f135 = new Forecast(135, "Albacete", 1.2f, q70);
+ Forecast f136 = new Forecast(136, "Real Madrid", 5.9f, q70);
+
+ q7.addForecast(f1);
+ q7.addForecast(f2);
+ q8.addForecast(f3);
+ q8.addForecast(f4);
+ q9.addForecast(f5);
+ q9.addForecast(f6);
+ q10.addForecast(f7);
+ q10.addForecast(f8);
+ q11.addForecast(f9);
+ q11.addForecast(f10);
+ q12.addForecast(f11);
+ q12.addForecast(f12);
+ q13.addForecast(f13);
+ q13.addForecast(f14);
+ q14.addForecast(f15);
+ q14.addForecast(f16);
+ q15.addForecast(f17);
+ q15.addForecast(f18);
+ q16.addForecast(f19);
+ q16.addForecast(f20);
+ q17.addForecast(f21);
+ q17.addForecast(f22);
+ q18.addForecast(f23);
+ q18.addForecast(f24);
+ q19.addForecast(f25);
+ q19.addForecast(f26);
+ q20.addForecast(f27);
+ q20.addForecast(f28);
+ q21.addForecast(f29);
+ q21.addForecast(f30);
+ q22.addForecast(f31);
+ q22.addForecast(f32);
+ q23.addForecast(f33);
+ q23.addForecast(f34);
+ q24.addForecast(f35);
+ q24.addForecast(f36);
+ q25.addForecast(f37);
+ q25.addForecast(f38);
+ q26.addForecast(f39);
+ q26.addForecast(f40);
+ q27.addForecast(f41);
+ q27.addForecast(f42);
+ q28.addForecast(f43);
+ q28.addForecast(f44);
+ q29.addForecast(f45);
+ q29.addForecast(f46);
+ q30.addForecast(f47);
+ q30.addForecast(f48);
+ q31.addForecast(f49);
+ q31.addForecast(f50);
+ q32.addForecast(f51);
+ q32.addForecast(f52);
+ q33.addForecast(f53);
+ q33.addForecast(f54);
+ q34.addForecast(f55);
+ q34.addForecast(f56);
+ q35.addForecast(f57);
+ q35.addForecast(f58);
+ q36.addForecast(f59);
+ q36.addForecast(f60);
+ q37.addForecast(f61);
+ q37.addForecast(f62);
+ q38.addForecast(f63);
+ q38.addForecast(f64);
+ q39.addForecast(f65);
+ q39.addForecast(f66);
+ q40.addForecast(f67);
+ q40.addForecast(f68);
+ q41.addForecast(f69);
+ q41.addForecast(f70);
+ q42.addForecast(f71);
+ q42.addForecast(f72);
+ q43.addForecast(f73);
+ q43.addForecast(f74);
+ q44.addForecast(f75);
+ q44.addForecast(f76);
+ q45.addForecast(f77);
+ q45.addForecast(f78);
+ q46.addForecast(f79);
+ q46.addForecast(f80);
+ q47.addForecast(f81);
+ q47.addForecast(f82);
+ q48.addForecast(f83);
+ q48.addForecast(f84);
+ q48.addForecast(f85);
+ q48.addForecast(f86);
+ q48.addForecast(f87);
+ q48.addForecast(f88);
+ q49.addForecast(f89);
+ q49.addForecast(f90);
+ q50.addForecast(f91);
+ q50.addForecast(f92);
+ q51.addForecast(f93);
+ q51.addForecast(f94);
+ q51.addForecast(f95);
+ q51.addForecast(f96);
+ q51.addForecast(f97);
+ q51.addForecast(f98);
+ q52.addForecast(f99);
+ q52.addForecast(f100);
+ q53.addForecast(f101);
+ q53.addForecast(f102);
+ q54.addForecast(f103);
+ q54.addForecast(f104);
+ q55.addForecast(f105);
+ q55.addForecast(f106);
+ q56.addForecast(f107);
+ q56.addForecast(f108);
+ q57.addForecast(f109);
+ q57.addForecast(f110);
+ q58.addForecast(f111);
+ q58.addForecast(f112);
+ q59.addForecast(f113);
+ q59.addForecast(f114);
+ q60.addForecast(f115);
+ q60.addForecast(f116);
+ q61.addForecast(f117);
+ q61.addForecast(f118);
+ q62.addForecast(f119);
+ q62.addForecast(f120);
+ q63.addForecast(f121);
+ q63.addForecast(f122);
+ q64.addForecast(f123);
+ q64.addForecast(f124);
+ q65.addForecast(f125);
+ q65.addForecast(f126);
+ q66.addForecast(f127);
+ q66.addForecast(f128);
+ q67.addForecast(f129);
+ q67.addForecast(f130);
+ q68.addForecast(f131);
+ q68.addForecast(f132);
+ q69.addForecast(f133);
+ q69.addForecast(f134);
+ q70.addForecast(f135);
+ q70.addForecast(f136);
+
+ User useradmin = new AdminUser("admin", "admin", "Pepe", "Lopez");
+ User usuario = new RegularUser("mauri", "Mauri1?", "Mauri", "Contreras", "01/01/1997", "mauri@gmail.com",
+ "ES11 1111 1111 1111", 123456789, "", 80);
+ User usuario2 = new RegularUser("bryan", "Bryan1?", "Bryan", "Sánchez", "01/01/1997", "bryan@gmail.com", "",
+ 123454321, "", 50);
+ db.persist(usuario);
+ db.persist(usuario2);
+ db.persist(useradmin);
+ Question q1;
+ Question q2;
+ Question q3;
+ Question q4;
+ Question q5;
+ Question q6;
+
+ if (Locale.getDefault().equals(new Locale("es"))) {
+ q1 = ev1.addQuestion("¿Quién ganará el partido?", 1);
+ q2 = ev1.addQuestion("¿Quién meterá el primer gol?", 2);
+ q3 = ev11.addQuestion("¿Quién ganará el partido?", 1);
+ q4 = ev11.addQuestion("¿Cuántos goles se marcarán?", 2);
+ q5 = ev17.addQuestion("¿Quién ganará el partido?", 1);
+ q6 = ev17.addQuestion("¿Habrá goles en la primera parte?", 2);
+ } else if (Locale.getDefault().equals(new Locale("en"))) {
+ q1 = ev1.addQuestion("Who will win the match?", 1);
+ q2 = ev1.addQuestion("Who will score first?", 2);
+ q3 = ev11.addQuestion("Who will win the match?", 1);
+ q4 = ev11.addQuestion("How many goals will be scored in the match?", 2);
+ q5 = ev17.addQuestion("Who will win the match?", 1);
+ q6 = ev17.addQuestion("Will there be goals in the first half?", 2);
+ } else {
+ q1 = ev1.addQuestion("Zeinek irabaziko du partidua?", 1);
+ q2 = ev1.addQuestion("Zeinek sartuko du lehenengo gola?", 2);
+ q3 = ev11.addQuestion("Zeinek irabaziko du partidua?", 1);
+ q4 = ev11.addQuestion("Zenbat gol sartuko dira?", 2);
+ q5 = ev17.addQuestion("Zeinek irabaziko du partidua?", 1);
+ q6 = ev17.addQuestion("Golak sartuko dira lehenengo zatian?", 2);
+
+ }
+
+ db.persist(ev1);
+ db.persist(ev2);
+ db.persist(ev3);
+ db.persist(ev4);
+ db.persist(ev5);
+ db.persist(ev6);
+ db.persist(ev7);
+ db.persist(ev8);
+ db.persist(ev9);
+ db.persist(ev10);
+ db.persist(ev11);
+ db.persist(ev12);
+ db.persist(ev13);
+ db.persist(ev14);
+ db.persist(ev15);
+ db.persist(ev16);
+ db.persist(ev17);
+ db.persist(ev18);
+ db.persist(ev19);
+ db.persist(ev20);
+ db.persist(ev21);
+ db.persist(ev22);
+ db.persist(ev23);
+ db.persist(ev24);
+ db.persist(ev25);
+ db.persist(ev26);
+ db.persist(ev27);
+ db.persist(ev28);
+ db.persist(ev29);
+ db.persist(ev30);
+ db.persist(ev31);
+ db.persist(ev32);
+ db.persist(ev33);
+ db.persist(ev34);
+ db.persist(ev35);
+ db.persist(ev36);
+ db.persist(ev37);
+ db.persist(ev38);
+ db.persist(ev39);
+ db.persist(ev40);
+ db.persist(ev41);
+ db.persist(ev42);
+ db.persist(ev43);
+ db.persist(ev44);
+ db.persist(ev45);
+ db.persist(ev46);
+ db.persist(ev47);
+
+ db.persist(q1);
+ db.persist(q2);
+ db.persist(q3);
+ db.persist(q4);
+ db.persist(q5);
+ db.persist(q6);
+ db.persist(q7);
+ db.persist(q8);
+ db.persist(q9);
+ db.persist(q10);
+ db.persist(q11);
+ db.persist(q12);
+ db.persist(q13);
+ db.persist(q14);
+ db.persist(q15);
+ db.persist(q16);
+ db.persist(q17);
+ db.persist(q18);
+ db.persist(q19);
+ db.persist(q20);
+ db.persist(q21);
+ db.persist(q22);
+ db.persist(q23);
+ db.persist(q24);
+ db.persist(q25);
+ db.persist(q26);
+ db.persist(q27);
+ db.persist(q28);
+ db.persist(q29);
+ db.persist(q30);
+ db.persist(q31);
+ db.persist(q32);
+ db.persist(q33);
+ db.persist(q34);
+ db.persist(q35);
+ db.persist(q36);
+ db.persist(q37);
+ db.persist(q38);
+ db.persist(q39);
+ db.persist(q40);
+ db.persist(q41);
+ db.persist(q42);
+ db.persist(q43);
+ db.persist(q44);
+ db.persist(q45);
+ db.persist(q46);
+ db.persist(q47);
+ db.persist(q48);
+ db.persist(q49);
+ db.persist(q50);
+ db.persist(q51);
+ db.persist(q52);
+ db.persist(q53);
+ db.persist(q54);
+ db.persist(q55);
+ db.persist(q56);
+ db.persist(q57);
+ db.persist(q58);
+ db.persist(q59);
+ db.persist(q60);
+ db.persist(q61);
+ db.persist(q62);
+ db.persist(q63);
+ db.persist(q64);
+ db.persist(q65);
+ db.persist(q66);
+ db.persist(q67);
+ db.persist(q68);
+ db.persist(q69);
+ db.persist(q70);
+
+ db.persist(f1);
+ db.persist(f2);
+ db.persist(f3);
+ db.persist(f4);
+ db.persist(f5);
+ db.persist(f6);
+ db.persist(f7);
+ db.persist(f8);
+ db.persist(f9);
+ db.persist(f10);
+ db.persist(f11);
+ db.persist(f12);
+ db.persist(f13);
+ db.persist(f14);
+ db.persist(f15);
+ db.persist(f16);
+ db.persist(f17);
+ db.persist(f18);
+ db.persist(f19);
+ db.persist(f20);
+ db.persist(f21);
+ db.persist(f22);
+ db.persist(f23);
+ db.persist(f24);
+ db.persist(f25);
+ db.persist(f26);
+ db.persist(f27);
+ db.persist(f28);
+ db.persist(f29);
+ db.persist(f30);
+ db.persist(f31);
+ db.persist(f32);
+ db.persist(f33);
+ db.persist(f34);
+ db.persist(f35);
+ db.persist(f36);
+ db.persist(f37);
+ db.persist(f38);
+ db.persist(f39);
+ db.persist(f40);
+ db.persist(f41);
+ db.persist(f42);
+ db.persist(f43);
+ db.persist(f44);
+ db.persist(f45);
+ db.persist(f46);
+ db.persist(f47);
+ db.persist(f48);
+ db.persist(f49);
+ db.persist(f50);
+ db.persist(f51);
+ db.persist(f52);
+ db.persist(f53);
+ db.persist(f54);
+ db.persist(f55);
+ db.persist(f56);
+ db.persist(f57);
+ db.persist(f58);
+ db.persist(f59);
+ db.persist(f60);
+ db.persist(f61);
+ db.persist(f62);
+ db.persist(f63);
+ db.persist(f64);
+ db.persist(f65);
+ db.persist(f66);
+ db.persist(f67);
+ db.persist(f68);
+ db.persist(f69);
+ db.persist(f70);
+ db.persist(f71);
+ db.persist(f72);
+ db.persist(f73);
+ db.persist(f74);
+ db.persist(f75);
+ db.persist(f76);
+ db.persist(f77);
+ db.persist(f78);
+ db.persist(f79);
+ db.persist(f80);
+ db.persist(f81);
+ db.persist(f82);
+ db.persist(f83);
+ db.persist(f84);
+ db.persist(f85);
+ db.persist(f86);
+ db.persist(f87);
+ db.persist(f88);
+ db.persist(f89);
+ db.persist(f90);
+ db.persist(f91);
+ db.persist(f92);
+ db.persist(f93);
+ db.persist(f94);
+ db.persist(f95);
+ db.persist(f96);
+ db.persist(f97);
+ db.persist(f98);
+ db.persist(f99);
+ db.persist(f100);
+ db.persist(f101);
+ db.persist(f102);
+ db.persist(f103);
+ db.persist(f104);
+ db.persist(f105);
+ db.persist(f106);
+ db.persist(f107);
+ db.persist(f108);
+ db.persist(f109);
+ db.persist(f110);
+ db.persist(f111);
+ db.persist(f112);
+ db.persist(f113);
+ db.persist(f114);
+ db.persist(f115);
+ db.persist(f116);
+ db.persist(f117);
+ db.persist(f118);
+ db.persist(f119);
+ db.persist(f120);
+ db.persist(f121);
+ db.persist(f122);
+ db.persist(f123);
+ db.persist(f124);
+ db.persist(f125);
+ db.persist(f126);
+ db.persist(f127);
+ db.persist(f128);
+ db.persist(f129);
+ db.persist(f130);
+ db.persist(f131);
+ db.persist(f132);
+ db.persist(f133);
+ db.persist(f134);
+ db.persist(f135);
+ db.persist(f136);
+
+ db.getTransaction().commit();
+ System.out.println("Db initialized");
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ /**
+ * This method creates a question for an event, with a question text and the
+ * minimum bet
+ *
+ * @param event to which question is added
+ * @param question text of the question
+ * @param betMinimum minimum quantity of the bet
+ * @return the created question, or null, or an exception
+ * @throws QuestionAlreadyExist if the same question already exists for the
+ * event
+ */
+ public Question createQuestion(Event event, String question, float betMinimum) throws QuestionAlreadyExist {
+ System.out.println(">> DataAccess: createQuestion=> event= " + event + " question= " + question + " betMinimum="
+ + betMinimum);
+
+ Event ev = db.find(Event.class, event.getEventNumber());
+
+ if (ev.DoesQuestionExists(question))
+ throw new QuestionAlreadyExist(ResourceBundle.getBundle("Etiquetas").getString("ErrorQueryAlreadyExist"));
+
+ db.getTransaction().begin();
+ Question q = ev.addQuestion(question, betMinimum);
+ // db.persist(q);
+ db.persist(ev); // db.persist(q) not required when CascadeType.PERSIST is added in questions
+ // property of Event class
+ // @OneToMany(fetch=FetchType.EAGER, cascade=CascadeType.PERSIST)
+ db.getTransaction().commit();
+ return q;
+
+ }
+
+ public Vector<Question> getAllQuestions() {
+ System.out.println(">> DataAccess: getAllQuestions");
+ Vector<Question> res = new Vector<Question>();
+ TypedQuery<Question> query = db.createQuery("SELECT qu FROM Question qu", Question.class);
+ List<Question> questions = query.getResultList();
+ for (Question qu : questions) {
+ System.out.println(qu.toString());
+ res.add(qu);
+ }
+ return res;
+ }
+
+ /**
+ * This method retrieves from the database the events of a given date
+ *
+ * @param date in which events are retrieved
+ * @return collection of events
+ */
+ public Vector<Event> getEvents(Date date) {
+ System.out.println(">> DataAccess: getEvents");
+ Vector<Event> res = new Vector<Event>();
+ TypedQuery<Event> query = db.createQuery("SELECT ev FROM Event ev WHERE ev.eventDate=?1", Event.class);
+ query.setParameter(1, date);
+ List<Event> events = query.getResultList();
+ for (Event ev : events) {
+ System.out.println(ev.toString());
+ res.add(ev);
+ }
+ return res;
+ }
+
+ public Vector<Event> getAllEvents() {
+ System.out.println(">> DataAccess: getAllEvents");
+ Vector<Event> res = new Vector<Event>();
+ TypedQuery<Event> query = db.createQuery("SELECT ev FROM Event ev", Event.class);
+ List<Event> events = query.getResultList();
+ for (Event ev : events) {
+ System.out.println(ev.toString());
+ res.add(ev);
+ }
+ return res;
+ }
+
+ /**
+ * This method retrieves from the database the dates a month for which there are
+ * events
+ *
+ * @param date of the month for which days with events want to be retrieved
+ * @return collection of dates
+ */
+ public Vector<Date> getEventsMonth(Date date) {
+ System.out.println(">> DataAccess: getEventsMonth");
+ Vector<Date> res = new Vector<Date>();
+
+ Date firstDayMonthDate = UtilDate.firstDayMonth(date);
+ Date lastDayMonthDate = UtilDate.lastDayMonth(date);
+
+ TypedQuery<Date> query = db.createQuery(
+ "SELECT DISTINCT ev.eventDate FROM Event ev WHERE ev.eventDate BETWEEN ?1 and ?2", Date.class);
+ query.setParameter(1, firstDayMonthDate);
+ query.setParameter(2, lastDayMonthDate);
+ List<Date> dates = query.getResultList();
+ for (Date d : dates) {
+ System.out.println(d.toString());
+ res.add(d);
+ }
+ return res;
+ }
+
+ public void open(boolean initializeMode) {
+
+ System.out.println("Opening DataAccess instance => isDatabaseLocal: " + c.isDatabaseLocal()
+ + " getDatabBaseOpenMode: " + c.getDataBaseOpenMode());
+
+ String fileName = c.getDbFilename();
+ if (initializeMode) {
+ fileName = fileName + ";drop";
+ System.out.println("Deleting the DataBase");
+ }
+
+ if (c.isDatabaseLocal()) {
+ emf = Persistence.createEntityManagerFactory("objectdb:" + fileName);
+ db = emf.createEntityManager();
+ } else {
+ Map<String, String> properties = new HashMap<String, String>();
+ properties.put("javax.persistence.jdbc.user", c.getUser());
+ properties.put("javax.persistence.jdbc.password", c.getPassword());
+
+ emf = Persistence.createEntityManagerFactory(
+ "objectdb://" + c.getDatabaseNode() + ":" + c.getDatabasePort() + "/" + fileName, properties);
+
+ db = emf.createEntityManager();
+ }
+
+ }
+
+ public boolean existQuestion(Event event, String question) {
+ System.out.println(">> DataAccess: existQuestion=> event= " + event + " question= " + question);
+ Event ev = db.find(Event.class, event.getEventNumber());
+ return ev.DoesQuestionExists(question);
+
+ }
+
+ public void close() {
+ db.close();
+ System.out.println("DataBase closed");
+ }
+
+ public User login(String username, String pass) throws UserDoesNotExistException, IncorrectPassException {
+
+ User usuario = db.find(User.class, username);
+
+ if (usuario == null) {
+ throw new exceptions.UserDoesNotExistException("El usuario no existe");
+ }
+ if (!pass.equals(usuario.getUserPass())) {
+ throw new exceptions.IncorrectPassException("Contraseña incorrecta");
+ }
+ return usuario;
+
+ }
+
+ public boolean insertEvent(Event pEvento) {
+ try {
+ db.getTransaction().begin();
+ db.persist(pEvento);
+ db.getTransaction().commit();
+ return true;
+ } catch (Exception e) {
+ e.printStackTrace();
+ return false;
+ }
+ }
+
+ public boolean validoUsuario(String puser) throws UserAlreadyExistException {
+
+ User usuarioBD = db.find(User.class, puser);
+ if (usuarioBD == null) {
+ return true;
+ } else {
+ throw new UserAlreadyExistException("Ese usuario ya existe");
+ }
+
+ }
+
+ public RegularUser registrar(String user, String pass, String name, String lastName, String birthDate, String email,
+ String account, Integer numb, String address, float balance) throws UserAlreadyExistException {
+ db.getTransaction().begin();
+ RegularUser u = new RegularUser(user, pass, name, lastName, birthDate, email, account, numb, address, balance);
+
+ boolean b = validoUsuario(user);
+
+ if (b) {
+ db.persist(u);
+ db.getTransaction().commit();
+ }
+
+ return u;
+ }
+
+ public int getNumberEvents() {
+ db.getTransaction().begin();
+ TypedQuery<Event> query = db.createQuery("SELECT ev FROM Event ev ", Event.class);
+ return query.getResultList().size();
+ }
+
+ public boolean existEvent(Event event) {
+ System.out.println(">> DataAccess: existEvent=> event= " + event);
+
+ Vector<Event> eventosmismodia = getEvents(event.getEventDate());
+
+ for (Event e : eventosmismodia) {
+ if (e.getDescription().equals(event.getDescription())) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ public boolean deleteEvent(Event evento) {
+ try {
+ db.getTransaction().begin();
+
+ Event event1 = db.find(Event.class, evento.getEventDate());
+ Query query1 = db.createQuery("DELETE FROM Event e WHERE e.getEventNumber()=?1");
+ query1.setParameter(1, evento.getEventNumber());
+
+ TypedQuery<Question> query2 = db.createQuery("SELECT qu FROM Question qu", Question.class);
+ List<Question> preguntasDB = query2.getResultList();
+
+ for (Question q : preguntasDB) {
+ if (q.getEvent() == evento) {
+ db.remove(q);
+ System.out.println("pregunta eliminada: " + q);
+ } else {
+ System.out.println("pregunta NO ELIMINADA");
+ }
+ }
+
+ int events = query1.executeUpdate();
+ db.getTransaction().commit();
+ System.out.println("Evento eliminado: " + evento);
+
+ return true;
+ } catch (Exception e) {
+ e.printStackTrace();
+ return false;
+ }
+
+ }
+
+ public Forecast insertForecast(Question q, String forecast, float fee) {
+ System.out.println(">> DataAccess: insertForecast=> question= " + q + " forecast= " + forecast + " fee=" + fee);
+
+ try {
+ db.getTransaction().begin();
+ Question qe = db.find(Question.class, q.getQuestionNumber());
+ if (qe.DoesForecastExists(forecast))
+ return null;
+ Forecast f = new Forecast(getMaxIdForecastInDB()+1, forecast, fee, qe);
+ qe.addForecast(f);
+ db.persist(qe);
+ db.getTransaction().commit();
+ return f;
+ } catch (Exception e) {
+ e.printStackTrace();
+ return null;
+ }
+
+ }
+
+ public int getNumberForecasts() {
+ db.getTransaction().begin();
+ TypedQuery<Forecast> query = db.createQuery("SELECT f FROM Forecast f ", Forecast.class);
+ return query.getResultList().size();
+ }
+
+ public Vector<Forecast> getForecasts() {
+ db.getTransaction().begin();
+ Vector<Forecast> res = new Vector<Forecast>();
+ TypedQuery<Forecast> query = db.createQuery("SELECT f FROM Forecast f ", Forecast.class);
+ List<Forecast> forecasts = query.getResultList();
+ for (Forecast f : forecasts) {
+ System.out.println(f.toString());
+ res.add(f);
+ }
+ return res;
+ }
+
+ public Vector<Forecast> getForecasts(Question pregunta) {
+ db.getTransaction().begin();
+ Vector<Forecast> res = new Vector<Forecast>();
+ TypedQuery<Forecast> query = db.createQuery("SELECT f FROM Forecast f WHERE f.getQuestion()=?1",
+ Forecast.class);
+ query.setParameter(1, pregunta);
+ List<Forecast> forecasts = query.getResultList();
+ for (Forecast f : forecasts) {
+ System.out.println(f.toString());
+ res.add(f);
+ }
+ return res;
+ }
+
+ public boolean existForecast(Forecast f) {
+ System.out.println(">> DataAccess: existForecast=> forecast= " + f);
+ return db.find(Forecast.class, f.getForecast()) != null ? true : false;
+
+ }
+
+ public boolean editarPerfilUsuario(String pContraseña, String pUsername, String pNombre, String pApellido,
+ String pEmail, String pCuentaBancaria) {
+ try {
+ db.getTransaction().begin();
+ RegularUser usuario = db.find(RegularUser.class, pUsername);
+ usuario.setFirstName(pNombre);
+ usuario.setLastName(pApellido);
+ usuario.setEmail(pEmail);
+ usuario.setBankAccount(pCuentaBancaria);
+ usuario.setUserPass(pContraseña);
+ db.getTransaction().commit();
+ return true;
+ } catch (Exception ex) {
+ ex.printStackTrace();
+ return false;
+ }
+ }
+
+ public boolean editarPerfilUsuarioSinPass(String pUsername, String pNombre, String pApellido, String pEmail,
+ String pCuentaBancaria) {
+ try {
+ db.getTransaction().begin();
+ RegularUser usuario = db.find(RegularUser.class, pUsername);
+ usuario.setFirstName(pNombre);
+ usuario.setLastName(pApellido);
+ usuario.setEmail(pEmail);
+ usuario.setBankAccount(pCuentaBancaria);
+ db.getTransaction().commit();
+ return true;
+ } catch (Exception ex) {
+ ex.printStackTrace();
+ return false;
+ }
+ }
+
+ public Vector<User> getAllUsers() {
+
+ Vector<User> res = new Vector<User>();
+ TypedQuery<User> query = db.createQuery("SELECT us FROM User us", User.class);
+ List<User> users = query.getResultList();
+ for (User us : users) {
+ System.out.println(us.toString());
+ res.add(us);
+ }
+ return res;
+
+ }
+
+ public Integer getMaxIdInDB() {
+
+ Vector<Event> events = getAllEvents();
+
+ Integer maxid = events.get(0).getEventNumber();
+
+ for (Event e : events) {
+
+ if (e.getEventNumber() > maxid) {
+ maxid = e.getEventNumber();
+ }
+ }
+
+ return maxid;
+ }
+
+ public Integer getMaxIdForecastInDB() {
+
+ Vector<Forecast> res = new Vector<Forecast>();
+ TypedQuery<Forecast> query = db.createQuery("SELECT fo FROM Forecast fo", Forecast.class);
+ List<Forecast> forecasts = query.getResultList();
+
+ return forecasts.get(forecasts.size()-1).getForecastNumber();
+ }
+
+
+ public int createApuesta(Forecast pSelectedForecast, RegularUser pselectedClient, Float pselectedAmount) {
+ // VALIDACIÓN DE NÚMERO POSITIVO
+ if (pselectedAmount < 0) {
+
+ // 4 - NÚMERO NEGATIVO
+ return 4;
+ } else {
+
+ // VALIDACIÓN DE MONTANTE MAYOR AL MÍNIMO
+ // if (pselectedAmount < pselectedQuestion.getBetMinimum()) {
+ if (pselectedAmount < pSelectedForecast.getQuestion().getBetMinimum()) {
+
+ // 3 - NO ALCANZA APUESTA MÍNIMA
+ return 3;
+
+ } else {
+
+ RegularUser clientdb = db.find(RegularUser.class, pselectedClient.getUserName());
+
+ // VALIDACIÓN DE SALDO EN CUENTA
+ if (pselectedAmount >= clientdb.getBalance()) {
+ // 2 - FALTA DE SALDO
+ return 2;
+
+ } else {
+
+ System.out.println(">> DataAccess: createApuesta=> answer= " + pSelectedForecast + " client= "
+ + clientdb.getUserName() + " amount=" + pselectedAmount + "€");
+
+ try {
+ db.getTransaction().begin();
+ Forecast fore = db.find(Forecast.class, pSelectedForecast);
+ Bet ap = fore.addBet(pSelectedForecast, pselectedClient, pselectedAmount);
+ clientdb.addBet(ap);
+ db.persist(ap);
+
+ clientdb.setBalance(clientdb.getBalance() - pselectedAmount);
+ db.persist(clientdb);
+ db.getTransaction().commit();
+
+ // 0 - APUESTA CREADA
+ return 0;
+
+ } catch (Exception ex) {
+
+ // 1 - ERROR DE INGRESO DE APUESTA
+ return 1;
+ }
+
+ }
+
+ }
+ }
+
+ }
+
+ public boolean doLogin(String username, String pass) {
+
+ TypedQuery<RegularUser> query1 = db.createQuery("SELECT ru FROM RegularUser ru", RegularUser.class);
+ List<RegularUser> regularusers = query1.getResultList();
+
+ for (RegularUser ru : regularusers) {
+ if (ru.getUserName().equals(username) && ru.getUserPass().equals(pass)) {
+ return true;
+ }
+ }
+
+ TypedQuery<AdminUser> query2 = db.createQuery("SELECT au FROM AdminUser au", AdminUser.class);
+ List<AdminUser> adminusers = query2.getResultList();
+
+ for (AdminUser au : adminusers) {
+ if (au.getUserName().equals(username) && au.getUserPass().equals(pass)) {
+ return true;
+ }
+ }
+
+ return false;
+
+ }
+
+ public boolean isAdmin(String pusername, String ppassword) {
+ TypedQuery<User> query = db
+ .createQuery("SELECT us FROM User us WHERE us.getUserName()=?1 and us.getUserPass()=?2", User.class);
+ query.setParameter(1, pusername);
+ query.setParameter(2, ppassword);
+ List<User> usuarios = query.getResultList();
+
+ for (User u : usuarios) {
+ return (u instanceof AdminUser);
+ }
+
+ if (usuarios instanceof AdminUser) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ public RegularUser getRegularUserByUsername(String pusername) {
+ System.out.println(">> DataAccess: getRegularUserByUsername");
+
+ TypedQuery<RegularUser> query = db.createQuery("SELECT ru FROM RegularUser ru", RegularUser.class);
+ List<RegularUser> regularusers = query.getResultList();
+
+ // ArrayList<Cliente> result = new ArrayList<Cliente>();
+ for (RegularUser ru : regularusers) {
+ if (ru.getUserName().equals(pusername)) {
+ return ru;
+ }
+
+ }
+ return null;
+
+ }
+
+ public AdminUser getAdminUserByUsername(String pusername) {
+ System.out.println(">> DataAccess: getAdminUserByUsername");
+
+ TypedQuery<AdminUser> query = db.createQuery("SELECT au FROM AdminUser au", AdminUser.class);
+ List<AdminUser> adminusers = query.getResultList();
+
+ // ArrayList<Admin> result = new ArrayList<Admin>();
+ for (AdminUser au : adminusers) {
+ if (au.getUserName().equals(pusername)) {
+ return au;
+ }
+
+ }
+ return null;
+
+ }
+
+ public boolean closeEvent2(Event e, Question q, Forecast f) {
+
+ try {
+
+ db.getTransaction().begin();
+ Event ev = db.find(Event.class, e);
+ Question qe = db.find(Question.class, q);
+ Forecast fe = db.find(Forecast.class, f);
+ qe.setResult(f.getForecast());
+ System.out.println(">> DataAccess: closeEvent=> Event:" + ev.getDescription() + " in question: "
+ + qe.getQuestion() + " with result: " + qe.getResult());
+
+ Vector<Bet> bets = new Vector<Bet>(fe.getBets());
+
+ } catch (Exception e2) {
+ }
+ return false;
+
+ }
+
+ public boolean closeEvent(Event e, Question q, Forecast f) {
+ try {
+ db.getTransaction().begin();
+ Event ev = db.find(Event.class, e);
+ Question qe = db.find(Question.class, q);
+ Forecast fe = db.find(Forecast.class, f);
+ qe.setResult(f.getForecast());
+ System.out.println(">> DataAccess: closeEvent=> Event:" + ev.getDescription() + " in question: "
+ + qe.getQuestion() + " with result: " + qe.getResult());
+ if (ev.getClosed()) {
+ return false;
+ } else {
+ ev.setClosed(true);
+ }
+ Vector<Bet> bets = new Vector<Bet>(fe.getBets());
+ for (Bet be : bets) {
+ Bet bet = db.find(Bet.class, be);
+ if (bet.getForecast() == fe) {
+ if (bet.getForecast().equals(bet.getForecast().getQuestion().getResult())) {
+ bet.setEstadoApuesta("Ganada");
+ } else {
+ bet.setEstadoApuesta("Perdida");
+ }
+ payUsers(bet);
+ }
+ }
+ db.getTransaction().commit();
+ return true;
+ } catch (Exception ex) {
+ ex.printStackTrace();
+ return false;
+ }
+
+ }
+
+ private boolean payUsers(Bet b) {
+
+ try {
+ Vector<User> usersToPay = new Vector<User>(getAllUsers());
+ for (User au : usersToPay) {
+ if (au instanceof RegularUser) {
+ RegularUser u = (RegularUser) au;
+ RegularUser us = db.find(RegularUser.class, u);
+ Vector<Bet> userBets = new Vector<Bet>(u.getBets());
+ for (Bet be : userBets) {
+ Bet bett = db.find(Bet.class, be);
+ if (bett.getUser().equals(us)) {
+ float sumo = us.getBalance() + (be.getAmount() * b.getForecast().getFee());
+ us.setBalance(us.getBalance() + (be.getAmount() * b.getForecast().getFee()));
+ System.out.println("le sumo: " + sumo);
+ System.out.println("Nuevo saldo: " + us.getBalance());
+ }
+ }
+ }
+
+ }
+ return true;
+ } catch (Exception e) {
+ return false;
+ }
+
+ }
+
+ public boolean anularApuesta(Bet pApuesta) {
+
+ try {
+ db.getTransaction().begin();
+ Bet apuesta = db.find(Bet.class, pApuesta);
+ RegularUser cliente = db.find(RegularUser.class, pApuesta.getUser());
+
+ Calendar fecha = new java.util.GregorianCalendar();
+ int año = fecha.get(Calendar.YEAR);
+ int mes = fecha.get(Calendar.MONTH);
+ int dia = fecha.get(Calendar.DAY_OF_MONTH);
+
+ if (apuesta.getForecast().getQuestion().getEvent().getEventDate()
+ .compareTo(UtilDate.newDate(año, mes, dia)) > 0) { // posterior al argumento (actual)
+
+ apuesta.setEstadoApuesta("Anulada");
+ System.out.println("Saldo inicial: " + cliente.getBalance());
+ cliente.setBalance(cliente.getBalance() + pApuesta.getAmount());
+ System.out.println("Se ha devuelto " + pApuesta.getAmount());
+ System.out.println("Saldo actualizado: " + cliente.getBalance());
+
+ db.getTransaction().commit();
+
+ System.out.println("Anulada");
+ return true;
+ } else {
+ System.out.println("No anulada");
+ return false;
+ }
+ } catch (Exception e) {
+ return false;
+ }
+
+ }
+
+ public Vector<Bet> getApuestasAbiertas(RegularUser pUser) {
+
+ db.getTransaction().begin();
+ TypedQuery<Bet> query = db.createQuery("SELECT b FROM Bet b WHERE b.estadoApuesta=?1 AND b.user=?2", Bet.class);
+ query.setParameter(1, "Pendiente");
+ query.setParameter(2, pUser);
+ Vector<Bet> ArrayListApuestas = new Vector<Bet>(query.getResultList());
+ db.getTransaction().commit();
+ return ArrayListApuestas;
+
+ }
+
+ public Vector<Bet> getApuestasCerradas(RegularUser pUser) {
+
+ db.getTransaction().begin();
+ TypedQuery<Bet> query = db.createQuery(
+ "SELECT b FROM Bet b WHERE b.estadoApuesta=?1 OR b.estadoApuesta=?2 AND b.user=?2", Bet.class);
+ query.setParameter(1, "Ganada");
+ query.setParameter(2, "Perdida");
+ query.setParameter(3, pUser);
+ Vector<Bet> ArrayListApuestas = new Vector<Bet>(query.getResultList());
+ db.getTransaction().commit();
+ return ArrayListApuestas;
+
+ }
+
+ public Vector<Bet> getApuestasGanadas(RegularUser pUser) {
+
+ db.getTransaction().begin();
+ TypedQuery<Bet> query = db.createQuery("SELECT b FROM Bet b WHERE b.estadoApuesta=?1 AND b.user=?2", Bet.class);
+ query.setParameter(1, "Ganada");
+ query.setParameter(2, pUser);
+ Vector<Bet> ArrayListApuestas = new Vector<Bet>(query.getResultList());
+ db.getTransaction().commit();
+ return ArrayListApuestas;
+
+ }
+
+ public Vector<Bet> getApuestasPerdidas(RegularUser pUser) {
+
+ db.getTransaction().begin();
+ TypedQuery<Bet> query = db.createQuery("SELECT b FROM Bet b WHERE b.estadoApuesta=?1 AND b.user=?2", Bet.class);
+ query.setParameter(1, "Perdida");
+ query.setParameter(2, pUser);
+ Vector<Bet> ArrayListApuestas = new Vector<Bet>(query.getResultList());
+ db.getTransaction().commit();
+ return ArrayListApuestas;
+
+ }
+
+ public Vector<Bet> getApuestasAnuladas(RegularUser pUser) {
+
+ db.getTransaction().begin();
+ TypedQuery<Bet> query = db.createQuery("SELECT b FROM Bet b WHERE b.estadoApuesta=?1 AND b.user=?2", Bet.class);
+ query.setParameter(1, "Anulada");
+ query.setParameter(2, pUser);
+ Vector<Bet> ArrayListApuestas = new Vector<Bet>(query.getResultList());
+ db.getTransaction().commit();
+ return ArrayListApuestas;
+
+ }
+
+ public Vector<Bet> getApuestasByUser(RegularUser user) {
+
+ db.getTransaction().begin();
+ TypedQuery<Bet> query = db.createQuery("SELECT b FROM Bet b WHERE b.user=?1", Bet.class);
+ query.setParameter(1, user);
+ Vector<Bet> ArrayListApuestas = new Vector<Bet>(query.getResultList());
+ db.getTransaction().commit();
+ return ArrayListApuestas;
+
+ }
+
+ public boolean aplicarBonoBienvenida(String user) {
+
+ try {
+ db.getTransaction().begin();
+ RegularUser usuario = db.find(RegularUser.class, user);
+ usuario.setBalance(5f);
+ db.getTransaction().commit();
+ return true;
+ } catch (Exception e) {
+ return false;
+ }
+
+ }
+
+ public boolean recargarSaldo(String user, Float importe) {
+
+ try {
+ db.getTransaction().begin();
+ RegularUser usuario = db.find(RegularUser.class, user);
+ usuario.setBalance(usuario.getBalance() + importe);
+ db.getTransaction().commit();
+ return true;
+ } catch (Exception e) {
+ return false;
+ }
+
+ }
+
+ public boolean definirResultados(Event pselectedEvent, Question pselectedQuestion, Forecast pselectedForecast) {
+
+ db.getTransaction().begin();
+ Forecast winnerf = db.find(Forecast.class, pselectedForecast.getForecastNumber());
+ Question winnerq = db.find(Question.class, pselectedQuestion);
+ winnerq.setResult(pselectedForecast.getForecast());
+ winnerf.setWinnerf(true);
+ db.getTransaction().commit();
+
+ // TODAS LAS RESPUESTAS POSIBLES DE ESA PREGUNTA
+ TypedQuery<Forecast> query0 = db.createQuery("SELECT fo FROM Forecast fo WHERE fo.question=?1", Forecast.class);
+ query0.setParameter(1, winnerq);
+ db.getTransaction().begin();
+ ArrayList<Forecast> ArrayListRespuestas = new ArrayList<Forecast>(query0.getResultList());
+ db.getTransaction().commit();
+
+ try {
+
+ db.getTransaction().begin();
+ for (Forecast ans : ArrayListRespuestas) { // por cada forecast(prediccion/respuesta) mira todas las
+ // apuestas
+ TypedQuery<Bet> query1 = db.createQuery("SELECT be FROM Bet be WHERE be.forecast=?1", Bet.class);
+ query1.setParameter(1, ans);
+ ArrayList<Bet> ArrayListApuestas = new ArrayList<Bet>(query1.getResultList());
+ if (ArrayListApuestas.isEmpty()) { // chekamos si tiene o no apuestas
+ System.out.println("No bets for this answer.");
+ } else {
+ for (Bet bet : ArrayListApuestas) { // por cada acuesta de ese forecast
+
+ if (bet.getEstadoApuesta().equals("Anulada") == false) {
+
+ if (bet.getForecast().getForecastNumber() == pselectedForecast.getForecastNumber()) {
+ bet.setEstadoApuesta("Ganada");// SET ACIERTO
+
+ User cliente = bet.getUser();
+ RegularUser ru = (RegularUser) cliente;
+ float saldoCliente = ru.getBalance();
+ float total = saldoCliente + bet.getAmount() * pselectedForecast.getFee();
+
+ System.out.println("\nAcredita al cliente " + ru.getUserName() + " un total de "
+ + bet.getAmount() * pselectedForecast.getFee() + "€ (" + bet.getAmount()
+ + "€ x " + pselectedForecast.getFee() + ")");
+
+ ru.setBalance(total);
+
+ } else {
+
+ bet.setEstadoApuesta("Perdida");// SET FALLO
+ }
+
+ }
+ }
+ }
+ }
+
+ winnerq.hasResult(true);
+ System.out.println(
+ "\n// Apuestas sobre pregunta '" + winnerq.getQuestion() + "' resueltas.\nPregunta cerrada. //");
+ db.getTransaction().commit();
+
+ } catch (Exception e) {
+ JOptionPane.showMessageDialog(null, "DataAccess >> Asignar Resultados y Pagos >> Catch: " + e.getMessage()); // FIX-ME!
+ // Comentar
+ // la
+ // lÃnea
+ return false;
+ }
+
+ // CIERRE DE EVENTO
+ try {
+
+ // SI NO HAY PREGUNTAS ABIERTAS, CIERRA EVENTO
+ Event ev = db.find(Event.class, pselectedEvent);
+
+ db.getTransaction().begin();
+ TypedQuery<Question> query = db.createQuery("SELECT q FROM Question q WHERE q.event=?1 AND q.hasResult=?2",
+ Question.class);
+ query.setParameter(1, ev);
+ query.setParameter(2, false);
+
+ ArrayList<Question> ArrayListQuestions = new ArrayList<Question>(query.getResultList());
+
+ if (ArrayListQuestions.isEmpty()) {
+ ev.setClosed(true);
+ // JOptionPane.showMessageDialog(null, "ebento serrado");
+ }
+ // db.getTransaction().commit();
+ db.getTransaction().commit();
+
+ return true;
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ JOptionPane.showMessageDialog(null, "DataAccess >> Cerrar evento >> Catch");
+ return false;
+ }
+ }
+
+ public Vector<Question> getOpenedQuestions(Event ev) {
+ db.getTransaction().begin();
+ Event ev1 = db.find(Event.class, ev);
+ TypedQuery<Question> query = db.createQuery("SELECT q from Question q WHERE q.hasResult=?1 AND q.event=?2",
+ Question.class);
+ query.setParameter(1, false);
+ query.setParameter(2, ev1);
+ ArrayList<Question> ArrayListQuestions = new ArrayList<Question>(query.getResultList());
+ Vector<Question> queries = new Vector<Question>();
+ for (int f = 0; f < ArrayListQuestions.size(); f++) {
+ queries.add(ArrayListQuestions.get(f));
+ System.out.println(ArrayListQuestions.get(f));
+ }
+ db.getTransaction().commit();
+ return queries;
+
+ }
+
+ public boolean getEstadoEvento(Event ev) {
+
+ db.getTransaction().begin();
+ Event ev1 = db.find(Event.class, ev);
+ boolean result = ev1.getClosed();
+ db.getTransaction().commit();
+
+ return result;
+
+ }
+
+ public Vector<Event> getEventosMedioCerrados() {
+
+ db.getTransaction().begin();
+ TypedQuery<Event> query = db.createQuery("SELECT e from Event e", Event.class);
+ boolean controlAbierta = false;
+ boolean controlCerrada = false;
+
+ Vector<Event> vectorEventos = new Vector<Event>(query.getResultList());
+ Vector<Event> resultado = new Vector<Event>();
+ for (Event e : vectorEventos) {
+ Vector<Question> preguntas = e.getQuestions();
+ for (Question q : preguntas) {
+ if (q.hasResult()) { // si la pregunta esta cerrada
+
+ controlCerrada = true;
+ } else if (q.hasResult() == false) { // si la pregunta esta abierta
+ controlAbierta = true;
+ }
+ }
+
+ if (controlAbierta && controlCerrada && (e.getClosed() == false)) {
+ resultado.add(e);
+ }
+ controlAbierta = false;
+ controlCerrada = false;
+ }
+ db.getTransaction().commit();
+
+ return resultado;
+
+ }
+
+ public static void main(String[] args) {
+
+ DataAccess data = new DataAccess();
+ RegularUser usuario = new RegularUser("usuario", "Usuario1?", "Nombre", "Apellido", "01/01/2000",
+ "usuario@gmail.com", "ES11 1111 1111 1111", 123456789, "", 0);
+ Event ev1 = new Event(69, "Eibar-Eibar", UtilDate.newDate(2025, 4, 17));
+ Question pregunta = new Question("pregunta", 2, ev1);
+ Forecast pronostico = new Forecast("Madrid", 17, pregunta);
+ Bet apuesta = new Bet(pronostico, usuario, 13);
+
+ System.out.println(data.anularApuesta(apuesta));
+
+ }
+
+}
\ No newline at end of file
projects / ISBets21MAUBRY / blobdiff