Java > Open Source Codes > com > nightlabs > ipanema > person > Person


1 /*
2  * Created on 02.03.2004
3  */
4 package com.nightlabs.ipanema.person;
5
6 import java.io.Serializable ;
7 import java.util.ArrayList ;
8 import java.util.Collection ;
9 import java.util.HashMap ;
10 import java.util.HashSet ;
11 import java.util.Iterator ;
12 import java.util.List ;
13 import java.util.Map ;
14 import java.util.Set ;
15
16 import javax.jdo.JDOHelper;
17 import javax.jdo.listener.StoreCallback;
18
19 import org.apache.log4j.Logger;
20
21 import com.nightlabs.ipanema.base.DuplicateKeyException;
22 import com.nightlabs.ipanema.language.id.LanguageID;
23 import com.nightlabs.ipanema.person.id.PersonStructBlockID;
24 import com.nightlabs.ipanema.person.id.PersonStructFieldID;
25
26 /**
27  * @author Alexander Bieber <alex[AT]nightlabs[DOT]de>
28  * @author nick
29  */
30
31 /**
32  * @jdo.persistence-capable
33  * identity-type = "application"
34  * objectid-class = "com.nightlabs.ipanema.person.id.PersonID"
35  * detachable = "true"
36  *
37  * @jdo.inheritance strategy = "new-table"
38  *
39  * @jdo.fetch-group name="Person.personDataFields" field-names="personDataFields"
40  * @jdo.fetch-group name="Person.personTypes" field-names="personTypes"
41  * @jdo.fetch-group name="Person.this" fetch-group-names="default, values" field-names="personDataFields, personTypes"
42  * @jdo.fetch-group name="FetchGroupsPerson.fullData" fetch-group-names="default, values" field-names="personDataFields, personTypes"
43  */
44 public class Person implements Serializable , StoreCallback//, DetachCallback
45 {
46     public static final Logger LOGGER = Logger.getLogger(Person.class);
47     
48     public static long TEMPORARY_PERSON_ID = -1;
49     
50     public static final String FETCH_GROUP_PERSON_DATA_FIELDS = "Person.personDataFields";
51     public static final String FETCH_GROUP_PERSON_TYPES = "Person.personTypes";
52     public static final String FETCH_GROUP_THIS_PERSON = "Person.this";
53     
54     protected Person() { }
55     
56     public Person(String _organisationID, long _personID)
57     {
58         if ((_personID < 0) && (_personID != TEMPORARY_PERSON_ID)) {
59             throw new IllegalArgumentException ("Parameter _personID has to be either >= 0 or TEMPORARY_PERSON_ID");
60         }
61         if (_organisationID.equals("")) {
62             throw new IllegalArgumentException ("Parameter _organisationID must not be empty");
63         }
64         this.organisationID = _organisationID;
65         this.personID = _personID;
66         this.primaryKey = getPrimaryKey(organisationID, personID);
67     }
68     
69     
70     /**
71      * @jdo.field persistence-modifier="persistent" primary-key="true"
72      * @jdo.column length="100"
73      */
74     private String organisationID;
75     
76     /**
77      * @return Returns the organisationID.
78      */
79     public String getOrganisationID() {
80         return organisationID;
81     }
82
83     /**
84      * @jdo.field persistence-modifier="persistent" primary-key="true"
85      */
86     private long personID;
87     
88     /**
89      * @return Returns the personID.
90      */
91     public long getPersonID() {
92         return personID;
93     }
94
95
96     /**
97      * key: String PersonStructBlockID.getPrimaryKey(personStructBlockOrganisationID,personStructBlockID)<br/>
98      * value: PersonDataBlockGroup personDataBlockGroup
99      *
100      * @jdo.field
101      * persistence-modifier="none"
102      */
103     protected transient Map personDataBlockGroups;
104     
105     
106     /**
107      * @jdo.field
108      * persistence-modifier="persistent"
109      * collection-type="collection"
110      * element-type="com.nightlabs.ipanema.person.AbstractPersonDataField"
111      *
112      * @jdo.join
113      */
114     private List personDataFields = new ArrayList ();
115     
116     /**
117      * Adds a datafield to the list of persistent fields
118      * and registers it in the
119      *
120      * @param field
121      */
122     void putDataFieldToPersistentList(AbstractPersonDataField field) {
123         for (int i=0; i<personDataFields.size(); i++) {
124             if (field.getPersonRelativePK().equals(((AbstractPersonDataField)personDataFields.get(i)).getPersonRelativePK())) {
125                 personDataFields.set(i,field);
126                 break;
127             }
128         }
129         personDataFields.add(field);
130     }
131     
132     /**
133      *
134      * @param field
135      */
136     void removeDataFieldFromPersistentList(AbstractPersonDataField field) {
137         personDataFields.remove(field);
138     }
139     
140     private void addPersonDataFieldToStructure(AbstractPersonDataField field) {
141         if (personDataBlockGroups == null) {
142             personDataBlockGroups = new HashMap ();
143         }
144         String structBlockPK = PersonStructBlock.getPrimaryKey(field.getPersonStructBlockOrganisationID(),field.getPersonStructBlockID());
145         PersonDataBlockGroup pdbg = null;
146         if (!personDataBlockGroups.containsKey(structBlockPK)) {
147             pdbg = new PersonDataBlockGroup(
148                     this,
149                     field.getPersonStructBlockOrganisationID(),
150                     field.getPersonStructBlockID()
151                 );
152             personDataBlockGroups.put(structBlockPK,pdbg);
153         }
154         else {
155             pdbg = (PersonDataBlockGroup)personDataBlockGroups.get(structBlockPK);
156         }
157         pdbg.addPersonDataFieldToStructure(field);
158     }
159     
160     protected void mapPersistentFieldsToStructure() {
161         for (int i=0; i<personDataFields.size(); i++) {
162             AbstractPersonDataField field = (AbstractPersonDataField) personDataFields.get(i);
163             addPersonDataFieldToStructure(field);
164         }
165         // no fields saved, but personDataBlockGroups map
166 // still should be created
167 if (personDataBlockGroups == null)
168             personDataBlockGroups = new HashMap ();
169     }
170     
171     public Map getPersonDataBlockGroupMap() {
172         if (personDataBlockGroups == null) {
173             mapPersistentFieldsToStructure();
174         }
175         return personDataBlockGroups;
176     }
177     
178     public Collection getPersonDataBlockGroups() {
179         return getPersonDataBlockGroupMap().values();
180     }
181         
182     public PersonDataBlockGroup getPersonDataBlockGroup(PersonStructBlockID structBlockID)
183     throws PersonDataBlockGroupNotFoundException
184     {
185         return getPersonDataBlockGroup(structBlockID.personStructBlockOrganisationID, structBlockID.personStructBlockID);
186     }
187
188     public PersonDataBlockGroup getPersonDataBlockGroup(String personStructBlockOrganisationID, String personStructBlockID)
189     throws PersonDataBlockGroupNotFoundException
190     {
191         String structBlockPrimaryKey = PersonStructBlock.getPrimaryKey(personStructBlockOrganisationID,personStructBlockID);
192         PersonDataBlockGroup pdbg = (PersonDataBlockGroup)getPersonDataBlockGroupMap().get(structBlockPrimaryKey);
193         if (pdbg == null) {
194             throw new PersonDataBlockGroupNotFoundException("Could not find PersonDataBlockGroup for (personStructBlockOrganisationID/personStructBlockID)="+structBlockPrimaryKey);
195         }
196         return pdbg;
197     }
198     
199     /**
200      * ShortCut to {@link #hasStructBlockRepresentation(String, String)}.
201      * @param structBlockID
202      * @return
203      */
204     public boolean hasStructBlockRepresentation(PersonStructBlockID structBlockID) {
205         return hasStructBlockRepresentation(structBlockID.personStructBlockOrganisationID,structBlockID.personStructBlockID);
206     }
207     
208     /**
209      * Checks if a PersonDataBlockGroup exists for the
210      * PersonStructBlock defined by the parameters.
211      *
212      * @param personStructBlockOrganisationID
213      * @param personStructBlockID
214      * @return
215      */
216     public boolean hasStructBlockRepresentation(String personStructBlockOrganisationID, String personStructBlockID) {
217         String structBlockPrimaryKey = PersonStructBlock.getPrimaryKey(personStructBlockOrganisationID,personStructBlockID);
218         return getPersonDataBlockGroupMap().containsKey(structBlockPrimaryKey);
219     }
220     
221     /**
222      * Shortcut method to access a PersonDataField directly.
223      * Takes all parts of the primary key of a AbstractPersonDataField
224      * and the ID of the PersonDataBlock to get the field from.
225      *
226      * @param personDataBlockOrganisationID
227      * @param personDataBlockID
228      * @param personDataFieldOrganisationID
229      * @param personDataFieldID
230      * @param personDataBlockIdx
231      * @return
232      * @throws PersonDataBlockGroupNotFoundException
233      * @throws PersonDataBlockNotFoundException
234      * @throws PersonDataFieldNotFoundException
235      */
236     public AbstractPersonDataField getPersonDataField(
237         String personDataBlockOrganisationID,
238         String personDataBlockID,
239         String personDataFieldOrganisationID,
240         String personDataFieldID,
241         int personDataBlockIdx
242     )
243     throws
244         PersonDataBlockGroupNotFoundException, PersonDataBlockNotFoundException, PersonDataFieldNotFoundException
245     {
246         String structBlockPrimaryKey = PersonStructBlock.getPrimaryKey(personDataBlockOrganisationID,personDataBlockID);
247         String structFieldKey = AbstractPersonStructField.getStructFieldKey(personDataFieldOrganisationID,personDataFieldID);
248         PersonDataBlockGroup blockGroup = getPersonDataBlockGroup(personDataBlockOrganisationID, personDataBlockID);
249         PersonDataBlock block = blockGroup.getPersonDataBlock(personDataBlockIdx);
250         return block.getPersonDataField(personDataFieldOrganisationID,personDataFieldID);
251     }
252     
253     
254     /**
255      * Calls {@link #getPersonDataField(String, String, String, String, int)} with personDataBlockIdx = 0.
256      *
257      * @param personDataBlockOrganisationID
258      * @param personDataBlockID
259      * @param personDataFieldOrganisationID
260      * @param personDataFieldID
261      * @return
262      * @throws PersonDataBlockNotFoundException
263      * @throws PersonDataBlockGroupNotFoundException
264      * @throws PersonDataFieldNotFoundException
265      */
266     public AbstractPersonDataField getPersonDataField(
267             String personDataBlockOrganisationID,
268             String personDataBlockID,
269             String personDataFieldOrganisationID,
270             String personDataFieldID
271         )
272         throws
273             PersonDataBlockNotFoundException, PersonDataBlockGroupNotFoundException, PersonDataFieldNotFoundException
274         {
275             return getPersonDataField(personDataBlockOrganisationID,personDataBlockID,personDataFieldOrganisationID,personDataFieldID,0);
276         }
277     
278     /**
279      * Calls {@link #getPersonDataField(String, String, String, String)}.
280      * @param structFieldID
281      * @return
282      * @throws PersonDataBlockNotFoundException
283      * @throws PersonDataBlockGroupNotFoundException
284      * @throws PersonDataFieldNotFoundException
285      */
286     public AbstractPersonDataField getPersonDataField(PersonStructFieldID structFieldID)
287     throws
288         PersonDataBlockNotFoundException, PersonDataBlockGroupNotFoundException, PersonDataFieldNotFoundException
289     {
290         return getPersonDataField(
291             structFieldID.personStructBlockOrganisationID,
292             structFieldID.personStructBlockID,
293             structFieldID.personStructFieldOrganisationID,
294             structFieldID.personStructFieldID
295         );
296     }
297     
298     /**
299      * Adds a {@link PersonDataBlockGroup} to this person representing
300      * the PersonStructBlock defined by the passed IDs.<br/>
301      * Additionally adds a {@link PersonDataBlock}
302      * to the created PersonDataBlockGroup for the firstEntry.<br/>
303      * If a PersonDataBlockGroup representng the passed StructBlock is already
304      * existing for this person a {@link DuplicateKeyException} it thrown.
305      *
306      * @param personStructBlock
307      * @throws DuplicateKeyException
308      * @return The newly added PersonDataBlockGroup
309      */
310     public PersonDataBlockGroup addDataBlockGroup(PersonStructBlock personStructBlock, PersonStruct structure)
311     throws DuplicateKeyException
312     {
313         String structBlockPrimaryKey = PersonStructBlock.getPrimaryKey(personStructBlock.getPersonStructBlockOrganisationID(),personStructBlock.getPersonStructBlockID());
314         if (personDataBlockGroups == null) {
315             mapPersistentFieldsToStructure();
316         }
317         else {
318             if (personDataBlockGroups.containsKey(structBlockPrimaryKey))
319                 throw new DuplicateKeyException("Person "+this+" already contians a PersonDataBlockGroup representing PersonStructBlock "+structBlockPrimaryKey);
320         }
321         PersonDataBlockGroup pdbg = new PersonDataBlockGroup(this,personStructBlock.getPersonStructBlockOrganisationID(),personStructBlock.getPersonStructBlockID());
322         try {
323             pdbg.newPersonDataBlock(structure);
324         } catch (PersonDataBlockUniqueException e) {
325             throw new RuntimeException ("Caught PersonDataBlockUniqueException when adding first DataBlock to DataBlockGroup "+pdbg+" representing "+structBlockPrimaryKey);
326         }
327         personDataBlockGroups.put(structBlockPrimaryKey,pdbg);
328         return pdbg;
329     }
330     
331     /**
332      * @jdo.field persistence-modifier="persistent"
333      */
334     private String personLanguageID = LanguageID.SYSTEM;
335     
336     /**
337      * Get this persons languageID.
338      * @return
339      */
340     public String getPersonLanguageID() {
341         return personLanguageID;
342     }
343     
344     /**
345      * Set this persons languageID.
346      * @param _personLanguageID
347      */
348     public void setPersonLanguageID(String _personLanguageID) {
349         this.personLanguageID = _personLanguageID;
350     }
351     
352     
353     /**
354      * @jdo.field persistence-modifier="persistent"
355      */
356     private String personDisplayName;
357     
358     public String getPersonDisplayName() {
359         return personDisplayName;
360     }
361     
362     public void setPersonDisplayName(String displayName) {
363         setPersonDisplayName(displayName,null);
364     }
365     
366     /**
367      * Sets the personDisplayName either to the value passed
368      * or when autoGenerateDisplayName is true it will be
369      * generated according to the personDisplayNameParts in
370      * PersonStruct.
371      *
372      * @param displayName
373      */
374     public void setPersonDisplayName(String displayName, PersonStruct structure) {
375         boolean first = true;
376         String firstSuffix = "";
377         boolean onlyOne = true;
378         
379         if (structure == null)
380             setAutoGenerateDisplayName(false);
381         
382         if (!isAutoGenerateDisplayName())
383             this.personDisplayName = displayName;
384         else {
385             this.personDisplayName = "";
386             for (Iterator it = structure.getPersonDisplayNameParts().iterator(); it.hasNext();) {
387                 PersonDisplayNamePart displayNamePart = (PersonDisplayNamePart) it.next();
388                 AbstractPersonDataField field = null;
389                 try {
390                     field = getPersonDataField(
391                         displayNamePart.getStructField().getPersonStructBlockOrganisationID(),
392                         displayNamePart.getStructField().getPersonStructBlockID(),
393                         displayNamePart.getStructField().getPersonStructFieldOrganisationID(),
394                         displayNamePart.getStructField().getPersonStructFieldID()
395                     );
396                 } catch (PersonDataNotFoundException e) {
397                     // person does not have this field
398 continue;
399                 }
400                 if (!field.isEmpty()) {
401                     personDisplayName += field.localizedToString(personLanguageID)+displayNamePart.getStructFieldSuffix();
402                     if (first) {
403                         firstSuffix = displayNamePart.getStructFieldSuffix();
404                         first = false;
405                     }
406                     else
407                         onlyOne = false;
408                 }
409             } // for ...
410 if (!first) {
411                 // at least one was added
412 if (onlyOne) {
413                     // only one was added, remove its suffix
414 personDisplayName = personDisplayName.substring(0,personDisplayName.length()-firstSuffix.length());
415                 }
416             }
417         }
418     }
419     
420     
421
422     /**
423      * @jdo.field persistence-modifier="persistent"
424      */
425     private boolean autoGenerateDisplayName;
426     
427     public boolean isAutoGenerateDisplayName() {
428         return this.autoGenerateDisplayName;
429     }
430     
431     public void setAutoGenerateDisplayName(boolean _autoGenerateDisplayName) {
432         this.autoGenerateDisplayName = _autoGenerateDisplayName;
433     }
434     
435     /**
436      * value: String personType
437      *
438      * @jdo.field
439      * persistence-modifier="persistent"
440      * collection-type="collection"
441      * element-type="java.lang.String"
442      *
443      * @jdo.join
444      */
445     protected Set personTypes = new HashSet ();
446     
447     /**
448      * Adds a type to the list of this persons types.
449      * @param personType
450      */
451     public void addPersonType(String personType) {
452         personTypes.add(personType);
453     }
454     
455     /**
456      * Removes a type from the list of this persons types.
457      * @param personType
458      */
459     public void removePersonType(String personType) {
460         personTypes.remove(personType);
461     }
462     
463     public static String getPrimaryKey(String organisationID, long personID) {
464         return organisationID+"/"+Long.toHexString(personID);
465     }
466     
467     /**
468      * @jdo.field persistence-modifier="persistent"
469      */
470     private String primaryKey;
471     
472     public String getPrimaryKey() {
473         return primaryKey;
474     }
475     
476     /**
477      * If this Person was instatiated with
478      * {@link #TEMPORARY_PERSON_ID} as personID this method
479      * will iterate through all DataBlocks and DataFields and
480      * set the personID member of them to the given _personID.
481      * The person must not have been made persistent before
482      * calling this method this will cause an {@link IllegalStateException}
483      *
484      * @param _personID
485      */
486     public void assignPersonID(long _personID) {
487         if (JDOHelper.isPersistent(this))
488             throw new IllegalStateException ("initPersonID(long) must not be called for already persistent Persons!");
489         if (personID != TEMPORARY_PERSON_ID)
490             throw new IllegalStateException ("initPersonID(long) must not be called for Persons with a personID other than TEMPORARY_PERSON_ID!");
491         
492         // all block groups
493 for (Iterator it = personDataBlockGroups.values().iterator(); it.hasNext();) {
494             PersonDataBlockGroup blockGroup = (PersonDataBlockGroup) it.next();
495             blockGroup.setPersonID(_personID);
496             // all blocks within
497 for (Iterator iter = blockGroup.personDataBlocks.values().iterator(); iter.hasNext();) {
498                 PersonDataBlock block = (PersonDataBlock) iter.next();
499                 block.setPersonID(_personID);
500                 // all fields within
501 for (Iterator iterator = block.personDataFields.values().iterator(); iterator.hasNext();) {
502                     AbstractPersonDataField field = (AbstractPersonDataField) iterator.next();
503                     field.setPersonID(_personID);
504                 }
505             }
506         }
507         this.personID = _personID;
508         this.primaryKey = getPrimaryKey(organisationID, personID);
509     }
510
511     /**
512      * @see javax.jdo.InstanceCallbacks#jdoPostLoad()
513      */
514     public void jdoPostLoad() {
515     }
516
517     /**
518      * @see javax.jdo.InstanceCallbacks#jdoPreStore()
519      */
520     public void jdoPreStore() {
521 // // make sure no empty fields are stored
522 // try {
523 // PersonStructFactory.getPersonStructure().implodePerson(this);
524 // } catch (Throwable t) {
525 // // implode failed.
526 // // log the error
527 // LOGGER.error("Error imploding person in jdoPreStore: ",t);
528 // }
529 }
530
531     /**
532      * @see javax.jdo.InstanceCallbacks#jdoPreClear()
533      */
534     public void jdoPreClear() {
535     }
536
537     /**
538      * @see javax.jdo.InstanceCallbacks#jdoPreDelete()
539      */
540     public void jdoPreDelete() {
541     }
542
543     /**
544      * @see javax.jdo.DetachLifecycleListener#detach(javax.jdo.LifecycleEvent)
545      */
546     public void nljdoDetach() {
547     }
548     
549 // private void writeObject(ObjectOutputStream oos)
550 // throws IOException
551 // {
552 // makeTransportable();
553 // oos.defaultWriteObject();
554 // }
555
556 // /**
557 // * Iterates through all PersonDataBlockGroup s and
558 // * sets their person member to this.<br/>
559 // * Is used when a detached Person is serialized as
560 // * detached Person s will still have backreferences to
561 // * the persistent instance within {@link #getPersonDataBlockGroupMap()}.
562 // */
563 // private void makeTransportable() {
564 // if (personDataBlockGroups == null)
565 // return;
566 // getPersonDataBlockGroupMap().clear();
567 // mapPersistentFieldsToStructure();
568 // }
569
570 // /**
571 // * @see com.nightlabs.jdo.callbacks.DetachCallback#nljdoPreDetach()
572 // */
573 // public void nljdoPreDetach() {
574 // LOGGER.info("nljdoPreDetach called on "+this);
575 // }
576 //
577 // /**
578 // * @see com.nightlabs.jdo.callbacks.DetachCallback#nljdoPostDetach()
579 // */
580 // public void nljdoPostDetach() {
581 // LOGGER.info("nljdoPostDetach called on "+this);
582 // }
583
584
585 }
586

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Free Books   Free Magazines  

Popular Tags