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