Source code

001// --------------------------------------------------------------------------------
002// Copyright 2002-2025 Echo Three, LLC
003//
004// Licensed under the Apache License, Version 2.0 (the "License");
005// you may not use this file except in compliance with the License.
006// You may obtain a copy of the License at
007//
008//     http://www.apache.org/licenses/LICENSE-2.0
009//
010// Unless required by applicable law or agreed to in writing, software
011// distributed under the License is distributed on an "AS IS" BASIS,
012// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013// See the License for the specific language governing permissions and
014// limitations under the License.
015// --------------------------------------------------------------------------------
016// Generated File -- DO NOT EDIT BY HAND
017// --------------------------------------------------------------------------------
018
019/**
020 * UserLoginPasswordStringValue.java
021 */
022
023package com.echothree.model.data.user.server.value;
024
025import com.echothree.model.data.user.common.pk.UserLoginPasswordStringPK;
026
027import com.echothree.model.data.user.server.factory.UserLoginPasswordStringFactory;
028
029import com.echothree.model.data.user.common.pk.UserLoginPasswordPK;
030
031import com.echothree.util.common.exception.PersistenceCloneException;
032import com.echothree.util.common.exception.PersistenceNotNullException;
033
034import com.echothree.util.server.persistence.BaseValue;
035
036import java.io.Serializable;
037
038public class UserLoginPasswordStringValue
039        extends BaseValue<UserLoginPasswordStringPK>
040        implements Cloneable, Serializable {
041    
042    private UserLoginPasswordPK userLoginPasswordPK;
043    private boolean userLoginPasswordPKHasBeenModified = false;
044    private String salt;
045    private boolean saltHasBeenModified = false;
046    private String password;
047    private boolean passwordHasBeenModified = false;
048    private Long changedTime;
049    private boolean changedTimeHasBeenModified = false;
050    private Boolean wasReset;
051    private boolean wasResetHasBeenModified = false;
052    private Long fromTime;
053    private boolean fromTimeHasBeenModified = false;
054    private Long thruTime;
055    private boolean thruTimeHasBeenModified = false;
056    
057    private transient Integer _hashCode = null;
058    private transient String _stringValue = null;
059    
060    private void constructFields(UserLoginPasswordPK userLoginPasswordPK, String salt, String password, Long changedTime, Boolean wasReset, Long fromTime, Long thruTime)
061            throws PersistenceNotNullException {
062        checkForNull(userLoginPasswordPK);
063        this.userLoginPasswordPK = userLoginPasswordPK;
064        this.salt = salt;
065        checkForNull(password);
066        this.password = password;
067        checkForNull(changedTime);
068        this.changedTime = changedTime;
069        checkForNull(wasReset);
070        this.wasReset = wasReset;
071        checkForNull(fromTime);
072        this.fromTime = fromTime;
073        checkForNull(thruTime);
074        this.thruTime = thruTime;
075    }
076    
077    /** Creates a new instance of UserLoginPasswordStringValue */
078    public UserLoginPasswordStringValue(UserLoginPasswordStringPK userLoginPasswordStringPK, UserLoginPasswordPK userLoginPasswordPK, String salt, String password, Long changedTime, Boolean wasReset, Long fromTime, Long thruTime)
079            throws PersistenceNotNullException {
080        super(userLoginPasswordStringPK);
081        constructFields(userLoginPasswordPK, salt, password, changedTime, wasReset, fromTime, thruTime);
082    }
083    
084    /** Creates a new instance of UserLoginPasswordStringValue */
085    public UserLoginPasswordStringValue(UserLoginPasswordPK userLoginPasswordPK, String salt, String password, Long changedTime, Boolean wasReset, Long fromTime, Long thruTime)
086            throws PersistenceNotNullException {
087        super();
088        constructFields(userLoginPasswordPK, salt, password, changedTime, wasReset, fromTime, thruTime);
089    }
090    
091   @Override
092   public UserLoginPasswordStringFactory getBaseFactoryInstance() {
093        return UserLoginPasswordStringFactory.getInstance();
094    }
095    
096    @Override
097    public UserLoginPasswordStringValue clone() {
098        Object result;
099        
100        try {
101            result = super.clone();
102        } catch (CloneNotSupportedException cnse) {
103            // This shouldn't happen, fail when it does.
104            throw new PersistenceCloneException(cnse);
105        }
106        
107        return (UserLoginPasswordStringValue)result;
108    }
109    
110   @Override
111    public UserLoginPasswordStringPK getPrimaryKey() {
112        if(_primaryKey == null) {
113            _primaryKey = new UserLoginPasswordStringPK(entityId);
114        }
115        
116        return _primaryKey;
117    }
118    
119    private void clearHashAndString() {
120        _hashCode = null;
121        _stringValue = null;
122    }
123    
124    @Override
125    public int hashCode() {
126        if(_hashCode == null) {
127            int hashCode = 17;
128            
129            hashCode = 37 * hashCode + ((entityId != null) ? entityId.hashCode() : 0);
130            
131            hashCode = 37 * hashCode + ((userLoginPasswordPK != null) ? userLoginPasswordPK.hashCode() : 0);
132            hashCode = 37 * hashCode + ((salt != null) ? salt.hashCode() : 0);
133            hashCode = 37 * hashCode + ((password != null) ? password.hashCode() : 0);
134            hashCode = 37 * hashCode + ((changedTime != null) ? changedTime.hashCode() : 0);
135            hashCode = 37 * hashCode + ((wasReset != null) ? wasReset.hashCode() : 0);
136            hashCode = 37 * hashCode + ((fromTime != null) ? fromTime.hashCode() : 0);
137            hashCode = 37 * hashCode + ((thruTime != null) ? thruTime.hashCode() : 0);
138            
139            _hashCode = hashCode;
140        }
141        
142        return _hashCode;
143    }
144    
145    @Override
146    public String toString() {
147        if(_stringValue == null) {
148            _stringValue = "{" + 
149                    "entityId=" + getEntityId() +
150                    ", userLoginPasswordPK=" + getUserLoginPasswordPK() +
151                    ", salt=" + getSalt() +
152                    ", password=" + getPassword() +
153                    ", changedTime=" + getChangedTime() +
154                    ", wasReset=" + getWasReset() +
155                    ", fromTime=" + getFromTime() +
156                    ", thruTime=" + getThruTime() +
157                    "}";
158        }
159        return _stringValue;
160    }
161    
162    @Override
163    public boolean equals(Object other) {
164        if(this == other)
165            return true;
166        
167        if(!hasIdentity())
168            return false;
169        
170        if(other instanceof  UserLoginPasswordStringValue that) {
171            if(!that.hasIdentity())
172                return false;
173            
174            Long thisEntityId = getEntityId();
175            Long thatEntityId = that.getEntityId();
176            
177            boolean objectsEqual = thisEntityId.equals(thatEntityId);
178            if(objectsEqual)
179                objectsEqual = isIdentical(that);
180            
181            return objectsEqual;
182        } else {
183            return false;
184        }
185    }
186    
187    public boolean isIdentical(Object other) {
188        if(other instanceof UserLoginPasswordStringValue that) {
189            boolean objectsEqual = true;
190            
191            
192            if(objectsEqual) {
193                UserLoginPasswordPK thisUserLoginPasswordPK = getUserLoginPasswordPK();
194                UserLoginPasswordPK thatUserLoginPasswordPK = that.getUserLoginPasswordPK();
195                
196                if(thisUserLoginPasswordPK == null) {
197                    objectsEqual = objectsEqual && (thatUserLoginPasswordPK == null);
198                } else {
199                    objectsEqual = objectsEqual && thisUserLoginPasswordPK.equals(thatUserLoginPasswordPK);
200                }
201            }
202            
203            if(objectsEqual) {
204                String thisSalt = getSalt();
205                String thatSalt = that.getSalt();
206                
207                if(thisSalt == null) {
208                    objectsEqual = objectsEqual && (thatSalt == null);
209                } else {
210                    objectsEqual = objectsEqual && thisSalt.equals(thatSalt);
211                }
212            }
213            
214            if(objectsEqual) {
215                String thisPassword = getPassword();
216                String thatPassword = that.getPassword();
217                
218                if(thisPassword == null) {
219                    objectsEqual = objectsEqual && (thatPassword == null);
220                } else {
221                    objectsEqual = objectsEqual && thisPassword.equals(thatPassword);
222                }
223            }
224            
225            if(objectsEqual) {
226                Long thisChangedTime = getChangedTime();
227                Long thatChangedTime = that.getChangedTime();
228                
229                if(thisChangedTime == null) {
230                    objectsEqual = objectsEqual && (thatChangedTime == null);
231                } else {
232                    objectsEqual = objectsEqual && thisChangedTime.equals(thatChangedTime);
233                }
234            }
235            
236            if(objectsEqual) {
237                Boolean thisWasReset = getWasReset();
238                Boolean thatWasReset = that.getWasReset();
239                
240                if(thisWasReset == null) {
241                    objectsEqual = objectsEqual && (thatWasReset == null);
242                } else {
243                    objectsEqual = objectsEqual && thisWasReset.equals(thatWasReset);
244                }
245            }
246            
247            if(objectsEqual) {
248                Long thisFromTime = getFromTime();
249                Long thatFromTime = that.getFromTime();
250                
251                if(thisFromTime == null) {
252                    objectsEqual = objectsEqual && (thatFromTime == null);
253                } else {
254                    objectsEqual = objectsEqual && thisFromTime.equals(thatFromTime);
255                }
256            }
257            
258            if(objectsEqual) {
259                Long thisThruTime = getThruTime();
260                Long thatThruTime = that.getThruTime();
261                
262                if(thisThruTime == null) {
263                    objectsEqual = objectsEqual && (thatThruTime == null);
264                } else {
265                    objectsEqual = objectsEqual && thisThruTime.equals(thatThruTime);
266                }
267            }
268            
269            return objectsEqual;
270        } else {
271            return false;
272        }
273    }
274    
275    @Override
276    public boolean hasBeenModified() {
277        return userLoginPasswordPKHasBeenModified || saltHasBeenModified || passwordHasBeenModified || changedTimeHasBeenModified || wasResetHasBeenModified || fromTimeHasBeenModified || thruTimeHasBeenModified;
278    }
279    
280    @Override
281    public void clearHasBeenModified() {
282        userLoginPasswordPKHasBeenModified = false;
283        saltHasBeenModified = false;
284        passwordHasBeenModified = false;
285        changedTimeHasBeenModified = false;
286        wasResetHasBeenModified = false;
287        fromTimeHasBeenModified = false;
288        thruTimeHasBeenModified = false;
289    }
290    
291    public UserLoginPasswordPK getUserLoginPasswordPK() {
292        return userLoginPasswordPK;
293    }
294    
295    public void setUserLoginPasswordPK(UserLoginPasswordPK userLoginPasswordPK)
296            throws PersistenceNotNullException {
297        checkForNull(userLoginPasswordPK);
298        
299        boolean update = true;
300        
301        if(this.userLoginPasswordPK != null) {
302            if(this.userLoginPasswordPK.equals(userLoginPasswordPK)) {
303                update = false;
304            }
305        } else if(userLoginPasswordPK == null) {
306            update = false;
307        }
308        
309        if(update) {
310            this.userLoginPasswordPK = userLoginPasswordPK;
311            userLoginPasswordPKHasBeenModified = true;
312            clearHashAndString();
313        }
314    }
315    
316    public boolean getUserLoginPasswordPKHasBeenModified() {
317        return userLoginPasswordPKHasBeenModified;
318    }
319    
320    public String getSalt() {
321        return salt;
322    }
323    
324    public void setSalt(String salt) {
325        boolean update = true;
326        
327        if(this.salt != null) {
328            if(this.salt.equals(salt)) {
329                update = false;
330            }
331        } else if(salt == null) {
332            update = false;
333        }
334        
335        if(update) {
336            this.salt = salt;
337            saltHasBeenModified = true;
338            clearHashAndString();
339        }
340    }
341    
342    public boolean getSaltHasBeenModified() {
343        return saltHasBeenModified;
344    }
345    
346    public String getPassword() {
347        return password;
348    }
349    
350    public void setPassword(String password)
351            throws PersistenceNotNullException {
352        checkForNull(password);
353        
354        boolean update = true;
355        
356        if(this.password != null) {
357            if(this.password.equals(password)) {
358                update = false;
359            }
360        } else if(password == null) {
361            update = false;
362        }
363        
364        if(update) {
365            this.password = password;
366            passwordHasBeenModified = true;
367            clearHashAndString();
368        }
369    }
370    
371    public boolean getPasswordHasBeenModified() {
372        return passwordHasBeenModified;
373    }
374    
375    public Long getChangedTime() {
376        return changedTime;
377    }
378    
379    public void setChangedTime(Long changedTime)
380            throws PersistenceNotNullException {
381        checkForNull(changedTime);
382        
383        boolean update = true;
384        
385        if(this.changedTime != null) {
386            if(this.changedTime.equals(changedTime)) {
387                update = false;
388            }
389        } else if(changedTime == null) {
390            update = false;
391        }
392        
393        if(update) {
394            this.changedTime = changedTime;
395            changedTimeHasBeenModified = true;
396            clearHashAndString();
397        }
398    }
399    
400    public boolean getChangedTimeHasBeenModified() {
401        return changedTimeHasBeenModified;
402    }
403    
404    public Boolean getWasReset() {
405        return wasReset;
406    }
407    
408    public void setWasReset(Boolean wasReset)
409            throws PersistenceNotNullException {
410        checkForNull(wasReset);
411        
412        boolean update = true;
413        
414        if(this.wasReset != null) {
415            if(this.wasReset.equals(wasReset)) {
416                update = false;
417            }
418        } else if(wasReset == null) {
419            update = false;
420        }
421        
422        if(update) {
423            this.wasReset = wasReset;
424            wasResetHasBeenModified = true;
425            clearHashAndString();
426        }
427    }
428    
429    public boolean getWasResetHasBeenModified() {
430        return wasResetHasBeenModified;
431    }
432    
433    public Long getFromTime() {
434        return fromTime;
435    }
436    
437    public void setFromTime(Long fromTime)
438            throws PersistenceNotNullException {
439        checkForNull(fromTime);
440        
441        boolean update = true;
442        
443        if(this.fromTime != null) {
444            if(this.fromTime.equals(fromTime)) {
445                update = false;
446            }
447        } else if(fromTime == null) {
448            update = false;
449        }
450        
451        if(update) {
452            this.fromTime = fromTime;
453            fromTimeHasBeenModified = true;
454            clearHashAndString();
455        }
456    }
457    
458    public boolean getFromTimeHasBeenModified() {
459        return fromTimeHasBeenModified;
460    }
461    
462    public Long getThruTime() {
463        return thruTime;
464    }
465    
466    public void setThruTime(Long thruTime)
467            throws PersistenceNotNullException {
468        checkForNull(thruTime);
469        
470        boolean update = true;
471        
472        if(this.thruTime != null) {
473            if(this.thruTime.equals(thruTime)) {
474                update = false;
475            }
476        } else if(thruTime == null) {
477            update = false;
478        }
479        
480        if(update) {
481            this.thruTime = thruTime;
482            thruTimeHasBeenModified = true;
483            clearHashAndString();
484        }
485    }
486    
487    public boolean getThruTimeHasBeenModified() {
488        return thruTimeHasBeenModified;
489    }
490    
491}