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