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