xp-dev.com Git - ISBets21MAUBRY/blob - eclipse-workspace/ISBets21MAUBRY/src/main/java/dataAccess/DataAccess.java

   1 package dataAccess;
   2
   3 import java.util.ArrayList;
   4 //hello
   5 import java.util.Calendar;
   6 import java.util.Date;
   7 import java.util.HashMap;
   8 import java.util.List;
   9 import java.util.Locale;
  10 import java.util.Map;
  11 import java.util.ResourceBundle;
  12 import java.util.Vector;
  13
  14 import javax.persistence.EntityManager;
  15 import javax.persistence.EntityManagerFactory;
  16 import javax.persistence.Persistence;
  17 import javax.persistence.Query;
  18 import javax.persistence.TypedQuery;
  19 import javax.swing.JOptionPane;
  20
  21 import configuration.ConfigXML;
  22 import configuration.UtilDate;
  23 import domain.AdminUser;
  24 import domain.Bet;
  25 import domain.Event;
  26 import domain.Forecast;
  27 import domain.Question;
  28 import domain.RegularUser;
  29 import domain.User;
  30 import exceptions.IncorrectPassException;
  31 import exceptions.QuestionAlreadyExist;
  32 import exceptions.UserAlreadyExistException;
  33 import exceptions.UserDoesNotExistException;
  34
  35 /**
  36  * It implements the data access to the objectDb database
  37  */
  38 public class DataAccess {
  39         protected static EntityManager db;
  40         protected static EntityManagerFactory emf;
  41
  42         ConfigXML c = ConfigXML.getInstance();
  43
  44         public DataAccess(boolean initializeMode) {
  45
  46                 System.out.println("Creating DataAccess instance => isDatabaseLocal: " + c.isDatabaseLocal()
  47                                 + " getDatabBaseOpenMode: " + c.getDataBaseOpenMode());
  48
  49                 open(initializeMode);
  50
  51         }
  52
  53         public DataAccess() {
  54                 new DataAccess(false);
  55         }
  56
  57         /**
  58          * This is the data access method that initializes the database with some events
  59          * and questions. This method is invoked by the business logic (constructor of
  60          * BLFacadeImplementation) when the option "initialize" is declared in the tag
  61          * dataBaseOpenMode of resources/config.xml file
  62          */
  63         public void initializeDB() {
  64
  65                 db.getTransaction().begin();
  66                 try {
  67
  68                         Calendar today = Calendar.getInstance();
  69
  70                         int month = today.get(Calendar.MONTH);
  71                         month += 1;
  72                         int year = today.get(Calendar.YEAR);
  73                         if (month == 12) {
  74                                 month = 0;
  75                                 year += 1;
  76                         }
  77
  78                         Event ev1 = new Event(1, "Atlético-Athletic", UtilDate.newDate(year, month, 17));
  79                         Event ev2 = new Event(2, "Eibar-Barcelona", UtilDate.newDate(year, month, 17));
  80                         Event ev3 = new Event(3, "Getafe-Celta", UtilDate.newDate(year, month, 17));
  81                         Event ev4 = new Event(4, "Alavés-Deportivo", UtilDate.newDate(year, month, 17));
  82                         Event ev5 = new Event(5, "Español-Villareal", UtilDate.newDate(year, month, 17));
  83                         Event ev6 = new Event(6, "Las Palmas-Sevilla", UtilDate.newDate(year, month, 17));
  84                         Event ev7 = new Event(7, "Malaga-Valencia", UtilDate.newDate(year, month, 17));
  85                         Event ev8 = new Event(8, "Girona-Leganés", UtilDate.newDate(year, month, 17));
  86                         Event ev9 = new Event(9, "Real Sociedad-Levante", UtilDate.newDate(year, month, 17));
  87                         Event ev10 = new Event(10, "Betis-Real Madrid", UtilDate.newDate(year, month, 17));
  88
  89                         Event ev11 = new Event(11, "Atletico-Athletic", UtilDate.newDate(year, month, 1));
  90                         Event ev12 = new Event(12, "Eibar-Barcelona", UtilDate.newDate(year, month, 1));
  91                         Event ev13 = new Event(13, "Getafe-Celta", UtilDate.newDate(year, month, 1));
  92                         Event ev14 = new Event(14, "Alavés-Deportivo", UtilDate.newDate(year, month, 1));
  93                         Event ev15 = new Event(15, "Español-Villareal", UtilDate.newDate(year, month, 1));
  94                         Event ev16 = new Event(16, "Las Palmas-Sevilla", UtilDate.newDate(year, month, 1));
  95
  96                         Event ev17 = new Event(17, "Málaga-Valencia", UtilDate.newDate(year, month + 1, 28));
  97                         Event ev18 = new Event(18, "Girona-Leganés", UtilDate.newDate(year, month + 1, 28));
  98                         Event ev19 = new Event(19, "Real Sociedad-Levante", UtilDate.newDate(year, month + 1, 28));
  99                         Event ev20 = new Event(20, "Betis-Real Madrid", UtilDate.newDate(year, month + 1, 28));
 100
 101                         Event ev21 = new Event(21, "Universidad-Mauri", UtilDate.newDate(year, month, 22));
 102                         Event ev22 = new Event(22, "Universidad-Bryan", UtilDate.newDate(year, month, 20));
 103                         Event ev23 = new Event(23, "Universidad-Melisa", UtilDate.newDate(year, month, 21));
 104                         Event ev24 = new Event(24, "Universidad-Jorshua", UtilDate.newDate(year, month, 23));
 105                         Event ev25 = new Event(25, "Ermua - Eibar", UtilDate.newDate(year, month, 24));
 106                         Event ev26 = new Event(26, "Ermua - Donostia", UtilDate.newDate(year, month, 25));
 107                         Event ev27 = new Event(27, "Grandes - Pequeñas", UtilDate.newDate(year, month, 26));
 108                         Event ev28 = new Event(28, "Baloncesto - Basketball", UtilDate.newDate(year, month, 27));
 109                         Event ev29 = new Event(29, "Cristiano - Messi", UtilDate.newDate(year, month, 20));
 110                         Event ev30 = new Event(30, "Vinicius - Messi", UtilDate.newDate(year, month, 20));
 111                         Event ev31 = new Event(31, "Yo - Tu", UtilDate.newDate(year, month, 21));
 112                         Event ev32 = new Event(32, "La perra - La guarra", UtilDate.newDate(year, month, 21));
 113                         Event ev33 = new Event(33, "Madrid - Barcelona", UtilDate.newDate(year, month, 22));
 114                         Event ev34 = new Event(34, "Cibeles - Canaletas", UtilDate.newDate(year, month, 22));
 115                         Event ev35 = new Event(35, "Playa - Montaña", UtilDate.newDate(year, month, 23));
 116                         Event ev36 = new Event(36, "Betis - Sevilla", UtilDate.newDate(year, month, 23));
 117                         Event ev37 = new Event(37, "Eibar - Alaves", UtilDate.newDate(year, month, 22));
 118                         Event ev38 = new Event(38, "Manchester United - Manchester City", UtilDate.newDate(year, month, 21));
 119                         Event ev39 = new Event(39, "Fifa - Uefa", UtilDate.newDate(year, month, 20));
 120                         Event ev40 = new Event(40, "Juventus - Napoli", UtilDate.newDate(year, month, 23));
 121                         Event ev41 = new Event(41, "Psg - Manchester City", UtilDate.newDate(year, month, 20));
 122                         Event ev42 = new Event(42, "Leganes - Espanyol", UtilDate.newDate(year, month, 23));
 123                         Event ev43 = new Event(43, "Liverpool - Everton", UtilDate.newDate(year, month, 21));
 124                         Event ev44 = new Event(44, "Bayern Munich - Schalke", UtilDate.newDate(year, month, 22));
 125                         Event ev45 = new Event(45, "Bayer Leverkusen - Friburgo", UtilDate.newDate(year, month, 20));
 126                         Event ev46 = new Event(46, "Castellon - Lugo", UtilDate.newDate(year, month, 21));
 127                         Event ev47 = new Event(47, "Albacete - Real Madrid", UtilDate.newDate(year, month, 22));
 128
 129                         Question q7;
 130                         Question q8;
 131                         Question q9;
 132                         Question q10;
 133                         Question q11;
 134                         Question q12;
 135                         Question q13;
 136                         Question q14;
 137                         Question q15;
 138                         Question q16;
 139                         Question q17;
 140                         Question q18;
 141                         Question q19;
 142                         Question q20;
 143                         Question q21;
 144                         Question q22;
 145                         Question q23;
 146                         Question q24;
 147                         Question q25;
 148                         Question q26;
 149                         Question q27;
 150                         Question q28;
 151                         Question q29;
 152                         Question q30;
 153                         Question q31;
 154                         Question q32;
 155                         Question q33;
 156                         Question q34;
 157                         Question q35;
 158                         Question q36;
 159                         Question q37;
 160                         Question q38;
 161                         Question q39;
 162                         Question q40;
 163                         Question q41;
 164                         Question q42;
 165                         Question q43;
 166                         Question q44;
 167                         Question q45;
 168                         Question q46;
 169                         Question q47;
 170                         Question q48;
 171                         Question q49;
 172                         Question q50;
 173                         Question q51;
 174                         Question q52;
 175                         Question q53;
 176                         Question q54;
 177                         Question q55;
 178                         Question q56;
 179                         Question q57;
 180                         Question q58;
 181                         Question q59;
 182                         Question q60;
 183                         Question q61;
 184                         Question q62;
 185                         Question q63;
 186                         Question q64;
 187                         Question q65;
 188                         Question q66;
 189                         Question q67;
 190                         Question q68;
 191                         Question q69;
 192                         Question q70;
 193
 194                         q7 = ev21.addQuestion("¿Quién ganará?", 1);
 195                         q8 = ev22.addQuestion("¿Quién ganará?", 1);
 196                         q9 = ev23.addQuestion("¿Quién ganará?", 1);
 197                         q10 = ev24.addQuestion("¿Quién ganará?", 1);
 198                         q11 = ev25.addQuestion("¿Quién ganará?", 1);
 199                         q12 = ev25.addQuestion("¿Quién marcará primero?", 1);
 200                         q13 = ev25.addQuestion("¿Quién marcará más goles?", 1);
 201                         q14 = ev26.addQuestion("¿Cuál es más grande?", 1);
 202                         q15 = ev26.addQuestion("¿Cuál es más bonito?", 1);
 203                         q16 = ev26.addQuestion("¿Cuál tiene playa?", 1);
 204                         q17 = ev27.addQuestion("¿Grandes o pequeñas?", 1);
 205                         q18 = ev27.addQuestion("¿Cuál es más común?", 1);
 206                         q19 = ev27.addQuestion("¿De cuál has probado más?", 1);
 207                         q20 = ev28.addQuestion("¿Cómo se dice en castellano?", 1);
 208                         q21 = ev28.addQuestion("¿Cómo lo diría Sergio Ramos?", 1);
 209                         q22 = ev28.addQuestion("¿Cuál suele gustar más?", 1);
 210                         q23 = ev29.addQuestion("¿Quién es mejor?", 1);
 211                         q24 = ev29.addQuestion("¿Quíen cobra más?", 1);
 212                         q25 = ev29.addQuestion("¿Quién está jugando en España?", 1);
 213                         q26 = ev30.addQuestion("¿Quién es mejor?", 1);
 214                         q27 = ev30.addQuestion("¿Quién es argentino?", 1);
 215                         q28 = ev30.addQuestion("¿Quién juega en el Madrid?", 1);
 216                         q29 = ev31.addQuestion("¿Quién eres tú?", 1);
 217                         q30 = ev31.addQuestion("¿Quién será ingeniero?", 1);
 218                         q31 = ev31.addQuestion("¿Quién aprobará IS?", 1);
 219                         q32 = ev32.addQuestion("¿Cuál frecuenta más la esquina?", 1);
 220                         q33 = ev32.addQuestion("¿Cuál es la más sexy?", 1);
 221                         q34 = ev32.addQuestion("¿Cuál es más frecuente en las esquinas?", 1);
 222                         q35 = ev33.addQuestion("¿Cuál tiene playa?", 1);
 223                         q36 = ev33.addQuestion("¿Donde reside el gobierno de España?", 1);
 224                         q37 = ev33.addQuestion("¿Cuál es más poblada?", 1);
 225                         q38 = ev34.addQuestion("¿Cuál está en Madrid?", 1);
 226                         q39 = ev34.addQuestion("¿Cuál está en Cataluña?", 1);
 227                         q40 = ev34.addQuestion("¿A dónde suele ir el Madrid?", 1);
 228                         q41 = ev35.addQuestion("¿Cuál prefieres?", 1);
 229                         q42 = ev35.addQuestion("¿Cuál tiene agua?", 1);
 230                         q43 = ev35.addQuestion("¿A donde sueles ir más?", 1);
 231                         q44 = ev36.addQuestion("¿Qué equipo tiene más aficionados?", 1);
 232                         q45 = ev36.addQuestion("¿Qué equipo viste de blanco y rojo?", 1);
 233                         q46 = ev36.addQuestion("¿Cuál es una ciudad?", 1);
 234                         q47 = ev37.addQuestion("¿Qué equipo es de Guipuzcoa?", 1);
 235                         q48 = ev37.addQuestion("¿Cuántos goles se marcarán en el partido?", 1);
 236                         q49 = ev37.addQuestion("¿Quién marcará primero?", 1);
 237                         q50 = ev38.addQuestion("¿Qué equipo tiene más trofeos?", 1);
 238                         q51 = ev38.addQuestion("¿Cuántos goles se marcarán en el partido?", 1);
 239                         q52 = ev38.addQuestion("¿Qué equipo es más antiguo?", 1);
 240                         q53 = ev39.addQuestion("¿Cuál es más corrupta?", 1);
 241                         q54 = ev39.addQuestion("¿Cuál es más antigua?", 1);
 242                         q55 = ev40.addQuestion("¿Dónde juega Cristiano Ronaldo?", 1);
 243                         q56 = ev40.addQuestion("¿Cuál tiene más trofeos?", 1);
 244                         q57 = ev40.addQuestion("¿Quién ganara la liga este año?", 1);
 245                         q58 = ev41.addQuestion("¿Qué equipo es francés?", 1);
 246                         q59 = ev41.addQuestion("¿Qué equipo ganará la champions?", 1);
 247                         q60 = ev42.addQuestion("¿Qué equipo es de Madrid?", 1);
 248                         q61 = ev42.addQuestion("¿Qué equipo es de Cataluña?", 1);
 249                         q62 = ev43.addQuestion("¿Quién ganará?", 1);
 250                         q63 = ev43.addQuestion("¿Cuál tiene más trofeo?", 1);
 251                         q64 = ev44.addQuestion("¿Quién tiene más trofeos?", 1);
 252                         q65 = ev44.addQuestion("¿Quién ganará?", 1);
 253                         q66 = ev45.addQuestion("¿Quién tiene más ligas ganadas?", 1);
 254                         q67 = ev45.addQuestion("¿Cuál ha estado más temporadas en primera?", 1);
 255                         q68 = ev46.addQuestion("¿Quién ha estado más en primera?", 1);
 256                         q69 = ev46.addQuestion("¿Quién quedará mejor en liga?", 1);
 257                         q70 = ev47.addQuestion("¿Quién ganará?", 1);
 258
 259                         Forecast f1 = new Forecast(1, "Mauri", 1.2f, q7);
 260                         Forecast f2 = new Forecast(2, "Universidad", 1.3f, q7);
 261                         Forecast f3 = new Forecast(3, "Bryan", 1.2f, q8);
 262                         Forecast f4 = new Forecast(4, "Universidad", 1.2f, q8);
 263                         Forecast f5 = new Forecast(5, "Melisa", 1.4f, q9);
 264                         Forecast f6 = new Forecast(6, "Universidad", 1.2f, q9);
 265                         Forecast f7 = new Forecast(7, "Jorshua", 1.3f, q10);
 266                         Forecast f8 = new Forecast(8, "Universidad", 1.8f, q10);
 267                         Forecast f9 = new Forecast(9, "Ermua", 1.8f, q11);
 268                         Forecast f10 = new Forecast(10, "Eibar", 1.2f, q11);
 269                         Forecast f11 = new Forecast(11, "Ermua", 1.9f, q12);
 270                         Forecast f12 = new Forecast(12, "Eibar", 1.2f, q12);
 271                         Forecast f13 = new Forecast(13, "Ermua", 1.6f, q13);
 272                         Forecast f14 = new Forecast(14, "Eibar", 1.5f, q13);
 273                         Forecast f15 = new Forecast(15, "Ermua", 1.4f, q14);
 274                         Forecast f16 = new Forecast(16, "Donostia", 1.1f, q14);
 275                         Forecast f17 = new Forecast(17, "Ermua", 1.2f, q15);
 276                         Forecast f18 = new Forecast(18, "Donostia", 2f, q15);
 277                         Forecast f19 = new Forecast(19, "Ermua", 2f, q16);
 278                         Forecast f20 = new Forecast(20, "Donostia", 1.8f, q16);
 279                         Forecast f21 = new Forecast(21, "Grandes", 2.1f, q17);
 280                         Forecast f22 = new Forecast(22, "Pequeñas", 2.4f, q17);
 281                         Forecast f23 = new Forecast(23, "Grandes", 2.7f, q18);
 282                         Forecast f24 = new Forecast(24, "Pequeñas", 2.7f, q18);
 283                         Forecast f25 = new Forecast(25, "Grandes", 1.2f, q19);
 284                         Forecast f26 = new Forecast(26, "Pequeñas", 1.2f, q19);
 285                         Forecast f27 = new Forecast(27, "Baloncesto", 1.2f, q20);
 286                         Forecast f28 = new Forecast(28, "Basketball", 1.9f, q20);
 287                         Forecast f29 = new Forecast(29, "Baloncesto", 1.2f, q21);
 288                         Forecast f30 = new Forecast(30, "Basketball", 1.2f, q21);
 289                         Forecast f31 = new Forecast(31, "Baloncesto", 1.2f, q22);
 290                         Forecast f32 = new Forecast(32, "Basketball", 1.6f, q22);
 291                         Forecast f33 = new Forecast(33, "Cristiano", 1.2f, q23);
 292                         Forecast f34 = new Forecast(34, "Messi", 1.2f, q23);
 293                         Forecast f35 = new Forecast(35, "Cristiano", 1.2f, q24);
 294                         Forecast f36 = new Forecast(36, "Messi", 1.4f, q24);
 295                         Forecast f37 = new Forecast(37, "Cristiano", 1.2f, q25);
 296                         Forecast f38 = new Forecast(38, "Messi", 1.3f, q25);
 297                         Forecast f39 = new Forecast(39, "Vinicius", 1.2f, q26);
 298                         Forecast f40 = new Forecast(40, "Messi", 1.2f, q26);
 299                         Forecast f41 = new Forecast(41, "Vinicius", 2.5f, q27);
 300                         Forecast f42 = new Forecast(42, "Messi", 1.2f, q27);
 301                         Forecast f43 = new Forecast(43, "Vinicius", 1.2f, q28);
 302                         Forecast f44 = new Forecast(44, "Messi", 1.2f, q28);
 303                         Forecast f45 = new Forecast(45, "Yo", 1.2f, q29);
 304                         Forecast f46 = new Forecast(46, "Tu", 2.6f, q29);
 305                         Forecast f47 = new Forecast(47, "Yo", 1.2f, q30);
 306                         Forecast f48 = new Forecast(48, "Tu", 2.8f, q30);
 307                         Forecast f49 = new Forecast(49, "Yo", 1.2f, q31);
 308                         Forecast f50 = new Forecast(50, "Tu", 2.7f, q31);
 309                         Forecast f51 = new Forecast(51, "La perra", 1.2f, q32);
 310                         Forecast f52 = new Forecast(52, "La guarra", 1.2f, q32);
 311                         Forecast f53 = new Forecast(53, "La perra", 1.2f, q33);
 312                         Forecast f54 = new Forecast(54, "La guarra", 2.3f, q33);
 313                         Forecast f55 = new Forecast(55, "La perra", 1.2f, q34);
 314                         Forecast f56 = new Forecast(56, "La guarra", 2.8f, q34);
 315                         Forecast f57 = new Forecast(57, "Madrid", 1.2f, q35);
 316                         Forecast f58 = new Forecast(58, "Barcelona", 1.2f, q35);
 317                         Forecast f59 = new Forecast(59, "Madrid", 3f, q36);
 318                         Forecast f60 = new Forecast(60, "Barcelona", 1.2f, q36);
 319                         Forecast f61 = new Forecast(61, "Madrid", 3.2f, q37);
 320                         Forecast f62 = new Forecast(62, "Barcelona", 1.2f, q37);
 321                         Forecast f63 = new Forecast(63, "Cibeles", 1.2f, q38);
 322                         Forecast f64 = new Forecast(64, "Canaletas", 1.2f, q38);
 323                         Forecast f65 = new Forecast(65, "Cibeles", 3.6f, q39);
 324                         Forecast f66 = new Forecast(66, "Canaletas", 1.2f, q39);
 325                         Forecast f67 = new Forecast(67, "Cibeles", 1.2f, q40);
 326                         Forecast f68 = new Forecast(68, "Canaletas", 3.5f, q40);
 327                         Forecast f69 = new Forecast(69, "Playa", 1.2f, q41);
 328                         Forecast f70 = new Forecast(70, "Montaña", 1.2f, q41);
 329                         Forecast f71 = new Forecast(71, "Playa", 1.2f, q42);
 330                         Forecast f72 = new Forecast(72, "Montaña", 3.7f, q42);
 331                         Forecast f73 = new Forecast(73, "Playa", 1.2f, q43);
 332                         Forecast f74 = new Forecast(74, "Montaña", 1.2f, q43);
 333                         Forecast f75 = new Forecast(75, "Betis", 3.9f, q44);
 334                         Forecast f76 = new Forecast(76, "Sevilla", 1.2f, q44);
 335                         Forecast f77 = new Forecast(77, "Betis", 1.2f, q45);
 336                         Forecast f78 = new Forecast(78, "Sevilla", 1.2f, q45);
 337                         Forecast f79 = new Forecast(79, "Betis", 1.2f, q46);
 338                         Forecast f80 = new Forecast(80, "Sevilla", 3.7f, q46);
 339                         Forecast f81 = new Forecast(81, "Eibar", 1.2f, q47);
 340                         Forecast f82 = new Forecast(82, "Alaves", 1.2f, q47);
 341                         Forecast f83 = new Forecast(83, "0", 1.2f, q48);
 342                         Forecast f84 = new Forecast(84, "1", 3.5f, q48);
 343                         Forecast f85 = new Forecast(85, "2", 1.2f, q48);
 344                         Forecast f86 = new Forecast(86, "3", 1.2f, q48);
 345                         Forecast f87 = new Forecast(87, "4", 1.2f, q48);
 346                         Forecast f88 = new Forecast(88, "5", 4f, q48);
 347                         Forecast f89 = new Forecast(89, "Eibar", 1.2f, q49);
 348                         Forecast f90 = new Forecast(90, "Alaves", 1.2f, q49);
 349                         Forecast f91 = new Forecast(91, "Manchester United", 4.2f, q50);
 350                         Forecast f92 = new Forecast(92, "Manchester City", 1.2f, q50);
 351                         Forecast f93 = new Forecast(93, "0", 1.2f, q51);
 352                         Forecast f94 = new Forecast(94, "1", 4.7f, q51);
 353                         Forecast f95 = new Forecast(95, "2", 1.2f, q51);
 354                         Forecast f96 = new Forecast(96, "3", 5.6f, q51);
 355                         Forecast f97 = new Forecast(97, "4", 1.2f, q51);
 356                         Forecast f98 = new Forecast(98, "5", 1.2f, q51);
 357                         Forecast f99 = new Forecast(99, "Manchester United", 3.7f, q52);
 358                         Forecast f100 = new Forecast(100, "Manchester City", 1.2f, q52);
 359                         Forecast f101 = new Forecast(101, "Fifa", 1.2f, q53);
 360                         Forecast f102 = new Forecast(102, "Uefa", 4.8f, q53);
 361                         Forecast f103 = new Forecast(103, "Fifa", 1.2f, q54);
 362                         Forecast f104 = new Forecast(104, "Uefa", 4.9f, q54);
 363                         Forecast f105 = new Forecast(105, "Juventus", 1.2f, q55);
 364                         Forecast f106 = new Forecast(106, "Napoli", 1.2f, q55);
 365                         Forecast f107 = new Forecast(107, "Juventus", 4.2f, q56);
 366                         Forecast f108 = new Forecast(108, "Napoli", 1.2f, q56);
 367                         Forecast f109 = new Forecast(109, "Juventus", 4.6f, q57);
 368                         Forecast f110 = new Forecast(110, "Napoli", 1.2f, q57);
 369                         Forecast f111 = new Forecast(111, "Psg", 1.2f, q58);
 370                         Forecast f112 = new Forecast(112, "Manchester City", 1.2f, q58);
 371                         Forecast f113 = new Forecast(113, "Psg", 1.2f, q59);
 372                         Forecast f114 = new Forecast(114, "Manchester City", 1.2f, q59);
 373                         Forecast f115 = new Forecast(115, "Leganes", 4.4f, q60);
 374                         Forecast f116 = new Forecast(116, "Espanyol", 1.2f, q60);
 375                         Forecast f117 = new Forecast(117, "Leganes", 1.2f, q61);
 376                         Forecast f118 = new Forecast(118, "Espanyol", 4.1f, q61);
 377                         Forecast f119 = new Forecast(119, "Liverpool", 5f, q62);
 378                         Forecast f120 = new Forecast(120, "Everton", 1.2f, q62);
 379                         Forecast f121 = new Forecast(121, "Liverpool", 1.2f, q63);
 380                         Forecast f122 = new Forecast(122, "Everton", 1.9f, q63);
 381                         Forecast f123 = new Forecast(123, "Bayern Munich", 1.2f, q64);
 382                         Forecast f124 = new Forecast(124, "Schalke", 2.9f, q64);
 383                         Forecast f125 = new Forecast(125, "Bayern Munich", 1.2f, q65);
 384                         Forecast f126 = new Forecast(126, "Schalke", 1.2f, q65);
 385                         Forecast f127 = new Forecast(127, "Bayer Leverkusen", 1.2f, q66);
 386                         Forecast f128 = new Forecast(128, "Friburgo", 1.2f, q66);
 387                         Forecast f129 = new Forecast(129, "Bayer Leverkusen", 1.2f, q67);
 388                         Forecast f130 = new Forecast(130, "Friburgo", 1.2f, q67);
 389                         Forecast f131 = new Forecast(131, "Castellon", 2.7f, q68);
 390                         Forecast f132 = new Forecast(132, "Lugo", 1.2f, q68);
 391                         Forecast f133 = new Forecast(133, "Castellon", 1.2f, q69);
 392                         Forecast f134 = new Forecast(134, "Lugo", 3.9f, q69);
 393                         Forecast f135 = new Forecast(135, "Albacete", 1.2f, q70);
 394                         Forecast f136 = new Forecast(136, "Real Madrid", 5.9f, q70);
 395
 396                         q7.addForecast(f1);
 397                         q7.addForecast(f2);
 398                         q8.addForecast(f3);
 399                         q8.addForecast(f4);
 400                         q9.addForecast(f5);
 401                         q9.addForecast(f6);
 402                         q10.addForecast(f7);
 403                         q10.addForecast(f8);
 404                         q11.addForecast(f9);
 405                         q11.addForecast(f10);
 406                         q12.addForecast(f11);
 407                         q12.addForecast(f12);
 408                         q13.addForecast(f13);
 409                         q13.addForecast(f14);
 410                         q14.addForecast(f15);
 411                         q14.addForecast(f16);
 412                         q15.addForecast(f17);
 413                         q15.addForecast(f18);
 414                         q16.addForecast(f19);
 415                         q16.addForecast(f20);
 416                         q17.addForecast(f21);
 417                         q17.addForecast(f22);
 418                         q18.addForecast(f23);
 419                         q18.addForecast(f24);
 420                         q19.addForecast(f25);
 421                         q19.addForecast(f26);
 422                         q20.addForecast(f27);
 423                         q20.addForecast(f28);
 424                         q21.addForecast(f29);
 425                         q21.addForecast(f30);
 426                         q22.addForecast(f31);
 427                         q22.addForecast(f32);
 428                         q23.addForecast(f33);
 429                         q23.addForecast(f34);
 430                         q24.addForecast(f35);
 431                         q24.addForecast(f36);
 432                         q25.addForecast(f37);
 433                         q25.addForecast(f38);
 434                         q26.addForecast(f39);
 435                         q26.addForecast(f40);
 436                         q27.addForecast(f41);
 437                         q27.addForecast(f42);
 438                         q28.addForecast(f43);
 439                         q28.addForecast(f44);
 440                         q29.addForecast(f45);
 441                         q29.addForecast(f46);
 442                         q30.addForecast(f47);
 443                         q30.addForecast(f48);
 444                         q31.addForecast(f49);
 445                         q31.addForecast(f50);
 446                         q32.addForecast(f51);
 447                         q32.addForecast(f52);
 448                         q33.addForecast(f53);
 449                         q33.addForecast(f54);
 450                         q34.addForecast(f55);
 451                         q34.addForecast(f56);
 452                         q35.addForecast(f57);
 453                         q35.addForecast(f58);
 454                         q36.addForecast(f59);
 455                         q36.addForecast(f60);
 456                         q37.addForecast(f61);
 457                         q37.addForecast(f62);
 458                         q38.addForecast(f63);
 459                         q38.addForecast(f64);
 460                         q39.addForecast(f65);
 461                         q39.addForecast(f66);
 462                         q40.addForecast(f67);
 463                         q40.addForecast(f68);
 464                         q41.addForecast(f69);
 465                         q41.addForecast(f70);
 466                         q42.addForecast(f71);
 467                         q42.addForecast(f72);
 468                         q43.addForecast(f73);
 469                         q43.addForecast(f74);
 470                         q44.addForecast(f75);
 471                         q44.addForecast(f76);
 472                         q45.addForecast(f77);
 473                         q45.addForecast(f78);
 474                         q46.addForecast(f79);
 475                         q46.addForecast(f80);
 476                         q47.addForecast(f81);
 477                         q47.addForecast(f82);
 478                         q48.addForecast(f83);
 479                         q48.addForecast(f84);
 480                         q48.addForecast(f85);
 481                         q48.addForecast(f86);
 482                         q48.addForecast(f87);
 483                         q48.addForecast(f88);
 484                         q49.addForecast(f89);
 485                         q49.addForecast(f90);
 486                         q50.addForecast(f91);
 487                         q50.addForecast(f92);
 488                         q51.addForecast(f93);
 489                         q51.addForecast(f94);
 490                         q51.addForecast(f95);
 491                         q51.addForecast(f96);
 492                         q51.addForecast(f97);
 493                         q51.addForecast(f98);
 494                         q52.addForecast(f99);
 495                         q52.addForecast(f100);
 496                         q53.addForecast(f101);
 497                         q53.addForecast(f102);
 498                         q54.addForecast(f103);
 499                         q54.addForecast(f104);
 500                         q55.addForecast(f105);
 501                         q55.addForecast(f106);
 502                         q56.addForecast(f107);
 503                         q56.addForecast(f108);
 504                         q57.addForecast(f109);
 505                         q57.addForecast(f110);
 506                         q58.addForecast(f111);
 507                         q58.addForecast(f112);
 508                         q59.addForecast(f113);
 509                         q59.addForecast(f114);
 510                         q60.addForecast(f115);
 511                         q60.addForecast(f116);
 512                         q61.addForecast(f117);
 513                         q61.addForecast(f118);
 514                         q62.addForecast(f119);
 515                         q62.addForecast(f120);
 516                         q63.addForecast(f121);
 517                         q63.addForecast(f122);
 518                         q64.addForecast(f123);
 519                         q64.addForecast(f124);
 520                         q65.addForecast(f125);
 521                         q65.addForecast(f126);
 522                         q66.addForecast(f127);
 523                         q66.addForecast(f128);
 524                         q67.addForecast(f129);
 525                         q67.addForecast(f130);
 526                         q68.addForecast(f131);
 527                         q68.addForecast(f132);
 528                         q69.addForecast(f133);
 529                         q69.addForecast(f134);
 530                         q70.addForecast(f135);
 531                         q70.addForecast(f136);
 532
 533                         User useradmin = new AdminUser("admin", "admin", "Pepe", "Lopez");
 534                         User usuario = new RegularUser("mauri", "Mauri1?", "Mauri", "Contreras", "01/01/1997", "mauri@gmail.com",
 535                                         "ES11 1111 1111 1111", 123456789, "", 80);
 536                         User usuario2 = new RegularUser("bryan", "Bryan1?", "Bryan", "Sánchez", "01/01/1997", "bryan@gmail.com", "",
 537                                         123454321, "", 50);
 538                         db.persist(usuario);
 539                         db.persist(usuario2);
 540                         db.persist(useradmin);
 541                         Question q1;
 542                         Question q2;
 543                         Question q3;
 544                         Question q4;
 545                         Question q5;
 546                         Question q6;
 547
 548                         if (Locale.getDefault().equals(new Locale("es"))) {
 549                                 q1 = ev1.addQuestion("¿Quién ganará el partido?", 1);
 550                                 q2 = ev1.addQuestion("¿Quién meterá el primer gol?", 2);
 551                                 q3 = ev11.addQuestion("¿Quién ganará el partido?", 1);
 552                                 q4 = ev11.addQuestion("¿Cuántos goles se marcarán?", 2);
 553                                 q5 = ev17.addQuestion("¿Quién ganará el partido?", 1);
 554                                 q6 = ev17.addQuestion("¿Habrá goles en la primera parte?", 2);
 555                         } else if (Locale.getDefault().equals(new Locale("en"))) {
 556                                 q1 = ev1.addQuestion("Who will win the match?", 1);
 557                                 q2 = ev1.addQuestion("Who will score first?", 2);
 558                                 q3 = ev11.addQuestion("Who will win the match?", 1);
 559                                 q4 = ev11.addQuestion("How many goals will be scored in the match?", 2);
 560                                 q5 = ev17.addQuestion("Who will win the match?", 1);
 561                                 q6 = ev17.addQuestion("Will there be goals in the first half?", 2);
 562                         } else {
 563                                 q1 = ev1.addQuestion("Zeinek irabaziko du partidua?", 1);
 564                                 q2 = ev1.addQuestion("Zeinek sartuko du lehenengo gola?", 2);
 565                                 q3 = ev11.addQuestion("Zeinek irabaziko du partidua?", 1);
 566                                 q4 = ev11.addQuestion("Zenbat gol sartuko dira?", 2);
 567                                 q5 = ev17.addQuestion("Zeinek irabaziko du partidua?", 1);
 568                                 q6 = ev17.addQuestion("Golak sartuko dira lehenengo zatian?", 2);
 569
 570                         }
 571
 572                         db.persist(ev1);
 573                         db.persist(ev2);
 574                         db.persist(ev3);
 575                         db.persist(ev4);
 576                         db.persist(ev5);
 577                         db.persist(ev6);
 578                         db.persist(ev7);
 579                         db.persist(ev8);
 580                         db.persist(ev9);
 581                         db.persist(ev10);
 582                         db.persist(ev11);
 583                         db.persist(ev12);
 584                         db.persist(ev13);
 585                         db.persist(ev14);
 586                         db.persist(ev15);
 587                         db.persist(ev16);
 588                         db.persist(ev17);
 589                         db.persist(ev18);
 590                         db.persist(ev19);
 591                         db.persist(ev20);
 592                         db.persist(ev21);
 593                         db.persist(ev22);
 594                         db.persist(ev23);
 595                         db.persist(ev24);
 596                         db.persist(ev25);
 597                         db.persist(ev26);
 598                         db.persist(ev27);
 599                         db.persist(ev28);
 600                         db.persist(ev29);
 601                         db.persist(ev30);
 602                         db.persist(ev31);
 603                         db.persist(ev32);
 604                         db.persist(ev33);
 605                         db.persist(ev34);
 606                         db.persist(ev35);
 607                         db.persist(ev36);
 608                         db.persist(ev37);
 609                         db.persist(ev38);
 610                         db.persist(ev39);
 611                         db.persist(ev40);
 612                         db.persist(ev41);
 613                         db.persist(ev42);
 614                         db.persist(ev43);
 615                         db.persist(ev44);
 616                         db.persist(ev45);
 617                         db.persist(ev46);
 618                         db.persist(ev47);
 619
 620                         db.persist(q1);
 621                         db.persist(q2);
 622                         db.persist(q3);
 623                         db.persist(q4);
 624                         db.persist(q5);
 625                         db.persist(q6);
 626                         db.persist(q7);
 627                         db.persist(q8);
 628                         db.persist(q9);
 629                         db.persist(q10);
 630                         db.persist(q11);
 631                         db.persist(q12);
 632                         db.persist(q13);
 633                         db.persist(q14);
 634                         db.persist(q15);
 635                         db.persist(q16);
 636                         db.persist(q17);
 637                         db.persist(q18);
 638                         db.persist(q19);
 639                         db.persist(q20);
 640                         db.persist(q21);
 641                         db.persist(q22);
 642                         db.persist(q23);
 643                         db.persist(q24);
 644                         db.persist(q25);
 645                         db.persist(q26);
 646                         db.persist(q27);
 647                         db.persist(q28);
 648                         db.persist(q29);
 649                         db.persist(q30);
 650                         db.persist(q31);
 651                         db.persist(q32);
 652                         db.persist(q33);
 653                         db.persist(q34);
 654                         db.persist(q35);
 655                         db.persist(q36);
 656                         db.persist(q37);
 657                         db.persist(q38);
 658                         db.persist(q39);
 659                         db.persist(q40);
 660                         db.persist(q41);
 661                         db.persist(q42);
 662                         db.persist(q43);
 663                         db.persist(q44);
 664                         db.persist(q45);
 665                         db.persist(q46);
 666                         db.persist(q47);
 667                         db.persist(q48);
 668                         db.persist(q49);
 669                         db.persist(q50);
 670                         db.persist(q51);
 671                         db.persist(q52);
 672                         db.persist(q53);
 673                         db.persist(q54);
 674                         db.persist(q55);
 675                         db.persist(q56);
 676                         db.persist(q57);
 677                         db.persist(q58);
 678                         db.persist(q59);
 679                         db.persist(q60);
 680                         db.persist(q61);
 681                         db.persist(q62);
 682                         db.persist(q63);
 683                         db.persist(q64);
 684                         db.persist(q65);
 685                         db.persist(q66);
 686                         db.persist(q67);
 687                         db.persist(q68);
 688                         db.persist(q69);
 689                         db.persist(q70);
 690
 691                         db.persist(f1);
 692                         db.persist(f2);
 693                         db.persist(f3);
 694                         db.persist(f4);
 695                         db.persist(f5);
 696                         db.persist(f6);
 697                         db.persist(f7);
 698                         db.persist(f8);
 699                         db.persist(f9);
 700                         db.persist(f10);
 701                         db.persist(f11);
 702                         db.persist(f12);
 703                         db.persist(f13);
 704                         db.persist(f14);
 705                         db.persist(f15);
 706                         db.persist(f16);
 707                         db.persist(f17);
 708                         db.persist(f18);
 709                         db.persist(f19);
 710                         db.persist(f20);
 711                         db.persist(f21);
 712                         db.persist(f22);
 713                         db.persist(f23);
 714                         db.persist(f24);
 715                         db.persist(f25);
 716                         db.persist(f26);
 717                         db.persist(f27);
 718                         db.persist(f28);
 719                         db.persist(f29);
 720                         db.persist(f30);
 721                         db.persist(f31);
 722                         db.persist(f32);
 723                         db.persist(f33);
 724                         db.persist(f34);
 725                         db.persist(f35);
 726                         db.persist(f36);
 727                         db.persist(f37);
 728                         db.persist(f38);
 729                         db.persist(f39);
 730                         db.persist(f40);
 731                         db.persist(f41);
 732                         db.persist(f42);
 733                         db.persist(f43);
 734                         db.persist(f44);
 735                         db.persist(f45);
 736                         db.persist(f46);
 737                         db.persist(f47);
 738                         db.persist(f48);
 739                         db.persist(f49);
 740                         db.persist(f50);
 741                         db.persist(f51);
 742                         db.persist(f52);
 743                         db.persist(f53);
 744                         db.persist(f54);
 745                         db.persist(f55);
 746                         db.persist(f56);
 747                         db.persist(f57);
 748                         db.persist(f58);
 749                         db.persist(f59);
 750                         db.persist(f60);
 751                         db.persist(f61);
 752                         db.persist(f62);
 753                         db.persist(f63);
 754                         db.persist(f64);
 755                         db.persist(f65);
 756                         db.persist(f66);
 757                         db.persist(f67);
 758                         db.persist(f68);
 759                         db.persist(f69);
 760                         db.persist(f70);
 761                         db.persist(f71);
 762                         db.persist(f72);
 763                         db.persist(f73);
 764                         db.persist(f74);
 765                         db.persist(f75);
 766                         db.persist(f76);
 767                         db.persist(f77);
 768                         db.persist(f78);
 769                         db.persist(f79);
 770                         db.persist(f80);
 771                         db.persist(f81);
 772                         db.persist(f82);
 773                         db.persist(f83);
 774                         db.persist(f84);
 775                         db.persist(f85);
 776                         db.persist(f86);
 777                         db.persist(f87);
 778                         db.persist(f88);
 779                         db.persist(f89);
 780                         db.persist(f90);
 781                         db.persist(f91);
 782                         db.persist(f92);
 783                         db.persist(f93);
 784                         db.persist(f94);
 785                         db.persist(f95);
 786                         db.persist(f96);
 787                         db.persist(f97);
 788                         db.persist(f98);
 789                         db.persist(f99);
 790                         db.persist(f100);
 791                         db.persist(f101);
 792                         db.persist(f102);
 793                         db.persist(f103);
 794                         db.persist(f104);
 795                         db.persist(f105);
 796                         db.persist(f106);
 797                         db.persist(f107);
 798                         db.persist(f108);
 799                         db.persist(f109);
 800                         db.persist(f110);
 801                         db.persist(f111);
 802                         db.persist(f112);
 803                         db.persist(f113);
 804                         db.persist(f114);
 805                         db.persist(f115);
 806                         db.persist(f116);
 807                         db.persist(f117);
 808                         db.persist(f118);
 809                         db.persist(f119);
 810                         db.persist(f120);
 811                         db.persist(f121);
 812                         db.persist(f122);
 813                         db.persist(f123);
 814                         db.persist(f124);
 815                         db.persist(f125);
 816                         db.persist(f126);
 817                         db.persist(f127);
 818                         db.persist(f128);
 819                         db.persist(f129);
 820                         db.persist(f130);
 821                         db.persist(f131);
 822                         db.persist(f132);
 823                         db.persist(f133);
 824                         db.persist(f134);
 825                         db.persist(f135);
 826                         db.persist(f136);
 827
 828                         db.getTransaction().commit();
 829                         System.out.println("Db initialized");
 830                 } catch (Exception e) {
 831                         e.printStackTrace();
 832                 }
 833         }
 834
 835         /**
 836          * This method creates a question for an event, with a question text and the
 837          * minimum bet
 838          *
 839          * @param event      to which question is added
 840          * @param question   text of the question
 841          * @param betMinimum minimum quantity of the bet
 842          * @return the created question, or null, or an exception
 843          * @throws QuestionAlreadyExist if the same question already exists for the
 844          *                              event
 845          */
 846         public Question createQuestion(Event event, String question, float betMinimum) throws QuestionAlreadyExist {
 847                 System.out.println(">> DataAccess: createQuestion=> event= " + event + " question= " + question + " betMinimum="
 848                                 + betMinimum);
 849
 850                 Event ev = db.find(Event.class, event.getEventNumber());
 851
 852                 if (ev.DoesQuestionExists(question))
 853                         throw new QuestionAlreadyExist(ResourceBundle.getBundle("Etiquetas").getString("ErrorQueryAlreadyExist"));
 854
 855                 db.getTransaction().begin();
 856                 Question q = ev.addQuestion(question, betMinimum);
 857                 // db.persist(q);
 858                 db.persist(ev); // db.persist(q) not required when CascadeType.PERSIST is added in questions
 859                 // property of Event class
 860                 // @OneToMany(fetch=FetchType.EAGER, cascade=CascadeType.PERSIST)
 861                 db.getTransaction().commit();
 862                 return q;
 863
 864         }
 865
 866         public Vector<Question> getAllQuestions() {
 867                 System.out.println(">> DataAccess: getAllQuestions");
 868                 Vector<Question> res = new Vector<Question>();
 869                 TypedQuery<Question> query = db.createQuery("SELECT qu FROM Question qu", Question.class);
 870                 List<Question> questions = query.getResultList();
 871                 for (Question qu : questions) {
 872                         System.out.println(qu.toString());
 873                         res.add(qu);
 874                 }
 875                 return res;
 876         }
 877
 878         /**
 879          * This method retrieves from the database the events of a given date
 880          *
 881          * @param date in which events are retrieved
 882          * @return collection of events
 883          */
 884         public Vector<Event> getEvents(Date date) {
 885                 System.out.println(">> DataAccess: getEvents");
 886                 Vector<Event> res = new Vector<Event>();
 887                 TypedQuery<Event> query = db.createQuery("SELECT ev FROM Event ev WHERE ev.eventDate=?1", Event.class);
 888                 query.setParameter(1, date);
 889                 List<Event> events = query.getResultList();
 890                 for (Event ev : events) {
 891                         System.out.println(ev.toString());
 892                         res.add(ev);
 893                 }
 894                 return res;
 895         }
 896
 897         public Vector<Event> getAllEvents() {
 898                 System.out.println(">> DataAccess: getAllEvents");
 899                 Vector<Event> res = new Vector<Event>();
 900                 TypedQuery<Event> query = db.createQuery("SELECT ev FROM Event ev", Event.class);
 901                 List<Event> events = query.getResultList();
 902                 for (Event ev : events) {
 903                         System.out.println(ev.toString());
 904                         res.add(ev);
 905                 }
 906                 return res;
 907         }
 908
 909         /**
 910          * This method retrieves from the database the dates a month for which there are
 911          * events
 912          *
 913          * @param date of the month for which days with events want to be retrieved
 914          * @return collection of dates
 915          */
 916         public Vector<Date> getEventsMonth(Date date) {
 917                 System.out.println(">> DataAccess: getEventsMonth");
 918                 Vector<Date> res = new Vector<Date>();
 919
 920                 Date firstDayMonthDate = UtilDate.firstDayMonth(date);
 921                 Date lastDayMonthDate = UtilDate.lastDayMonth(date);
 922
 923                 TypedQuery<Date> query = db.createQuery(
 924                                 "SELECT DISTINCT ev.eventDate FROM Event ev WHERE ev.eventDate BETWEEN ?1 and ?2", Date.class);
 925                 query.setParameter(1, firstDayMonthDate);
 926                 query.setParameter(2, lastDayMonthDate);
 927                 List<Date> dates = query.getResultList();
 928                 for (Date d : dates) {
 929                         System.out.println(d.toString());
 930                         res.add(d);
 931                 }
 932                 return res;
 933         }
 934
 935         public void open(boolean initializeMode) {
 936
 937                 System.out.println("Opening DataAccess instance => isDatabaseLocal: " + c.isDatabaseLocal()
 938                                 + " getDatabBaseOpenMode: " + c.getDataBaseOpenMode());
 939
 940                 String fileName = c.getDbFilename();
 941                 if (initializeMode) {
 942                         fileName = fileName + ";drop";
 943                         System.out.println("Deleting the DataBase");
 944                 }
 945
 946                 if (c.isDatabaseLocal()) {
 947                         emf = Persistence.createEntityManagerFactory("objectdb:" + fileName);
 948                         db = emf.createEntityManager();
 949                 } else {
 950                         Map<String, String> properties = new HashMap<String, String>();
 951                         properties.put("javax.persistence.jdbc.user", c.getUser());
 952                         properties.put("javax.persistence.jdbc.password", c.getPassword());
 953
 954                         emf = Persistence.createEntityManagerFactory(
 955                                         "objectdb://" + c.getDatabaseNode() + ":" + c.getDatabasePort() + "/" + fileName, properties);
 956
 957                         db = emf.createEntityManager();
 958                 }
 959
 960         }
 961
 962         public boolean existQuestion(Event event, String question) {
 963                 System.out.println(">> DataAccess: existQuestion=> event= " + event + " question= " + question);
 964                 Event ev = db.find(Event.class, event.getEventNumber());
 965                 return ev.DoesQuestionExists(question);
 966
 967         }
 968
 969         public void close() {
 970                 db.close();
 971                 System.out.println("DataBase closed");
 972         }
 973
 974         public User login(String username, String pass) throws UserDoesNotExistException, IncorrectPassException {
 975
 976                 User usuario = db.find(User.class, username);
 977
 978                 if (usuario == null) {
 979                         throw new exceptions.UserDoesNotExistException("El usuario no existe");
 980                 }
 981                 if (!pass.equals(usuario.getUserPass())) {
 982                         throw new exceptions.IncorrectPassException("Contraseña incorrecta");
 983                 }
 984                 return usuario;
 985
 986         }
 987
 988         public boolean insertEvent(Event pEvento) {
 989                 try {
 990                         db.getTransaction().begin();
 991                         db.persist(pEvento);
 992                         db.getTransaction().commit();
 993                         return true;
 994                 } catch (Exception e) {
 995                         e.printStackTrace();
 996                         return false;
 997                 }
 998         }
 999
1000         public boolean validoUsuario(String puser) throws UserAlreadyExistException {
1001
1002                 User usuarioBD = db.find(User.class, puser);
1003                 if (usuarioBD == null) {
1004                         return true;
1005                 } else {
1006                         throw new UserAlreadyExistException("Ese usuario ya existe");
1007                 }
1008
1009         }
1010
1011         public RegularUser registrar(String user, String pass, String name, String lastName, String birthDate, String email,
1012                         String account, Integer numb, String address, float balance) throws UserAlreadyExistException {
1013                 db.getTransaction().begin();
1014                 RegularUser u = new RegularUser(user, pass, name, lastName, birthDate, email, account, numb, address, balance);
1015
1016                 boolean b = validoUsuario(user);
1017
1018                 if (b) {
1019                         db.persist(u);
1020                         db.getTransaction().commit();
1021                 }
1022
1023                 return u;
1024         }
1025
1026         public int getNumberEvents() {
1027                 db.getTransaction().begin();
1028                 TypedQuery<Event> query = db.createQuery("SELECT ev FROM Event ev ", Event.class);
1029                 return query.getResultList().size();
1030         }
1031
1032         public boolean existEvent(Event event) {
1033                 System.out.println(">> DataAccess: existEvent=> event= " + event);
1034
1035                 Vector<Event> eventosmismodia = getEvents(event.getEventDate());
1036
1037                 for (Event e : eventosmismodia) {
1038                         if (e.getDescription().equals(event.getDescription())) {
1039                                 return true;
1040                         }
1041                 }
1042
1043                 return false;
1044         }
1045
1046         public boolean deleteEvent(Event evento) {
1047                 try {
1048                         db.getTransaction().begin();
1049
1050                         Event event1 = db.find(Event.class, evento.getEventDate());
1051                         Query query1 = db.createQuery("DELETE FROM Event e WHERE e.getEventNumber()=?1");
1052                         query1.setParameter(1, evento.getEventNumber());
1053
1054                         TypedQuery<Question> query2 = db.createQuery("SELECT qu FROM Question qu", Question.class);
1055                         List<Question> preguntasDB = query2.getResultList();
1056
1057                         for (Question q : preguntasDB) {
1058                                 if (q.getEvent() == evento) {
1059                                         db.remove(q);
1060                                         System.out.println("pregunta eliminada: " + q);
1061                                 } else {
1062                                         System.out.println("pregunta NO ELIMINADA");
1063                                 }
1064                         }
1065
1066                         int events = query1.executeUpdate();
1067                         db.getTransaction().commit();
1068                         System.out.println("Evento eliminado: " + evento);
1069
1070                         return true;
1071                 } catch (Exception e) {
1072                         e.printStackTrace();
1073                         return false;
1074                 }
1075
1076         }
1077
1078         public Forecast insertForecast(Question q, String forecast, float fee) {
1079                 System.out.println(">> DataAccess: insertForecast=> question= " + q + " forecast= " + forecast + " fee=" + fee);
1080
1081                 try {
1082                         db.getTransaction().begin();
1083                         Question qe = db.find(Question.class, q.getQuestionNumber());
1084                         if (qe.DoesForecastExists(forecast))
1085                                 return null;
1086                         Forecast f = new Forecast(getMaxIdForecastInDB()+1, forecast, fee, qe);
1087                         qe.addForecast(f);
1088                         db.persist(qe);
1089                         db.getTransaction().commit();
1090                         return f;
1091                 } catch (Exception e) {
1092                         e.printStackTrace();
1093                         return null;
1094                 }
1095
1096         }
1097
1098         public int getNumberForecasts() {
1099                 db.getTransaction().begin();
1100                 TypedQuery<Forecast> query = db.createQuery("SELECT f FROM Forecast f ", Forecast.class);
1101                 return query.getResultList().size();
1102         }
1103
1104         public Vector<Forecast> getForecasts() {
1105                 db.getTransaction().begin();
1106                 Vector<Forecast> res = new Vector<Forecast>();
1107                 TypedQuery<Forecast> query = db.createQuery("SELECT f FROM Forecast f ", Forecast.class);
1108                 List<Forecast> forecasts = query.getResultList();
1109                 for (Forecast f : forecasts) {
1110                         System.out.println(f.toString());
1111                         res.add(f);
1112                 }
1113                 return res;
1114         }
1115
1116         public Vector<Forecast> getForecasts(Question pregunta) {
1117                 db.getTransaction().begin();
1118                 Vector<Forecast> res = new Vector<Forecast>();
1119                 TypedQuery<Forecast> query = db.createQuery("SELECT f FROM Forecast f WHERE f.getQuestion()=?1",
1120                                 Forecast.class);
1121                 query.setParameter(1, pregunta);
1122                 List<Forecast> forecasts = query.getResultList();
1123                 for (Forecast f : forecasts) {
1124                         System.out.println(f.toString());
1125                         res.add(f);
1126                 }
1127                 return res;
1128         }
1129
1130         public boolean existForecast(Forecast f) {
1131                 System.out.println(">> DataAccess: existForecast=> forecast= " + f);
1132                 return db.find(Forecast.class, f.getForecast()) != null ? true : false;
1133
1134         }
1135
1136         public boolean editarPerfilUsuario(String pContraseña, String pUsername, String pNombre, String pApellido,
1137                         String pEmail, String pCuentaBancaria) {
1138                 try {
1139                         db.getTransaction().begin();
1140                         RegularUser usuario = db.find(RegularUser.class, pUsername);
1141                         usuario.setFirstName(pNombre);
1142                         usuario.setLastName(pApellido);
1143                         usuario.setEmail(pEmail);
1144                         usuario.setBankAccount(pCuentaBancaria);
1145                         usuario.setUserPass(pContraseña);
1146                         db.getTransaction().commit();
1147                         return true;
1148                 } catch (Exception ex) {
1149                         ex.printStackTrace();
1150                         return false;
1151                 }
1152         }
1153
1154         public boolean editarPerfilUsuarioSinPass(String pUsername, String pNombre, String pApellido, String pEmail,
1155                         String pCuentaBancaria) {
1156                 try {
1157                         db.getTransaction().begin();
1158                         RegularUser usuario = db.find(RegularUser.class, pUsername);
1159                         usuario.setFirstName(pNombre);
1160                         usuario.setLastName(pApellido);
1161                         usuario.setEmail(pEmail);
1162                         usuario.setBankAccount(pCuentaBancaria);
1163                         db.getTransaction().commit();
1164                         return true;
1165                 } catch (Exception ex) {
1166                         ex.printStackTrace();
1167                         return false;
1168                 }
1169         }
1170
1171         public Vector<User> getAllUsers() {
1172
1173                 Vector<User> res = new Vector<User>();
1174                 TypedQuery<User> query = db.createQuery("SELECT us FROM User us", User.class);
1175                 List<User> users = query.getResultList();
1176                 for (User us : users) {
1177                         System.out.println(us.toString());
1178                         res.add(us);
1179                 }
1180                 return res;
1181
1182         }
1183
1184         public Integer getMaxIdInDB() {
1185
1186                 Vector<Event> events = getAllEvents();
1187
1188                 Integer maxid = events.get(0).getEventNumber();
1189
1190                 for (Event e : events) {
1191
1192                         if (e.getEventNumber() > maxid) {
1193                                 maxid = e.getEventNumber();
1194                         }
1195                 }
1196
1197                 return maxid;
1198         }
1199
1200         public Integer getMaxIdForecastInDB() {
1201
1202                 Vector<Forecast> res = new Vector<Forecast>();
1203                 TypedQuery<Forecast> query = db.createQuery("SELECT fo FROM Forecast fo", Forecast.class);
1204                 List<Forecast> forecasts = query.getResultList();
1205
1206                 return forecasts.get(forecasts.size()-1).getForecastNumber();
1207         }
1208
1209
1210         public int createApuesta(Forecast pSelectedForecast, RegularUser pselectedClient, Float pselectedAmount) {
1211                 // VALIDACIÓN DE NÚMERO POSITIVO
1212                 if (pselectedAmount < 0) {
1213
1214                         // 4 - NÚMERO NEGATIVO
1215                         return 4;
1216                 } else {
1217
1218                         // VALIDACIÓN DE MONTANTE MAYOR AL MÍNIMO
1219                         // if (pselectedAmount < pselectedQuestion.getBetMinimum()) {
1220                         if (pselectedAmount < pSelectedForecast.getQuestion().getBetMinimum()) {
1221
1222                                 // 3 - NO ALCANZA APUESTA MÍNIMA
1223                                 return 3;
1224
1225                         } else {
1226
1227                                 RegularUser clientdb = db.find(RegularUser.class, pselectedClient.getUserName());
1228
1229                                 // VALIDACIÓN DE SALDO EN CUENTA
1230                                 if (pselectedAmount >= clientdb.getBalance()) {
1231                                         // 2 - FALTA DE SALDO
1232                                         return 2;
1233
1234                                 } else {
1235
1236                                         System.out.println(">> DataAccess: createApuesta=> answer= " + pSelectedForecast + " client= "
1237                                                         + clientdb.getUserName() + " amount=" + pselectedAmount + "€");
1238
1239                                         try {
1240                                                 db.getTransaction().begin();
1241                                                 Forecast fore = db.find(Forecast.class, pSelectedForecast);
1242                                                 Bet ap = fore.addBet(pSelectedForecast, pselectedClient, pselectedAmount);
1243                                                 clientdb.addBet(ap);
1244                                                 db.persist(ap);
1245
1246                                                 clientdb.setBalance(clientdb.getBalance() - pselectedAmount);
1247                                                 db.persist(clientdb);
1248                                                 db.getTransaction().commit();
1249
1250                                                 // 0 - APUESTA CREADA
1251                                                 return 0;
1252
1253                                         } catch (Exception ex) {
1254
1255                                                 // 1 - ERROR DE INGRESO DE APUESTA
1256                                                 return 1;
1257                                         }
1258
1259                                 }
1260
1261                         }
1262                 }
1263
1264         }
1265
1266         public boolean doLogin(String username, String pass) {
1267
1268                 TypedQuery<RegularUser> query1 = db.createQuery("SELECT ru FROM RegularUser ru", RegularUser.class);
1269                 List<RegularUser> regularusers = query1.getResultList();
1270
1271                 for (RegularUser ru : regularusers) {
1272                         if (ru.getUserName().equals(username) && ru.getUserPass().equals(pass)) {
1273                                 return true;
1274                         }
1275                 }
1276
1277                 TypedQuery<AdminUser> query2 = db.createQuery("SELECT au FROM AdminUser au", AdminUser.class);
1278                 List<AdminUser> adminusers = query2.getResultList();
1279
1280                 for (AdminUser au : adminusers) {
1281                         if (au.getUserName().equals(username) && au.getUserPass().equals(pass)) {
1282                                 return true;
1283                         }
1284                 }
1285
1286                 return false;
1287
1288         }
1289
1290         public boolean isAdmin(String pusername, String ppassword) {
1291                 TypedQuery<User> query = db
1292                                 .createQuery("SELECT us FROM User us WHERE us.getUserName()=?1 and us.getUserPass()=?2", User.class);
1293                 query.setParameter(1, pusername);
1294                 query.setParameter(2, ppassword);
1295                 List<User> usuarios = query.getResultList();
1296
1297                 for (User u : usuarios) {
1298                         return (u instanceof AdminUser);
1299                 }
1300
1301                 if (usuarios instanceof AdminUser) {
1302                         return true;
1303                 } else {
1304                         return false;
1305                 }
1306         }
1307
1308         public RegularUser getRegularUserByUsername(String pusername) {
1309                 System.out.println(">> DataAccess: getRegularUserByUsername");
1310
1311                 TypedQuery<RegularUser> query = db.createQuery("SELECT ru FROM RegularUser ru", RegularUser.class);
1312                 List<RegularUser> regularusers = query.getResultList();
1313
1314                 // ArrayList<Cliente> result = new ArrayList<Cliente>();
1315                 for (RegularUser ru : regularusers) {
1316                         if (ru.getUserName().equals(pusername)) {
1317                                 return ru;
1318                         }
1319
1320                 }
1321                 return null;
1322
1323         }
1324
1325         public AdminUser getAdminUserByUsername(String pusername) {
1326                 System.out.println(">> DataAccess: getAdminUserByUsername");
1327
1328                 TypedQuery<AdminUser> query = db.createQuery("SELECT au FROM AdminUser au", AdminUser.class);
1329                 List<AdminUser> adminusers = query.getResultList();
1330
1331                 // ArrayList<Admin> result = new ArrayList<Admin>();
1332                 for (AdminUser au : adminusers) {
1333                         if (au.getUserName().equals(pusername)) {
1334                                 return au;
1335                         }
1336
1337                 }
1338                 return null;
1339
1340         }
1341
1342         public boolean closeEvent2(Event e, Question q, Forecast f) {
1343
1344                 try {
1345
1346                         db.getTransaction().begin();
1347                         Event ev = db.find(Event.class, e);
1348                         Question qe = db.find(Question.class, q);
1349                         Forecast fe = db.find(Forecast.class, f);
1350                         qe.setResult(f.getForecast());
1351                         System.out.println(">> DataAccess: closeEvent=> Event:" + ev.getDescription() + " in question: "
1352                                         + qe.getQuestion() + " with result: " + qe.getResult());
1353
1354                         Vector<Bet> bets = new Vector<Bet>(fe.getBets());
1355
1356                 } catch (Exception e2) {
1357                 }
1358                 return false;
1359
1360         }
1361
1362         public boolean closeEvent(Event e, Question q, Forecast f) {
1363                 try {
1364                         db.getTransaction().begin();
1365                         Event ev = db.find(Event.class, e);
1366                         Question qe = db.find(Question.class, q);
1367                         Forecast fe = db.find(Forecast.class, f);
1368                         qe.setResult(f.getForecast());
1369                         System.out.println(">> DataAccess: closeEvent=> Event:" + ev.getDescription() + " in question: "
1370                                         + qe.getQuestion() + " with result: " + qe.getResult());
1371                         if (ev.getClosed()) {
1372                                 return false;
1373                         } else {
1374                                 ev.setClosed(true);
1375                         }
1376                         Vector<Bet> bets = new Vector<Bet>(fe.getBets());
1377                         for (Bet be : bets) {
1378                                 Bet bet = db.find(Bet.class, be);
1379                                 if (bet.getForecast() == fe) {
1380                                         if (bet.getForecast().equals(bet.getForecast().getQuestion().getResult())) {
1381                                                 bet.setEstadoApuesta("Ganada");
1382                                         } else {
1383                                                 bet.setEstadoApuesta("Perdida");
1384                                         }
1385                                         payUsers(bet);
1386                                 }
1387                         }
1388                         db.getTransaction().commit();
1389                         return true;
1390                 } catch (Exception ex) {
1391                         ex.printStackTrace();
1392                         return false;
1393                 }
1394
1395         }
1396
1397         private boolean payUsers(Bet b) {
1398
1399                 try {
1400                         Vector<User> usersToPay = new Vector<User>(getAllUsers());
1401                         for (User au : usersToPay) {
1402                                 if (au instanceof RegularUser) {
1403                                         RegularUser u = (RegularUser) au;
1404                                         RegularUser us = db.find(RegularUser.class, u);
1405                                         Vector<Bet> userBets = new Vector<Bet>(u.getBets());
1406                                         for (Bet be : userBets) {
1407                                                 Bet bett = db.find(Bet.class, be);
1408                                                 if (bett.getUser().equals(us)) {
1409                                                         float sumo = us.getBalance() + (be.getAmount() * b.getForecast().getFee());
1410                                                         us.setBalance(us.getBalance() + (be.getAmount() * b.getForecast().getFee()));
1411                                                         System.out.println("le sumo: " + sumo);
1412                                                         System.out.println("Nuevo saldo: " + us.getBalance());
1413                                                 }
1414                                         }
1415                                 }
1416
1417                         }
1418                         return true;
1419                 } catch (Exception e) {
1420                         return false;
1421                 }
1422
1423         }
1424
1425         public boolean anularApuesta(Bet pApuesta) {
1426
1427                 try {
1428                         db.getTransaction().begin();
1429                         Bet apuesta = db.find(Bet.class, pApuesta);
1430                         RegularUser cliente = db.find(RegularUser.class, pApuesta.getUser());
1431
1432                         Calendar fecha = new java.util.GregorianCalendar();
1433                         int año = fecha.get(Calendar.YEAR);
1434                         int mes = fecha.get(Calendar.MONTH);
1435                         int dia = fecha.get(Calendar.DAY_OF_MONTH);
1436
1437                         if (apuesta.getForecast().getQuestion().getEvent().getEventDate()
1438                                         .compareTo(UtilDate.newDate(año, mes, dia)) > 0) { // posterior al argumento (actual)
1439
1440                                 apuesta.setEstadoApuesta("Anulada");
1441                                 System.out.println("Saldo inicial: " + cliente.getBalance());
1442                                 cliente.setBalance(cliente.getBalance() + pApuesta.getAmount());
1443                                 System.out.println("Se ha devuelto " + pApuesta.getAmount());
1444                                 System.out.println("Saldo actualizado: " + cliente.getBalance());
1445
1446                                 db.getTransaction().commit();
1447
1448                                 System.out.println("Anulada");
1449                                 return true;
1450                         } else {
1451                                 System.out.println("No anulada");
1452                                 return false;
1453                         }
1454                 } catch (Exception e) {
1455                         return false;
1456                 }
1457
1458         }
1459
1460         public Vector<Bet> getApuestasAbiertas(RegularUser pUser) {
1461
1462                 db.getTransaction().begin();
1463                 TypedQuery<Bet> query = db.createQuery("SELECT b FROM Bet b WHERE b.estadoApuesta=?1 AND b.user=?2", Bet.class);
1464                 query.setParameter(1, "Pendiente");
1465                 query.setParameter(2, pUser);
1466                 Vector<Bet> ArrayListApuestas = new Vector<Bet>(query.getResultList());
1467                 db.getTransaction().commit();
1468                 return ArrayListApuestas;
1469
1470         }
1471
1472         public Vector<Bet> getApuestasCerradas(RegularUser pUser) {
1473
1474                 db.getTransaction().begin();
1475                 TypedQuery<Bet> query = db.createQuery(
1476                                 "SELECT b FROM Bet b WHERE b.estadoApuesta=?1 OR b.estadoApuesta=?2 AND b.user=?2", Bet.class);
1477                 query.setParameter(1, "Ganada");
1478                 query.setParameter(2, "Perdida");
1479                 query.setParameter(3, pUser);
1480                 Vector<Bet> ArrayListApuestas = new Vector<Bet>(query.getResultList());
1481                 db.getTransaction().commit();
1482                 return ArrayListApuestas;
1483
1484         }
1485
1486         public Vector<Bet> getApuestasGanadas(RegularUser pUser) {
1487
1488                 db.getTransaction().begin();
1489                 TypedQuery<Bet> query = db.createQuery("SELECT b FROM Bet b WHERE b.estadoApuesta=?1 AND b.user=?2", Bet.class);
1490                 query.setParameter(1, "Ganada");
1491                 query.setParameter(2, pUser);
1492                 Vector<Bet> ArrayListApuestas = new Vector<Bet>(query.getResultList());
1493                 db.getTransaction().commit();
1494                 return ArrayListApuestas;
1495
1496         }
1497
1498         public Vector<Bet> getApuestasPerdidas(RegularUser pUser) {
1499
1500                 db.getTransaction().begin();
1501                 TypedQuery<Bet> query = db.createQuery("SELECT b FROM Bet b WHERE b.estadoApuesta=?1 AND b.user=?2", Bet.class);
1502                 query.setParameter(1, "Perdida");
1503                 query.setParameter(2, pUser);
1504                 Vector<Bet> ArrayListApuestas = new Vector<Bet>(query.getResultList());
1505                 db.getTransaction().commit();
1506                 return ArrayListApuestas;
1507
1508         }
1509
1510         public Vector<Bet> getApuestasAnuladas(RegularUser pUser) {
1511
1512                 db.getTransaction().begin();
1513                 TypedQuery<Bet> query = db.createQuery("SELECT b FROM Bet b WHERE b.estadoApuesta=?1 AND b.user=?2", Bet.class);
1514                 query.setParameter(1, "Anulada");
1515                 query.setParameter(2, pUser);
1516                 Vector<Bet> ArrayListApuestas = new Vector<Bet>(query.getResultList());
1517                 db.getTransaction().commit();
1518                 return ArrayListApuestas;
1519
1520         }
1521
1522         public Vector<Bet> getApuestasByUser(RegularUser user) {
1523
1524                 db.getTransaction().begin();
1525                 TypedQuery<Bet> query = db.createQuery("SELECT b FROM Bet b WHERE b.user=?1", Bet.class);
1526                 query.setParameter(1, user);
1527                 Vector<Bet> ArrayListApuestas = new Vector<Bet>(query.getResultList());
1528                 db.getTransaction().commit();
1529                 return ArrayListApuestas;
1530
1531         }
1532
1533         public boolean aplicarBonoBienvenida(String user) {
1534
1535                 try {
1536                         db.getTransaction().begin();
1537                         RegularUser usuario = db.find(RegularUser.class, user);
1538                         usuario.setBalance(5f);
1539                         db.getTransaction().commit();
1540                         return true;
1541                 } catch (Exception e) {
1542                         return false;
1543                 }
1544
1545         }
1546
1547         public boolean recargarSaldo(String user, Float importe) {
1548
1549                 try {
1550                         db.getTransaction().begin();
1551                         RegularUser usuario = db.find(RegularUser.class, user);
1552                         usuario.setBalance(usuario.getBalance() + importe);
1553                         db.getTransaction().commit();
1554                         return true;
1555                 } catch (Exception e) {
1556                         return false;
1557                 }
1558
1559         }
1560
1561         public boolean definirResultados(Event pselectedEvent, Question pselectedQuestion, Forecast pselectedForecast) {
1562
1563                 db.getTransaction().begin();
1564                 Forecast winnerf = db.find(Forecast.class, pselectedForecast.getForecastNumber());
1565                 Question winnerq = db.find(Question.class, pselectedQuestion);
1566                 winnerq.setResult(pselectedForecast.getForecast());
1567                 winnerf.setWinnerf(true);
1568                 db.getTransaction().commit();
1569
1570                 // TODAS LAS RESPUESTAS POSIBLES DE ESA PREGUNTA
1571                 TypedQuery<Forecast> query0 = db.createQuery("SELECT fo FROM Forecast fo WHERE fo.question=?1", Forecast.class);
1572                 query0.setParameter(1, winnerq);
1573                 db.getTransaction().begin();
1574                 ArrayList<Forecast> ArrayListRespuestas = new ArrayList<Forecast>(query0.getResultList());
1575                 db.getTransaction().commit();
1576
1577                 try {
1578
1579                         db.getTransaction().begin();
1580                         for (Forecast ans : ArrayListRespuestas) { // por cada forecast(prediccion/respuesta) mira todas las
1581                                                                                                                 // apuestas
1582                                 TypedQuery<Bet> query1 = db.createQuery("SELECT be FROM Bet be WHERE be.forecast=?1", Bet.class);
1583                                 query1.setParameter(1, ans);
1584                                 ArrayList<Bet> ArrayListApuestas = new ArrayList<Bet>(query1.getResultList());
1585                                 if (ArrayListApuestas.isEmpty()) { // chekamos si tiene o no apuestas
1586                                         System.out.println("No bets for this answer.");
1587                                 } else {
1588                                         for (Bet bet : ArrayListApuestas) { // por cada acuesta de ese forecast
1589
1590                                                 if (bet.getEstadoApuesta().equals("Anulada") == false) {
1591
1592                                                         if (bet.getForecast().getForecastNumber() == pselectedForecast.getForecastNumber()) {
1593                                                                 bet.setEstadoApuesta("Ganada");// SET ACIERTO
1594
1595                                                                 User cliente = bet.getUser();
1596                                                                 RegularUser ru = (RegularUser) cliente;
1597                                                                 float saldoCliente = ru.getBalance();
1598                                                                 float total = saldoCliente + bet.getAmount() * pselectedForecast.getFee();
1599
1600                                                                 System.out.println("\nAcredita al cliente " + ru.getUserName() + " un total de "
1601                                                                                 + bet.getAmount() * pselectedForecast.getFee() + "â‚¬ (" + bet.getAmount()
1602                                                                                 + "â‚¬ x " + pselectedForecast.getFee() + ")");
1603
1604                                                                 ru.setBalance(total);
1605
1606                                                         } else {
1607
1608                                                                 bet.setEstadoApuesta("Perdida");// SET FALLO
1609                                                         }
1610
1611                                                 }
1612                                         }
1613                                 }
1614                         }
1615
1616                         winnerq.hasResult(true);
1617                         System.out.println(
1618                                         "\n// Apuestas sobre pregunta '" + winnerq.getQuestion() + "' resueltas.\nPregunta cerrada. //");
1619                         db.getTransaction().commit();
1620
1621                 } catch (Exception e) {
1622                         JOptionPane.showMessageDialog(null, "DataAccess >> Asignar Resultados y Pagos >> Catch: " + e.getMessage()); // FIX-ME!
1623                                                                                                                                                                                                                                                         // Comentar
1624                                                                                                                                                                                                                                                         // la
1625                                                                                                                                                                                                                                                         // lÃnea
1626                         return false;
1627                 }
1628
1629                 // CIERRE DE EVENTO
1630                 try {
1631
1632                         // SI NO HAY PREGUNTAS ABIERTAS, CIERRA EVENTO
1633                         Event ev = db.find(Event.class, pselectedEvent);
1634
1635                         db.getTransaction().begin();
1636                         TypedQuery<Question> query = db.createQuery("SELECT q FROM Question q WHERE q.event=?1 AND q.hasResult=?2",
1637                                         Question.class);
1638                         query.setParameter(1, ev);
1639                         query.setParameter(2, false);
1640
1641                         ArrayList<Question> ArrayListQuestions = new ArrayList<Question>(query.getResultList());
1642
1643                         if (ArrayListQuestions.isEmpty()) {
1644                                 ev.setClosed(true);
1645                                 // JOptionPane.showMessageDialog(null, "ebento serrado");
1646                         }
1647                         // db.getTransaction().commit();
1648                         db.getTransaction().commit();
1649
1650                         return true;
1651
1652                 } catch (Exception e) {
1653                         e.printStackTrace();
1654                         JOptionPane.showMessageDialog(null, "DataAccess >> Cerrar evento >> Catch");
1655                         return false;
1656                 }
1657         }
1658
1659         public Vector<Question> getOpenedQuestions(Event ev) {
1660                 db.getTransaction().begin();
1661                 Event ev1 = db.find(Event.class, ev);
1662                 TypedQuery<Question> query = db.createQuery("SELECT q from Question q WHERE q.hasResult=?1 AND q.event=?2",
1663                                 Question.class);
1664                 query.setParameter(1, false);
1665                 query.setParameter(2, ev1);
1666                 ArrayList<Question> ArrayListQuestions = new ArrayList<Question>(query.getResultList());
1667                 Vector<Question> queries = new Vector<Question>();
1668                 for (int f = 0; f < ArrayListQuestions.size(); f++) {
1669                         queries.add(ArrayListQuestions.get(f));
1670                         System.out.println(ArrayListQuestions.get(f));
1671                 }
1672                 db.getTransaction().commit();
1673                 return queries;
1674
1675         }
1676
1677         public boolean getEstadoEvento(Event ev) {
1678
1679                 db.getTransaction().begin();
1680                 Event ev1 = db.find(Event.class, ev);
1681                 boolean result = ev1.getClosed();
1682                 db.getTransaction().commit();
1683
1684                 return result;
1685
1686         }
1687
1688         public Vector<Event> getEventosMedioCerrados() {
1689
1690                 db.getTransaction().begin();
1691                 TypedQuery<Event> query = db.createQuery("SELECT e from Event e", Event.class);
1692                 boolean controlAbierta = false;
1693                 boolean controlCerrada = false;
1694
1695                 Vector<Event> vectorEventos = new Vector<Event>(query.getResultList());
1696                 Vector<Event> resultado = new Vector<Event>();
1697                 for (Event e : vectorEventos) {
1698                         Vector<Question> preguntas = e.getQuestions();
1699                         for (Question q : preguntas) {
1700                                 if (q.hasResult()) { // si la pregunta esta cerrada
1701
1702                                         controlCerrada = true;
1703                                 } else if (q.hasResult() == false) { // si la pregunta esta abierta
1704                                         controlAbierta = true;
1705                                 }
1706                         }
1707
1708                         if (controlAbierta && controlCerrada && (e.getClosed() == false)) {
1709                                 resultado.add(e);
1710                         }
1711                         controlAbierta = false;
1712                         controlCerrada = false;
1713                 }
1714                 db.getTransaction().commit();
1715
1716                 return resultado;
1717
1718         }
1719
1720         public static void main(String[] args) {
1721
1722                 DataAccess data = new DataAccess();
1723                 RegularUser usuario = new RegularUser("usuario", "Usuario1?", "Nombre", "Apellido", "01/01/2000",
1724                                 "usuario@gmail.com", "ES11 1111 1111 1111", 123456789, "", 0);
1725                 Event ev1 = new Event(69, "Eibar-Eibar", UtilDate.newDate(2025, 4, 17));
1726                 Question pregunta = new Question("pregunta", 2, ev1);
1727                 Forecast pronostico = new Forecast("Madrid", 17, pregunta);
1728                 Bet apuesta = new Bet(pronostico, usuario, 13);
1729
1730                 System.out.println(data.anularApuesta(apuesta));
1731
1732         }
1733
1734 }