]> git.mxchange.org Git - jfinancials-swing.git/blob - Addressbook/src/org/mxchange/addressbook/database/frontend/contact/ContactDatabaseFrontend.java
8280ad02e866bbecf29157d64027ea00b18d009a
[jfinancials-swing.git] / Addressbook / src / org / mxchange / addressbook / database / frontend / contact / ContactDatabaseFrontend.java
1 /*
2  * Copyright (C) 2015 Roland Haeder
3  *
4  * This program is free software: you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation, either version 3 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
16  */
17 package org.mxchange.addressbook.database.frontend.contact;
18
19 import java.io.IOException;
20 import java.sql.SQLException;
21 import java.text.MessageFormat;
22 import java.util.Iterator;
23 import java.util.StringTokenizer;
24 import org.mxchange.jcore.contact.Contact;
25 import org.mxchange.jcore.contact.Gender;
26 import org.mxchange.addressbook.contact.book.BookContact;
27 import org.mxchange.addressbook.contact.user.UserContact;
28 import org.mxchange.addressbook.database.contact.ContactDatabaseConstants;
29 import org.mxchange.addressbook.exceptions.ContactAlreadyAddedException;
30 import org.mxchange.addressbook.manager.contact.ContactManager;
31 import org.mxchange.jcore.database.frontend.BaseDatabaseFrontend;
32 import org.mxchange.jcore.database.storage.Storeable;
33 import org.mxchange.jcore.exceptions.BadTokenException;
34 import org.mxchange.jcore.exceptions.UnsupportedDatabaseBackendException;
35
36 /**
37  * Stores and retrieves Contact instances
38  *
39  * @author Roland Haeder
40  */
41 public class ContactDatabaseFrontend extends BaseDatabaseFrontend implements ContactFrontend {
42
43         /**
44          * Constructor which accepts a contact manager
45          *
46          * @param manager Manager instance
47          */
48         public ContactDatabaseFrontend (final ContactManager manager) {
49                 // Call own constructor
50                 this();
51
52                 // Trace message
53                 this.getLogger().trace(MessageFormat.format("manager={0} - CALLED!", manager)); //NOI18N
54
55                 // Manager instance must not be null
56                 if (manager == null) {
57                         // Abort here
58                         throw new NullPointerException("manager is null"); //NOI18N
59                 }
60
61                 // Set contact manager
62                 this.setContactManager(manager);
63         }
64
65         /**
66          * Basic constrcutor
67          */
68         protected ContactDatabaseFrontend () {
69                 // Trace message
70                 this.getLogger().trace("CALLED!"); //NOI18N
71
72                 // Set "table" name
73                 this.setTableName("contacts"); //NOI18N
74
75                 try {
76                         // Initalize backend
77                         this.initBackend();
78                 } catch (final UnsupportedDatabaseBackendException ex) {
79                         // Abort program
80                         this.abortProgramWithException(ex);
81                 } catch (final SQLException ex) {
82                         // Abort here
83                         this.abortProgramWithException(ex);
84                 }
85         }
86
87         /**
88          * Adds given contact instance to database
89          *
90          * @param contact Contact instance
91          * @throws org.mxchange.addressbook.exceptions.ContactAlreadyAddedException If the contact instance is already found
92          */
93         @Override
94         public void addContact (final Contact contact) throws ContactAlreadyAddedException {
95                 // Trace message
96                 this.getLogger().trace("CALLED!"); //NOI18N
97
98                 // Make sure the contact is set
99                 if (contact == null) {
100                         // Abort here
101                         throw new NullPointerException("contact is null"); //NOI18N
102                 }
103
104                 try {
105                         // First check if the contact is there
106                         if (this.isContactFound(contact)) {
107                                 // Already there
108                                 throw new ContactAlreadyAddedException(contact);
109                         }
110
111                         // Then add it
112                         this.getBackend().store((Storeable) contact);
113                 } catch (final IOException ex) {
114                         // Abort here
115                         this.abortProgramWithException(ex);
116                 } catch (final BadTokenException ex) {
117                         // Abort here
118                         this.abortProgramWithException(ex);
119                 }
120
121                 // Trace message
122                 this.getLogger().trace("CALLED!"); //NOI18N
123         }
124
125         /**
126          * Shuts down the database layer
127          */
128         @Override
129         public void doShutdown () {
130                 // Trace message
131                 this.getLogger().trace("CALLED!"); //NOI18N
132
133                 // Shutdown backend
134                 this.getBackend().doShutdown();
135
136                 // Trace message
137                 this.getLogger().trace("EXIT!"); //NOI18N
138         }
139
140         /**
141          * Some "getter" for total contact count
142          *
143          * @return Total contact count
144          */
145         @Override
146         public int getContactsCount () throws SQLException {
147                 // And deligate to backend
148                 return this.getBackend().getTotalCount(); //NOI18N
149         }
150
151         /**
152          * Some "getter" for own contact instance
153          *
154          * @return Own contact instance
155          */
156         @Override
157         public Contact getOwnContact () {
158                 // Trace message
159                 this.getLogger().trace("CALLED!"); //NOI18N
160
161                 // Get row index back from backend
162                 int rowIndex = this.getBackend().getRowIndexFromColumn(ContactDatabaseConstants.COLUMN_NAME_OWN_CONTACT, true);
163
164                 // Debug message
165                 this.getLogger().debug(MessageFormat.format("rowIndex={0}", rowIndex));
166
167                 // Init instance
168                 Contact contact = null;
169
170                 try {
171                         // Now simply read the row
172                         contact = (Contact) this.getBackend().readRow(rowIndex);
173                 } catch (final BadTokenException ex) {
174                         // Bad token found
175                         this.abortProgramWithException(ex);
176                 }
177
178                 // Trace message
179                 this.getLogger().trace(MessageFormat.format("contact={0} - EXIT!", contact));
180
181                 // Return it
182                 return contact;
183         }
184
185         /**
186          * Checks if given Contact is found
187          * 
188          * @param contact Contact instance to check
189          * @return Whether the given Contact instance is found
190          */
191         @Override
192         public boolean isContactFound (final Contact contact) throws BadTokenException {
193                 // Trace message
194                 this.getLogger().trace(MessageFormat.format("contact={0} - CALLED!", contact)); //NOI18N
195
196                 // contact should not be null
197                 if (contact == null) {
198                         // Abort here
199                         throw new NullPointerException("contact is null"); //NOI18N
200                 }
201
202                 // Default is not found
203                 boolean isFound = false;
204
205                 // Start iteration
206                 Iterator<? extends Storeable> iterator = this.getBackend().iterator();
207
208                 // Check all entries
209                 while (iterator.hasNext()) {
210                         // Get next element
211                         Contact c = (Contact) iterator.next();
212
213                         // Debug message
214                         this.getLogger().debug(MessageFormat.format("c={0},contact={1}", c, contact)); //NOI18N
215
216                         // Is it added?
217                         if (c.equals(contact)) {
218                                 // Is found
219                                 isFound = true;
220                                 break;
221                         }
222                 }
223
224                 // Trace message
225                 this.getLogger().trace(MessageFormat.format("isFound={0} - EXIT!", isFound)); //NOI18N
226
227                 // Return it
228                 return isFound;
229         }
230
231         /**
232          * Checks whether own contact is found in database
233          *
234          * @return Whether own contact is found
235          */
236         @Override
237         public boolean isOwnContactFound () throws SQLException {
238                 // Deligate this call to backend
239                 return this.getBackend().isRowFound(ContactDatabaseConstants.COLUMN_NAME_OWN_CONTACT, true);
240         }
241
242         /**
243          * Parses given line from database backend into a Storeable instance. Please
244          * note that not all backends need this.
245          *
246          * @param line Line from database backend
247          * @return A Storeable instance
248          */
249         @Override
250         public Storeable parseLineToStoreable (final String line) throws BadTokenException {
251                 // Trace message
252                 this.getLogger().trace(MessageFormat.format("line={0} - CALLED!", line)); //NOI18N
253
254                 // Call inner method
255                 Contact contact = this.parseLineToContact(line);
256
257                 // Debug message
258                 this.getLogger().debug(MessageFormat.format("contact={0}", contact));
259
260                 // Return it
261                 return (Storeable) contact;
262         }
263
264         /**
265          * Reads a single row and parses it to a contact instance
266          *
267          * @param rowIndex Row index (also how much to skip)
268          * @return Contact instance
269          */
270         @Override
271         public Contact readSingleContact (final int rowIndex) {
272                 try {
273                         // Deligate this to backend instance
274                         return (Contact) this.getBackend().readRow(rowIndex);
275                 } catch (final BadTokenException ex) {
276                         // Bad token found
277                         this.abortProgramWithException(ex);
278                 }
279
280                 // Bad state, should not be reached
281                 throw new IllegalStateException("This should not be reached");
282         }
283
284         /**
285          * Parses given line and creates a Contact instance
286          * 
287          * @param line Raw line to parse
288          *
289          * @return Contact instance
290          */
291         private Contact parseLineToContact (final String line) throws BadTokenException {
292                 // Trace message
293                 this.getLogger().trace(MessageFormat.format("line={0} - CALLED!", line)); //NOI18N
294
295                 // Init A lot variables
296                 Long num = null;
297                 Boolean bool = null;
298                 Gender gender = null;
299                 int count = 0;
300                 Contact contact = null;
301
302                 // Debug message
303                 this.getLogger().debug(MessageFormat.format("line={0}", line)); //NOI18N
304
305                 // Then tokenize it
306                 // @TODO Move this into separate method
307                 StringTokenizer tokenizer = new StringTokenizer(line, ";"); //NOI18N
308
309                 // Reset variables
310                 count = 0;
311                 contact = null;
312
313                 // The tokens are now available, so get all
314                 while (tokenizer.hasMoreElements()) {
315                         // Reset variables
316                         num = null;
317                         bool = null;
318
319                         // Get next token
320                         String token = tokenizer.nextToken();
321
322                         // If char " is at pos 2 (0,1,2), then cut it of there
323                         if ((token.charAt(0) != '"') && (token.charAt(2) == '"')) {
324                                 // UTF-8 writer characters found
325                                 token = token.substring(2);
326                         }
327
328                         // Debug message
329                         this.getLogger().debug(MessageFormat.format("token={0}", token)); //NOI18N
330
331                         // Verify token, it must have double-quotes on each side
332                         if ((!token.startsWith("\"")) || (!token.endsWith("\""))) { //NOI18N
333                                 // Something bad was read
334                                 throw new BadTokenException(token, count); //NOI18N
335                         }
336
337                         // All fine, so remove it
338                         String strippedToken = token.substring(1, token.length() - 1);
339
340                         // Is the string's content "null"?
341                         if (strippedToken.equals("null")) { //NOI18N
342                                 // Debug message
343                                 this.getLogger().debug(MessageFormat.format("strippedToken={0} - NULL!", strippedToken)); //NOI18N
344
345                                 // This needs to be set to null
346                                 strippedToken = null;
347                         }
348
349                         // Debug message
350                         this.getLogger().debug(MessageFormat.format("strippedToken={0}", strippedToken)); //NOI18N
351
352                         // Now, let's try a number check, if no null
353                         if (strippedToken != null) {
354                                 // Okay, no null, maybe the string bears a decimal number?
355                                 try {
356                                         num = Long.valueOf(strippedToken);
357
358                                         // Debug message
359                                         this.getLogger().debug(MessageFormat.format("strippedToken={0} - NUMBER!", strippedToken)); //NOI18N
360                                 } catch (final NumberFormatException ex) {
361                                         // No number, then set default
362                                         num = null;
363                                 }
364                         }
365
366                         // Now, let's try a boolean check, if no null
367                         if ((strippedToken != null) && (num == null) && ((strippedToken.equals("true")) || (strippedToken.equals("false")))) { //NOI18N
368                                 // Debug message
369                                 this.getLogger().debug(MessageFormat.format("strippedToken={0} - BOOLEAN!", strippedToken)); //NOI18N
370
371                                 // parseBoolean() is relaxed, so no exceptions
372                                 bool = Boolean.valueOf(strippedToken);
373                         }
374
375                         // Debug message
376                         this.getLogger().debug(MessageFormat.format("strippedToken={0},num={1},bool={2}", strippedToken, num, bool)); //NOI18N
377
378                         // Now, let's try a gender check, if no null
379                         if ((strippedToken != null) && (num == null) && (bool == null) && ((strippedToken.equals("M")) || (strippedToken.equals("F")) || (strippedToken.equals("C")))) { //NOI18N
380                                 // Get first character
381                                 gender = Gender.fromChar(strippedToken.charAt(0));
382
383                                 // Debug message
384                                 this.getLogger().debug(MessageFormat.format("strippedToken={0},gender={1}", strippedToken, gender)); //NOI18N
385
386                                 // This instance must be there
387                                 assert (gender instanceof Gender) : MessageFormat.format("gender is not set by Gender.fromChar({0})", strippedToken); //NOI18N
388                         }
389
390                         // Now it depends on the counter which position we need to check
391                         switch (count) {
392                                 case 0: // isOwnContact
393                                         assert ((bool instanceof Boolean));
394
395                                         // Debug message
396                                         this.getLogger().debug(MessageFormat.format("bool={0}", bool)); //NOI18N
397
398                                         // Is it own contact?
399                                         if (true == bool) {
400                                                 // Debug message
401                                                 this.getLogger().debug("Creating UserContact object ..."); //NOI18N
402
403                                                 // Own entry
404                                                 contact = new UserContact();
405                                         } else {
406                                                 // Debug message
407                                                 this.getLogger().debug("Creating BookContact object ..."); //NOI18N
408
409                                                 // Other contact
410                                                 contact = new BookContact();
411                                         }
412                                         break;
413
414                                 case 1: // Gender
415                                         assert (contact instanceof Contact) : "First token was not boolean"; //NOI18N
416
417                                         // Update data
418                                         contact.setGender(gender);
419                                         break;
420
421                                 case 2: // Surname
422                                         assert (contact instanceof Contact) : "First token was not boolean"; //NOI18N
423                                         assert (gender instanceof Gender) : "gender instance is not set"; //NOI18N
424
425                                         // Update data
426                                         contact.setSurname(strippedToken);
427                                         break;
428
429                                 case 3: // Family name
430                                         assert (contact instanceof Contact) : "First token was not boolean"; //NOI18N
431                                         assert (gender instanceof Gender) : "gender instance is not set"; //NOI18N
432
433                                         // Update data
434                                         contact.setFamilyName(strippedToken);
435                                         break;
436
437                                 case 4: // Company name
438                                         assert (contact instanceof Contact) : "First token was not boolean"; //NOI18N
439                                         assert (gender instanceof Gender) : "gender instance is not set"; //NOI18N
440
441                                         // Update data
442                                         contact.setCompanyName(strippedToken);
443                                         break;
444
445                                 case 5: // Street number
446                                         assert (contact instanceof Contact) : "First token was not boolean"; //NOI18N
447
448                                         // Update data
449                                         contact.setHouseNumber(num);
450                                         break;
451
452                                 case 6: // ZIP code
453                                         assert (contact instanceof Contact) : "First token was not boolean"; //NOI18N
454
455                                         // Update data
456                                         contact.setZipCode(num);
457                                         break;
458
459                                 case 7: // City name
460                                         assert (contact instanceof Contact) : "First token was not boolean"; //NOI18N
461
462                                         // Update data
463                                         contact.setCity(strippedToken);
464                                         break;
465
466                                 case 8: // Country code
467                                         assert (contact instanceof Contact) : "First token was not boolean"; //NOI18N
468
469                                         // Update data
470                                         contact.setCountryCode(strippedToken);
471                                         break;
472
473                                 case 9: // Phone number
474                                         assert (contact instanceof Contact) : "First token was not boolean"; //NOI18N
475
476                                         // Update data
477                                         contact.setPhoneNumber(strippedToken);
478                                         break;
479
480                                 case 10: // Fax number
481                                         assert (contact instanceof Contact) : "First token was not boolean"; //NOI18N
482
483                                         // Update data
484                                         contact.setFaxNumber(strippedToken);
485                                         break;
486
487                                 case 11: // Cellphone number
488                                         assert (contact instanceof Contact) : "First token was not boolean"; //NOI18N
489
490                                         // Update data
491                                         contact.setCellphoneNumber(strippedToken);
492                                         break;
493
494                                 case 12: // Email address
495                                         assert (contact instanceof Contact) : "First token was not boolean"; //NOI18N
496
497                                         // Update data
498                                         contact.setEmailAddress(strippedToken);
499                                         break;
500
501                                 case 13: // Birthday
502                                         assert (contact instanceof Contact) : "First token was not boolean"; //NOI18N
503
504                                         // Update data
505                                         contact.setBirthday(strippedToken);
506                                         break;
507
508                                 case 14: // Comment
509                                         assert (contact instanceof Contact) : "First token was not boolean"; //NOI18N
510
511                                         // Update data
512                                         contact.setComment(strippedToken);
513                                         break;
514
515                                 default: // New data entry
516                                         this.getLogger().warn(MessageFormat.format("Will not handle unknown data {0} at index {1}", strippedToken, count)); //NOI18N
517                                         break;
518                         }
519
520                         // Increment counter for next round
521                         count++;
522                 }
523
524                 // Trace message
525                 this.getLogger().trace(MessageFormat.format("contact={0} - EXIT!", contact)); //NOI18N
526
527                 // Return finished instance
528                 return contact;
529         }
530 }