57b54c6858bce2e95ad71ec407107af9b7aeae3b
[Sone.git] / src / main / java / net / pterodactylus / sone / data / Profile.java
1 /*
2  * Sone - Profile.java - Copyright © 2010–2013 David Roden
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
18 package net.pterodactylus.sone.data;
19
20 import static com.google.common.base.Preconditions.checkArgument;
21 import static com.google.common.base.Preconditions.checkNotNull;
22 import static com.google.common.base.Preconditions.checkState;
23
24 import java.util.ArrayList;
25 import java.util.Collections;
26 import java.util.List;
27 import java.util.UUID;
28
29 /**
30  * A profile stores personal information about a {@link Sone}. All information
31  * is optional and can be {@code null}.
32  *
33  * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
34  */
35 public class Profile implements Fingerprintable {
36
37         /** The Sone this profile belongs to. */
38         private final Sone sone;
39
40         /** The first name. */
41         private volatile String firstName;
42
43         /** The middle name(s). */
44         private volatile String middleName;
45
46         /** The last name. */
47         private volatile String lastName;
48
49         /** The day of the birth date. */
50         private volatile Integer birthDay;
51
52         /** The month of the birth date. */
53         private volatile Integer birthMonth;
54
55         /** The year of the birth date. */
56         private volatile Integer birthYear;
57
58         /** The ID of the avatar image. */
59         private volatile String avatar;
60
61         /** Additional fields in the profile. */
62         private final List<Field> fields = Collections.synchronizedList(new ArrayList<Field>());
63
64         /**
65          * Creates a new empty profile.
66          *
67          * @param sone
68          *            The Sone this profile belongs to
69          */
70         public Profile(Sone sone) {
71                 this.sone = sone;
72         }
73
74         /**
75          * Creates a copy of a profile.
76          *
77          * @param profile
78          *            The profile to copy
79          */
80         public Profile(Profile profile) {
81                 this.sone = profile.sone;
82                 this.firstName = profile.firstName;
83                 this.middleName = profile.middleName;
84                 this.lastName = profile.lastName;
85                 this.birthDay = profile.birthDay;
86                 this.birthMonth = profile.birthMonth;
87                 this.birthYear = profile.birthYear;
88                 this.avatar = profile.avatar;
89                 this.fields.addAll(profile.fields);
90         }
91
92         //
93         // ACCESSORS
94         //
95
96         /**
97          * Returns the Sone this profile belongs to.
98          *
99          * @return The Sone this profile belongs to
100          */
101         public Sone getSone() {
102                 return sone;
103         }
104
105         /**
106          * Returns the first name.
107          *
108          * @return The first name
109          */
110         public String getFirstName() {
111                 return firstName;
112         }
113
114         /**
115          * Sets the first name.
116          *
117          * @param firstName
118          *            The first name to set
119          * @return This profile (for method chaining)
120          */
121         public Profile setFirstName(String firstName) {
122                 this.firstName = firstName;
123                 return this;
124         }
125
126         /**
127          * Returns the middle name(s).
128          *
129          * @return The middle name
130          */
131         public String getMiddleName() {
132                 return middleName;
133         }
134
135         /**
136          * Sets the middle name.
137          *
138          * @param middleName
139          *            The middle name to set
140          * @return This profile (for method chaining)
141          */
142         public Profile setMiddleName(String middleName) {
143                 this.middleName = middleName;
144                 return this;
145         }
146
147         /**
148          * Returns the last name.
149          *
150          * @return The last name
151          */
152         public String getLastName() {
153                 return lastName;
154         }
155
156         /**
157          * Sets the last name.
158          *
159          * @param lastName
160          *            The last name to set
161          * @return This profile (for method chaining)
162          */
163         public Profile setLastName(String lastName) {
164                 this.lastName = lastName;
165                 return this;
166         }
167
168         /**
169          * Returns the day of the birth date.
170          *
171          * @return The day of the birth date (from 1 to 31)
172          */
173         public Integer getBirthDay() {
174                 return birthDay;
175         }
176
177         /**
178          * Sets the day of the birth date.
179          *
180          * @param birthDay
181          *            The day of the birth date (from 1 to 31)
182          * @return This profile (for method chaining)
183          */
184         public Profile setBirthDay(Integer birthDay) {
185                 this.birthDay = birthDay;
186                 return this;
187         }
188
189         /**
190          * Returns the month of the birth date.
191          *
192          * @return The month of the birth date (from 1 to 12)
193          */
194         public Integer getBirthMonth() {
195                 return birthMonth;
196         }
197
198         /**
199          * Sets the month of the birth date.
200          *
201          * @param birthMonth
202          *            The month of the birth date (from 1 to 12)
203          * @return This profile (for method chaining)
204          */
205         public Profile setBirthMonth(Integer birthMonth) {
206                 this.birthMonth = birthMonth;
207                 return this;
208         }
209
210         /**
211          * Returns the year of the birth date.
212          *
213          * @return The year of the birth date
214          */
215         public Integer getBirthYear() {
216                 return birthYear;
217         }
218
219         /**
220          * Returns the ID of the currently selected avatar image.
221          *
222          * @return The ID of the currently selected avatar image, or {@code null} if
223          *         no avatar is selected.
224          */
225         public String getAvatar() {
226                 return avatar;
227         }
228
229         /**
230          * Sets the avatar image.
231          *
232          * @param avatar
233          *            The new avatar image, or {@code null} to not select an avatar
234          *            image.
235          * @return This Sone
236          */
237         public Profile setAvatar(Image avatar) {
238                 if (avatar == null) {
239                         this.avatar = null;
240                         return this;
241                 }
242                 checkArgument(avatar.getSone().equals(sone), "avatar must belong to Sone");
243                 this.avatar = avatar.getId();
244                 return this;
245         }
246
247         /**
248          * Sets the year of the birth date.
249          *
250          * @param birthYear
251          *            The year of the birth date
252          * @return This profile (for method chaining)
253          */
254         public Profile setBirthYear(Integer birthYear) {
255                 this.birthYear = birthYear;
256                 return this;
257         }
258
259         /**
260          * Returns the fields of this profile.
261          *
262          * @return The fields of this profile
263          */
264         public List<Field> getFields() {
265                 return new ArrayList<Field>(fields);
266         }
267
268         /**
269          * Returns whether this profile contains the given field.
270          *
271          * @param field
272          *            The field to check for
273          * @return {@code true} if this profile contains the field, false otherwise
274          */
275         public boolean hasField(Field field) {
276                 return fields.contains(field);
277         }
278
279         /**
280          * Returns the field with the given ID.
281          *
282          * @param fieldId
283          *            The ID of the field to get
284          * @return The field, or {@code null} if this profile does not contain a
285          *         field with the given ID
286          */
287         public Field getFieldById(String fieldId) {
288                 checkNotNull(fieldId, "fieldId must not be null");
289                 for (Field field : fields) {
290                         if (field.getId().equals(fieldId)) {
291                                 return field;
292                         }
293                 }
294                 return null;
295         }
296
297         /**
298          * Returns the field with the given name.
299          *
300          * @param fieldName
301          *            The name of the field to get
302          * @return The field, or {@code null} if this profile does not contain a
303          *         field with the given name
304          */
305         public Field getFieldByName(String fieldName) {
306                 for (Field field : fields) {
307                         if (field.getName().equals(fieldName)) {
308                                 return field;
309                         }
310                 }
311                 return null;
312         }
313
314         /**
315          * Appends a new field to the list of fields.
316          *
317          * @param fieldName
318          *            The name of the new field
319          * @return The new field
320          * @throws IllegalArgumentException
321          *             if the name is not valid
322          */
323         public Field addField(String fieldName) throws IllegalArgumentException {
324                 checkNotNull(fieldName, "fieldName must not be null");
325                 checkArgument(fieldName.length() > 0, "fieldName must not be empty");
326                 checkState(getFieldByName(fieldName) == null, "fieldName must be unique");
327                 @SuppressWarnings("synthetic-access")
328                 Field field = new Field().setName(fieldName);
329                 fields.add(field);
330                 return field;
331         }
332
333         /**
334          * Moves the given field up one position in the field list. The index of the
335          * field to move must be greater than {@code 0} (because you obviously can
336          * not move the first field further up).
337          *
338          * @param field
339          *            The field to move up
340          */
341         public void moveFieldUp(Field field) {
342                 checkNotNull(field, "field must not be null");
343                 checkArgument(hasField(field), "field must belong to this profile");
344                 checkArgument(getFieldIndex(field) > 0, "field index must be > 0");
345                 int fieldIndex = getFieldIndex(field);
346                 fields.remove(field);
347                 fields.add(fieldIndex - 1, field);
348         }
349
350         /**
351          * Moves the given field down one position in the field list. The index of
352          * the field to move must be less than the index of the last field (because
353          * you obviously can not move the last field further down).
354          *
355          * @param field
356          *            The field to move down
357          */
358         public void moveFieldDown(Field field) {
359                 checkNotNull(field, "field must not be null");
360                 checkArgument(hasField(field), "field must belong to this profile");
361                 checkArgument(getFieldIndex(field) < fields.size() - 1, "field index must be < " + (fields.size() - 1));
362                 int fieldIndex = getFieldIndex(field);
363                 fields.remove(field);
364                 fields.add(fieldIndex + 1, field);
365         }
366
367         /**
368          * Removes the given field.
369          *
370          * @param field
371          *            The field to remove
372          */
373         public void removeField(Field field) {
374                 checkNotNull(field, "field must not be null");
375                 checkArgument(hasField(field), "field must belong to this profile");
376                 fields.remove(field);
377         }
378
379         //
380         // PRIVATE METHODS
381         //
382
383         /**
384          * Returns the index of the field with the given name.
385          *
386          * @param field
387          *            The name of the field
388          * @return The index of the field, or {@code -1} if there is no field with
389          *         the given name
390          */
391         private int getFieldIndex(Field field) {
392                 return fields.indexOf(field);
393         }
394
395         //
396         // INTERFACE Fingerprintable
397         //
398
399         /**
400          * {@inheritDoc}
401          */
402         @Override
403         public String getFingerprint() {
404                 StringBuilder fingerprint = new StringBuilder();
405                 fingerprint.append("Profile(");
406                 if (firstName != null) {
407                         fingerprint.append("FirstName(").append(firstName).append(')');
408                 }
409                 if (middleName != null) {
410                         fingerprint.append("MiddleName(").append(middleName).append(')');
411                 }
412                 if (lastName != null) {
413                         fingerprint.append("LastName(").append(lastName).append(')');
414                 }
415                 if (birthDay != null) {
416                         fingerprint.append("BirthDay(").append(birthDay).append(')');
417                 }
418                 if (birthMonth != null) {
419                         fingerprint.append("BirthMonth(").append(birthMonth).append(')');
420                 }
421                 if (birthYear != null) {
422                         fingerprint.append("BirthYear(").append(birthYear).append(')');
423                 }
424                 if (avatar != null) {
425                         fingerprint.append("Avatar(").append(avatar).append(')');
426                 }
427                 fingerprint.append("ContactInformation(");
428                 for (Field field : fields) {
429                         fingerprint.append(field.getName()).append('(').append(field.getValue()).append(')');
430                 }
431                 fingerprint.append(")");
432                 fingerprint.append(")");
433
434                 return fingerprint.toString();
435         }
436
437         /**
438          * Container for a profile field.
439          *
440          * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
441          */
442         public class Field {
443
444                 /** The ID of the field. */
445                 private final String id;
446
447                 /** The name of the field. */
448                 private String name;
449
450                 /** The value of the field. */
451                 private String value;
452
453                 /**
454                  * Creates a new field with a random ID.
455                  */
456                 private Field() {
457                         this(UUID.randomUUID().toString());
458                 }
459
460                 /**
461                  * Creates a new field with the given ID.
462                  *
463                  * @param id
464                  *            The ID of the field
465                  */
466                 private Field(String id) {
467                         this.id = checkNotNull(id, "id must not be null");
468                 }
469
470                 /**
471                  * Returns the ID of this field.
472                  *
473                  * @return The ID of this field
474                  */
475                 public String getId() {
476                         return id;
477                 }
478
479                 /**
480                  * Returns the name of this field.
481                  *
482                  * @return The name of this field
483                  */
484                 public String getName() {
485                         return name;
486                 }
487
488                 /**
489                  * Sets the name of this field. The name must not be {@code null} and
490                  * must not match any other fields in this profile but my match the name
491                  * of this field.
492                  *
493                  * @param name
494                  *            The new name of this field
495                  * @return This field
496                  */
497                 public Field setName(String name) {
498                         checkNotNull(name, "name must not be null");
499                         checkArgument(getFieldByName(name) == null, "name must be unique");
500                         this.name = name;
501                         return this;
502                 }
503
504                 /**
505                  * Returns the value of this field.
506                  *
507                  * @return The value of this field
508                  */
509                 public String getValue() {
510                         return value;
511                 }
512
513                 /**
514                  * Sets the value of this field. While {@code null} is allowed, no
515                  * guarantees are made that {@code null} values are correctly persisted
516                  * across restarts of the plugin!
517                  *
518                  * @param value
519                  *            The new value of this field
520                  * @return This field
521                  */
522                 public Field setValue(String value) {
523                         this.value = value;
524                         return this;
525                 }
526
527                 //
528                 // OBJECT METHODS
529                 //
530
531                 /**
532                  * {@inheritDoc}
533                  */
534                 @Override
535                 public boolean equals(Object object) {
536                         if (!(object instanceof Field)) {
537                                 return false;
538                         }
539                         Field field = (Field) object;
540                         return id.equals(field.id);
541                 }
542
543                 /**
544                  * {@inheritDoc}
545                  */
546                 @Override
547                 public int hashCode() {
548                         return id.hashCode();
549                 }
550
551         }
552
553 }