src/main/java/net/pterodactylus/sone/data/Profile.java

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