/*
 * JPA entity template
 *
 *
 * Takatuka - Template fuer JPA2 Entitaeten (inklusive Bean Validation)
 *
 * Moeglichkeiten und Einschraenkungen:
 * - Beziehungen werden abgebildet
 * -- es gibt keine 1:1 Beziehungen
 * -- N:M Beziehungen sind immer bidirektional
 * - Vererbung wird nicht unterstuetzt
 * - Support für CustomData
 */
package de.ivu.elect.business.benutzerverwaltung.entity;

@javax.persistence.NamedQueries(
 {



       @javax.persistence.NamedQuery(
     name="BENUTZER.UK",
     query="SELECT o FROM Benutzer o WHERE "

                         + "o"
                +".benutzerkennung"
              +" = ?1"

             +" AND "         + "o"
                +".mandant"
                +".nummer"
              +" = ?2"

     ,
   hints = {
              @javax.persistence.QueryHint(name = "org.hibernate.cacheable", value = "true"),
             @javax.persistence.QueryHint(name = "org.hibernate.flushMode", value = "commit")
   }


   )
   
     ,   @javax.persistence.NamedQuery(
     name="BENUTZER.All",
     query="SELECT o FROM Benutzer o WHERE o.mandant=?1",
     hints = {@javax.persistence.QueryHint(name = "org.hibernate.cacheable", value = "true"),
                            @javax.persistence.QueryHint(name = "org.hibernate.flushMode", value = "commit")
             }
   )

        
         ,   @javax.persistence.NamedQuery(
     name="BENUTZER.AllOrderByBenutzerkennung",
     query="SELECT o FROM Benutzer o WHERE o.mandant=?1 ORDER BY o.benutzerkennung",
     hints = {@javax.persistence.QueryHint(name = "org.hibernate.cacheable", value = "true"),
                            @javax.persistence.QueryHint(name = "org.hibernate.flushMode", value = "commit")
             }
   )

        
         ,   @javax.persistence.NamedQuery(
     name="BENUTZER.BenutzerkennungUpper",
     query="SELECT o FROM Benutzer o WHERE UPPER(o.benutzerkennung) = UPPER(?2) AND o.mandant = ?1",
     hints = {@javax.persistence.QueryHint(name = "org.hibernate.cacheable", value = "true"),
                            @javax.persistence.QueryHint(name = "org.hibernate.flushMode", value = "commit")
             }
   )

        
         ,   @javax.persistence.NamedQuery(
     name="BENUTZER.Rolle",
     query="SELECT o FROM Benutzer o WHERE ?1 MEMBER OF o.rolles",
     hints = {@javax.persistence.QueryHint(name = "org.hibernate.cacheable", value = "false"),
                            @javax.persistence.QueryHint(name = "org.hibernate.flushMode", value = "commit")
             }
   )

        
     }
)
@javax.enterprise.inject.Vetoed
@javax.persistence.Entity
@javax.persistence.Table(name = "BENUTZER")
// @javax.persistence.IdClass(BenutzerPK.class)
    @javax.persistence.EntityListeners(de.ivu.elect.jee.protokollierung.ProtokollEntityListener.class)
    @javax.persistence.Cacheable

public
 class Benutzer
extends AbstractBenutzer
  {

  private static final long serialVersionUID = 0L;


  /**
   * default constructor (protected, da mit CustomData aufgerufen werden muss)
   */
  protected Benutzer() {
    super();
  }
    public Benutzer(de.ivu.elect.jee.entity.customdata.CustomData customData){
                      if (customData != null && de.ivu.elect.jee.entity.customdata.EmptyCustomData.INSTANCE != customData) {
          customData.setTechnicalEntity(this);
          customDataStorage = new de.ivu.elect.business.customdata.entity.CustomDataStorage(customData);
        }
            }



    /**
     * @param original
     *
     * @deprecated Sollte nur mit Bedacht genutzt werden, da hier auch die Beziehungen kopiert werden. Deswegen markiert
     *             als Deprecated.
     */
    @Deprecated
    public Benutzer(Benutzer original){
      original.copyEntity(this);
    }

  /**
   * PRIMARY KEY
   */
  @javax.persistence.Id
  @javax.persistence.Column(name = "benutzer_id")
    @javax.persistence.GeneratedValue(strategy = javax.persistence.GenerationType.TABLE, generator = "Benutzer")
    @javax.persistence.TableGenerator(name = "Benutzer", table = "SEQUENCES", pkColumnName = "sequence_name", pkColumnValue = "Benutzer", valueColumnName = "next_val", allocationSize = 1000, initialValue = 0)
    protected java.lang.Long id;

  @Override
  public java.lang.Long getId() {
    return id;
  }

  public void setId(java.lang.Long id) {
    this.id = id;
  }

  @javax.persistence.Transient
  private transient BenutzerPK pkCache;

  @Override
  public BenutzerPK getPk() {
    if (pkCache==null || pkCache.getId() != id ) {
      pkCache = new BenutzerPK(getId());
    }

    return pkCache;
  }

  public static <E extends Benutzer> java.util.Map<BenutzerPK, E> mappeNachPk(java.util.Collection<E> entities){
    java.util.Map<BenutzerPK, E> result = new java.util.HashMap<>();

    for (E entity : entities) {
      result.put(entity.getPk(), entity);
    }

    return result;
  }

  public static <E extends Benutzer> java.util.Map<Long, E> mappeNachId(java.util.Collection<E> entities){
    java.util.Map<Long, E> result = new java.util.HashMap<>();

    for (E entity : entities) {
      result.put(entity.getId(), entity);
    }

    return result;
  }



  /**
   * Indikator, ob sich ein Attribut oder eine UNIDIREKTIONALE n:1-Beziehungen geaendert hat
   */
  @javax.persistence.Transient
  protected boolean attributeChanged = false;

  public void setAttributeChanged() {
    attributeChanged = true;
  }

  public boolean isAttributeChanged() {
    return attributeChanged;
  }

  /**
   * Hilfsvariable fuer das Aktualisieren von Beziehungen
   */
  @javax.persistence.Transient
  protected boolean updateRelationship = false;


  public void resetAttributeChanged() {
        hasChangedBemerkung = false;
          hasChangedBenutzerkennung = false;
          hasChangedFamilienname = false;
          hasChangedGeschlecht = false;
          hasChangedGesperrt = false;
          hasChangedHotpSecret = false;
          hasChangedLetzteAnmeldung = false;
          hasChangedLetzteNachrichtId = false;
          hasChangedLoginVersuche = false;
          hasChangedMussPasswortWechseln = false;
          hasChangedPasswort = false;
          hasChangedProtokollalias = false;
          hasChangedSalt = false;
          hasChangedTanliste = false;
          hasChangedVorname = false;
  
      hasChangedCustomDataStorage = false;
        hasChangedMandant = false;
  
          hasChangedRolles = false;
                hasChangedGebiets = false;
      
          hasChangedBenutzerParametersByBenutzer = false;
      
    attributeChanged = false;
  }


  /**
   * ATTRIBUTE
   */

    
  @javax.persistence.Column(name = "BEMERKUNG", nullable = BenutzerConstants.BEMERKUNG_NULLABLE, length=BenutzerConstants.BEMERKUNG_MAX_LENGTH)
        
  protected java.lang.String bemerkung =  null;

  @javax.persistence.Transient
  protected boolean hasChangedBemerkung = false;

  public boolean hasChangedBemerkung(){
    return hasChangedBemerkung;
  }
       @javax.persistence.Transient
     private transient boolean isSeitLadenVeraendertBemerkung = false;
     @javax.persistence.Transient
     private transient java.lang.String wertNachLadenBemerkung;
  
  /**
   * 
   *
   * getter for BENUTZER.BEMERKUNG
   */
  @javax.annotation.Nullable   @Override   public  java.lang.String getBemerkung() {
        return bemerkung;
      }

  /**
   * 
   *
   * setter for BENUTZER.BEMERKUNG
   *
   * @param bemerkung
   */
  @Override   public void setBemerkung(@javax.annotation.Nullable  java.lang.String bemerkung) {

       resetTkCache();
                  
                          java.lang.String bemerkungInternal = de.ivu.elect.jee.entity.EntityUtil.trimToNullOrMaxLength(bemerkung, BenutzerConstants.BEMERKUNG_MAX_LENGTH, getId(), getClass());
                  
       
      boolean thisAttributChanged =
      !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.bemerkung
      , bemerkungInternal);

      attributeChanged |= thisAttributChanged;

      hasChangedBemerkung |= thisAttributChanged;

      if (thisAttributChanged) {
      markDirty("bemerkung");
      }


             if (!isSeitLadenVeraendertBemerkung) {
          isSeitLadenVeraendertBemerkung = thisAttributChanged;
         if (isSeitLadenVeraendertBemerkung){
           wertNachLadenBemerkung=this.bemerkung;
         }
       }
      

       this.bemerkung = bemerkungInternal;

         }

        
      @javax.persistence.Column(name = "BENUTZERKENNUNG", nullable = BenutzerConstants.BENUTZERKENNUNG_NULLABLE, length=BenutzerConstants.BENUTZERKENNUNG_MAX_LENGTH)
        
  protected String benutzerkennung =  null;

  @javax.persistence.Transient
  protected boolean hasChangedBenutzerkennung = false;

  public boolean hasChangedBenutzerkennung(){
    return hasChangedBenutzerkennung;
  }
       @javax.persistence.Transient
     private transient boolean isSeitLadenVeraendertBenutzerkennung = false;
     @javax.persistence.Transient
     private transient String wertNachLadenBenutzerkennung;
  
  /**
   * 
   *
   * getter for BENUTZER.BENUTZERKENNUNG
   */
    @Override   public  String getBenutzerkennung() {
        return benutzerkennung;
      }

  /**
   * 
   *
   * setter for BENUTZER.BENUTZERKENNUNG
   *
   * @param benutzerkennung
   */
  @Override   public void setBenutzerkennung( String benutzerkennung) {

       resetTkCache();
                  
                          String benutzerkennungInternal = de.ivu.elect.jee.entity.EntityUtil.trimToNullOrMaxLength(benutzerkennung, BenutzerConstants.BENUTZERKENNUNG_MAX_LENGTH, getId(), getClass());
                  
                String alterWert = getBenutzerkennung();
         benutzerkennungInternal = preProcessBenutzerkennung(benutzerkennungInternal);
         preSetBenutzerkennung(alterWert, benutzerkennungInternal);
       
      boolean thisAttributChanged =
      !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.benutzerkennung
      , benutzerkennungInternal);

      attributeChanged |= thisAttributChanged;

      hasChangedBenutzerkennung |= thisAttributChanged;

      if (thisAttributChanged) {
      markDirty("benutzerkennung");
      }


             if (!isSeitLadenVeraendertBenutzerkennung) {
          isSeitLadenVeraendertBenutzerkennung = thisAttributChanged;
         if (isSeitLadenVeraendertBenutzerkennung){
           wertNachLadenBenutzerkennung=this.benutzerkennung;
         }
       }
      

       this.benutzerkennung = benutzerkennungInternal;

                postSetBenutzerkennung(alterWert, benutzerkennungInternal);
         }

  
    @Override
    protected String preProcessBenutzerkennung(String neuerWert) {
      return super.preProcessBenutzerkennung(neuerWert);
    }

    @Override
    protected void preSetBenutzerkennung(String alterWert, String neuerWert) {
      super.preSetBenutzerkennung(alterWert, neuerWert);
    }

    @Override
    protected void postSetBenutzerkennung(String alterWert, String neuerWert) {
      super.postSetBenutzerkennung(alterWert, neuerWert);
    }
        
  @javax.persistence.Column(name = "FAMILIENNAME", nullable = BenutzerConstants.FAMILIENNAME_NULLABLE, length=BenutzerConstants.FAMILIENNAME_MAX_LENGTH)
        
  protected java.lang.String familienname =  null;

  @javax.persistence.Transient
  protected boolean hasChangedFamilienname = false;

  public boolean hasChangedFamilienname(){
    return hasChangedFamilienname;
  }
       @javax.persistence.Transient
     private transient boolean isSeitLadenVeraendertFamilienname = false;
     @javax.persistence.Transient
     private transient java.lang.String wertNachLadenFamilienname;
  
  /**
   * 
   *
   * getter for BENUTZER.FAMILIENNAME
   */
  @javax.annotation.Nullable   @Override   public  java.lang.String getFamilienname() {
        return familienname;
      }

  /**
   * 
   *
   * setter for BENUTZER.FAMILIENNAME
   *
   * @param familienname
   */
  @Override   public void setFamilienname(@javax.annotation.Nullable  java.lang.String familienname) {

       resetTkCache();
                  
                          java.lang.String familiennameInternal = de.ivu.elect.jee.entity.EntityUtil.trimToNullOrMaxLength(familienname, BenutzerConstants.FAMILIENNAME_MAX_LENGTH, getId(), getClass());
                  
       
      boolean thisAttributChanged =
      !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.familienname
      , familiennameInternal);

      attributeChanged |= thisAttributChanged;

      hasChangedFamilienname |= thisAttributChanged;

      if (thisAttributChanged) {
      markDirty("familienname");
      }


             if (!isSeitLadenVeraendertFamilienname) {
          isSeitLadenVeraendertFamilienname = thisAttributChanged;
         if (isSeitLadenVeraendertFamilienname){
           wertNachLadenFamilienname=this.familienname;
         }
       }
      

       this.familienname = familiennameInternal;

         }

        
    @javax.persistence.Enumerated(javax.persistence.EnumType.STRING)
      @javax.persistence.Column(name = "GESCHLECHT", nullable = BenutzerConstants.GESCHLECHT_NULLABLE)
    
  protected de.ivu.elect.business.person.entity.Geschlecht geschlecht =  de.ivu.elect.business.person.entity.Geschlecht.UNBEKANNT;

  @javax.persistence.Transient
  protected boolean hasChangedGeschlecht = false;

  public boolean hasChangedGeschlecht(){
    return hasChangedGeschlecht;
  }
       @javax.persistence.Transient
     private transient boolean isSeitLadenVeraendertGeschlecht = false;
     @javax.persistence.Transient
     private transient de.ivu.elect.business.person.entity.Geschlecht wertNachLadenGeschlecht;
  
  /**
   * 
   *
   * getter for BENUTZER.GESCHLECHT
   */
    @Override   public  de.ivu.elect.business.person.entity.Geschlecht getGeschlecht() {
        return geschlecht;
      }

  /**
   * 
   *
   * setter for BENUTZER.GESCHLECHT
   *
   * @param geschlecht
   */
  @Override   public void setGeschlecht( de.ivu.elect.business.person.entity.Geschlecht geschlecht) {

       resetTkCache();
                  de.ivu.elect.business.person.entity.Geschlecht geschlechtInternal = geschlecht;
       
       
      boolean thisAttributChanged =
      !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.geschlecht
      , geschlechtInternal);

      attributeChanged |= thisAttributChanged;

      hasChangedGeschlecht |= thisAttributChanged;

      if (thisAttributChanged) {
      markDirty("geschlecht");
      }


             if (!isSeitLadenVeraendertGeschlecht) {
          isSeitLadenVeraendertGeschlecht = thisAttributChanged;
         if (isSeitLadenVeraendertGeschlecht){
           wertNachLadenGeschlecht=this.geschlecht;
         }
       }
      

       this.geschlecht = geschlechtInternal;

         }

        
  @javax.persistence.Column(name = "GESPERRT", nullable = BenutzerConstants.GESPERRT_NULLABLE)
    
  protected java.lang.Boolean gesperrt =  false;

  @javax.persistence.Transient
  protected boolean hasChangedGesperrt = false;

  public boolean hasChangedGesperrt(){
    return hasChangedGesperrt;
  }
       @javax.persistence.Transient
     private transient boolean isSeitLadenVeraendertGesperrt = false;
     @javax.persistence.Transient
     private transient java.lang.Boolean wertNachLadenGesperrt;
  
  /**
   * 
   *
   * getter for BENUTZER.GESPERRT
   */
  @javax.annotation.Nullable   @Override   public  java.lang.Boolean getGesperrt() {
        return gesperrt;
      }

  /**
   * 
   *
   * setter for BENUTZER.GESPERRT
   *
   * @param gesperrt
   */
  @Override   public void setGesperrt(@javax.annotation.Nullable  java.lang.Boolean gesperrt) {

       resetTkCache();
                  java.lang.Boolean gesperrtInternal = gesperrt;
       
       
      boolean thisAttributChanged =
      !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.gesperrt
      , gesperrtInternal);

      attributeChanged |= thisAttributChanged;

      hasChangedGesperrt |= thisAttributChanged;

      if (thisAttributChanged) {
      markDirty("gesperrt");
      }


             if (!isSeitLadenVeraendertGesperrt) {
          isSeitLadenVeraendertGesperrt = thisAttributChanged;
         if (isSeitLadenVeraendertGesperrt){
           wertNachLadenGesperrt=this.gesperrt;
         }
       }
      

       this.gesperrt = gesperrtInternal;

         }

        
  @javax.persistence.Column(name = "HOTP_SECRET", nullable = BenutzerConstants.HOTP_SECRET_NULLABLE, length=BenutzerConstants.HOTP_SECRET_MAX_LENGTH)
        
  protected java.lang.String hotpSecret =  null;

  @javax.persistence.Transient
  protected boolean hasChangedHotpSecret = false;

  public boolean hasChangedHotpSecret(){
    return hasChangedHotpSecret;
  }
  
  /**
   * 
   *
   * getter for BENUTZER.HOTP_SECRET
   */
  @javax.annotation.Nullable   @Override   public  java.lang.String getHotpSecret() {
        return hotpSecret;
      }

  /**
   * 
   *
   * setter for BENUTZER.HOTP_SECRET
   *
   * @param hotpSecret
   */
  @Override   public void setHotpSecret(@javax.annotation.Nullable  java.lang.String hotpSecret) {

       resetTkCache();
                  
                          java.lang.String hotpSecretInternal = de.ivu.elect.jee.entity.EntityUtil.trimToNullOrMaxLength(hotpSecret, BenutzerConstants.HOTP_SECRET_MAX_LENGTH, getId(), getClass());
                  
       
      boolean thisAttributChanged =
      !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.hotpSecret
      , hotpSecretInternal);

      attributeChanged |= thisAttributChanged;

      hasChangedHotpSecret |= thisAttributChanged;

      if (thisAttributChanged) {
      markDirty("hotpSecret");
      }


      

       this.hotpSecret = hotpSecretInternal;

         }

        
  @javax.persistence.Temporal(javax.persistence.TemporalType.TIMESTAMP)
  @javax.persistence.Column(name = "LETZTE_ANMELDUNG", nullable = BenutzerConstants.LETZTE_ANMELDUNG_NULLABLE, precision=BenutzerConstants.LETZTE_ANMELDUNG_PRECISION)
    
  protected java.util.Date letzteAnmeldung =  null;

  @javax.persistence.Transient
  protected boolean hasChangedLetzteAnmeldung = false;

  public boolean hasChangedLetzteAnmeldung(){
    return hasChangedLetzteAnmeldung;
  }
       @javax.persistence.Transient
     private transient boolean isSeitLadenVeraendertLetzteAnmeldung = false;
     @javax.persistence.Transient
     private transient java.util.Date wertNachLadenLetzteAnmeldung;
  
  /**
   * 
   *
   * getter for BENUTZER.LETZTE_ANMELDUNG
   */
  @javax.annotation.Nullable   @Override   public  java.util.Date getLetzteAnmeldung() {
              if (letzteAnmeldung == null){
            return null;
          } else {
                          return letzteAnmeldung;
          }
      }

  /**
   * 
   *
   * setter for BENUTZER.LETZTE_ANMELDUNG
   *
   * @param letzteAnmeldung
   */
  @Override   public void setLetzteAnmeldung(@javax.annotation.Nullable  java.util.Date letzteAnmeldung) {

       resetTkCache();
                  java.util.Date letzteAnmeldungInternal = de.ivu.elect.jee.entity.EntityUtil.normalizeDateTime(letzteAnmeldung);
       
       
      boolean thisAttributChanged =
      !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.letzteAnmeldung
      , letzteAnmeldungInternal);

      attributeChanged |= thisAttributChanged;

      hasChangedLetzteAnmeldung |= thisAttributChanged;

      if (thisAttributChanged) {
      markDirty("letzteAnmeldung");
      }


             if (!isSeitLadenVeraendertLetzteAnmeldung) {
          isSeitLadenVeraendertLetzteAnmeldung = thisAttributChanged;
         if (isSeitLadenVeraendertLetzteAnmeldung){
           wertNachLadenLetzteAnmeldung=this.letzteAnmeldung;
         }
       }
      

       this.letzteAnmeldung = letzteAnmeldungInternal;

         }

        
  @javax.persistence.Column(name = "LETZTE_NACHRICHT_ID", nullable = BenutzerConstants.LETZTE_NACHRICHT_ID_NULLABLE, precision=BenutzerConstants.LETZTE_NACHRICHT_ID_PRECISION, scale=BenutzerConstants.LETZTE_NACHRICHT_ID_SCALE)
            
  protected java.lang.Long letzteNachrichtId =  null;

  @javax.persistence.Transient
  protected boolean hasChangedLetzteNachrichtId = false;

  public boolean hasChangedLetzteNachrichtId(){
    return hasChangedLetzteNachrichtId;
  }
       @javax.persistence.Transient
     private transient boolean isSeitLadenVeraendertLetzteNachrichtId = false;
     @javax.persistence.Transient
     private transient java.lang.Long wertNachLadenLetzteNachrichtId;
  
  /**
   * 
   *
   * getter for BENUTZER.LETZTE_NACHRICHT_ID
   */
  @javax.annotation.Nullable   @Override   public  java.lang.Long getLetzteNachrichtId() {
        return letzteNachrichtId;
      }

  /**
   * 
   *
   * setter for BENUTZER.LETZTE_NACHRICHT_ID
   *
   * @param letzteNachrichtId
   */
  @Override   public void setLetzteNachrichtId(@javax.annotation.Nullable  java.lang.Long letzteNachrichtId) {

       resetTkCache();
                  java.lang.Long letzteNachrichtIdInternal = letzteNachrichtId;
       
       
      boolean thisAttributChanged =
      !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.letzteNachrichtId
      , letzteNachrichtIdInternal);

      attributeChanged |= thisAttributChanged;

      hasChangedLetzteNachrichtId |= thisAttributChanged;

      if (thisAttributChanged) {
      markDirty("letzteNachrichtId");
      }


             if (!isSeitLadenVeraendertLetzteNachrichtId) {
          isSeitLadenVeraendertLetzteNachrichtId = thisAttributChanged;
         if (isSeitLadenVeraendertLetzteNachrichtId){
           wertNachLadenLetzteNachrichtId=this.letzteNachrichtId;
         }
       }
      

       this.letzteNachrichtId = letzteNachrichtIdInternal;

         }

        
      @javax.persistence.Column(name = "LOGINVERSUCHE", nullable = BenutzerConstants.LOGINVERSUCHE_NULLABLE, precision=BenutzerConstants.LOGINVERSUCHE_PRECISION, scale=BenutzerConstants.LOGINVERSUCHE_SCALE)
            
  protected java.lang.Long loginVersuche =  Long.valueOf("0");

  @javax.persistence.Transient
  protected boolean hasChangedLoginVersuche = false;

  public boolean hasChangedLoginVersuche(){
    return hasChangedLoginVersuche;
  }
       @javax.persistence.Transient
     private transient boolean isSeitLadenVeraendertLoginVersuche = false;
     @javax.persistence.Transient
     private transient java.lang.Long wertNachLadenLoginVersuche;
  
  /**
   * 
   *
   * getter for BENUTZER.LOGINVERSUCHE
   */
    @Override   public  java.lang.Long getLoginVersuche() {
        return loginVersuche;
      }

  /**
   * 
   *
   * setter for BENUTZER.LOGINVERSUCHE
   *
   * @param loginVersuche
   */
  @Override   public void setLoginVersuche( java.lang.Long loginVersuche) {

       resetTkCache();
                  java.lang.Long loginVersucheInternal = loginVersuche;
       
       
      boolean thisAttributChanged =
      !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.loginVersuche
      , loginVersucheInternal);

      attributeChanged |= thisAttributChanged;

      hasChangedLoginVersuche |= thisAttributChanged;

      if (thisAttributChanged) {
      markDirty("loginVersuche");
      }


             if (!isSeitLadenVeraendertLoginVersuche) {
          isSeitLadenVeraendertLoginVersuche = thisAttributChanged;
         if (isSeitLadenVeraendertLoginVersuche){
           wertNachLadenLoginVersuche=this.loginVersuche;
         }
       }
      

       this.loginVersuche = loginVersucheInternal;

         }

        
  @javax.persistence.Column(name = "MUSS_PASSWORT_WECHSELN", nullable = BenutzerConstants.MUSS_PASSWORT_WECHSELN_NULLABLE)
    
  protected java.lang.Boolean mussPasswortWechseln =  false;

  @javax.persistence.Transient
  protected boolean hasChangedMussPasswortWechseln = false;

  public boolean hasChangedMussPasswortWechseln(){
    return hasChangedMussPasswortWechseln;
  }
       @javax.persistence.Transient
     private transient boolean isSeitLadenVeraendertMussPasswortWechseln = false;
     @javax.persistence.Transient
     private transient java.lang.Boolean wertNachLadenMussPasswortWechseln;
  
  /**
   * 
   *
   * getter for BENUTZER.MUSS_PASSWORT_WECHSELN
   */
  @javax.annotation.Nullable   @Override   public  java.lang.Boolean getMussPasswortWechseln() {
        return mussPasswortWechseln;
      }

  /**
   * 
   *
   * setter for BENUTZER.MUSS_PASSWORT_WECHSELN
   *
   * @param mussPasswortWechseln
   */
  @Override   public void setMussPasswortWechseln(@javax.annotation.Nullable  java.lang.Boolean mussPasswortWechseln) {

       resetTkCache();
                  java.lang.Boolean mussPasswortWechselnInternal = mussPasswortWechseln;
       
       
      boolean thisAttributChanged =
      !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.mussPasswortWechseln
      , mussPasswortWechselnInternal);

      attributeChanged |= thisAttributChanged;

      hasChangedMussPasswortWechseln |= thisAttributChanged;

      if (thisAttributChanged) {
      markDirty("mussPasswortWechseln");
      }


             if (!isSeitLadenVeraendertMussPasswortWechseln) {
          isSeitLadenVeraendertMussPasswortWechseln = thisAttributChanged;
         if (isSeitLadenVeraendertMussPasswortWechseln){
           wertNachLadenMussPasswortWechseln=this.mussPasswortWechseln;
         }
       }
      

       this.mussPasswortWechseln = mussPasswortWechselnInternal;

         }

        
      @javax.persistence.Column(name = "PASSWORT", nullable = BenutzerConstants.PASSWORT_NULLABLE, length=BenutzerConstants.PASSWORT_MAX_LENGTH)
        
  protected String passwort =  null;

  @javax.persistence.Transient
  protected boolean hasChangedPasswort = false;

  public boolean hasChangedPasswort(){
    return hasChangedPasswort;
  }
       @javax.persistence.Transient
     private transient boolean isSeitLadenVeraendertPasswort = false;
     @javax.persistence.Transient
     private transient String wertNachLadenPasswort;
  
  /**
   * 
   *
   * getter for BENUTZER.PASSWORT
   */
    @Override   public  String getPasswort() {
        return passwort;
      }

  /**
   * 
   *
   * setter for BENUTZER.PASSWORT
   *
   * @param passwort
   */
  @Override   public void setPasswort( String passwort) {

       resetTkCache();
                  
                          String passwortInternal = de.ivu.elect.jee.entity.EntityUtil.trimToNullOrMaxLength(passwort, BenutzerConstants.PASSWORT_MAX_LENGTH, getId(), getClass());
                  
       
      boolean thisAttributChanged =
      !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.passwort
      , passwortInternal);

      attributeChanged |= thisAttributChanged;

      hasChangedPasswort |= thisAttributChanged;

      if (thisAttributChanged) {
      markDirty("passwort");
      }


             if (!isSeitLadenVeraendertPasswort) {
          isSeitLadenVeraendertPasswort = thisAttributChanged;
         if (isSeitLadenVeraendertPasswort){
           wertNachLadenPasswort=this.passwort;
         }
       }
      

       this.passwort = passwortInternal;

         }

        
  @javax.persistence.Column(name = "PROTOKOLLALIAS", nullable = BenutzerConstants.PROTOKOLLALIAS_NULLABLE, length=BenutzerConstants.PROTOKOLLALIAS_MAX_LENGTH)
        
  protected java.lang.String protokollalias =  null;

  @javax.persistence.Transient
  protected boolean hasChangedProtokollalias = false;

  public boolean hasChangedProtokollalias(){
    return hasChangedProtokollalias;
  }
       @javax.persistence.Transient
     private transient boolean isSeitLadenVeraendertProtokollalias = false;
     @javax.persistence.Transient
     private transient java.lang.String wertNachLadenProtokollalias;
  
  /**
   * 
   *
   * getter for BENUTZER.PROTOKOLLALIAS
   */
  @javax.annotation.Nullable   @Override   public  java.lang.String getProtokollalias() {
        return protokollalias;
      }

  /**
   * 
   *
   * setter for BENUTZER.PROTOKOLLALIAS
   *
   * @param protokollalias
   */
  @Override   public void setProtokollalias(@javax.annotation.Nullable  java.lang.String protokollalias) {

       resetTkCache();
                  
                          java.lang.String protokollaliasInternal = de.ivu.elect.jee.entity.EntityUtil.trimToNullOrMaxLength(protokollalias, BenutzerConstants.PROTOKOLLALIAS_MAX_LENGTH, getId(), getClass());
                  
       
      boolean thisAttributChanged =
      !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.protokollalias
      , protokollaliasInternal);

      attributeChanged |= thisAttributChanged;

      hasChangedProtokollalias |= thisAttributChanged;

      if (thisAttributChanged) {
      markDirty("protokollalias");
      }


             if (!isSeitLadenVeraendertProtokollalias) {
          isSeitLadenVeraendertProtokollalias = thisAttributChanged;
         if (isSeitLadenVeraendertProtokollalias){
           wertNachLadenProtokollalias=this.protokollalias;
         }
       }
      

       this.protokollalias = protokollaliasInternal;

         }

        
      @javax.persistence.Column(name = "SALT", nullable = BenutzerConstants.SALT_NULLABLE, length=BenutzerConstants.SALT_MAX_LENGTH)
        
  protected java.lang.String salt =  null;

  @javax.persistence.Transient
  protected boolean hasChangedSalt = false;

  public boolean hasChangedSalt(){
    return hasChangedSalt;
  }
       @javax.persistence.Transient
     private transient boolean isSeitLadenVeraendertSalt = false;
     @javax.persistence.Transient
     private transient java.lang.String wertNachLadenSalt;
  
  /**
   * 
   *
   * getter for BENUTZER.SALT
   */
    @Override   public  java.lang.String getSalt() {
        return salt;
      }

  /**
   * 
   *
   * setter for BENUTZER.SALT
   *
   * @param salt
   */
  @Override   public void setSalt( java.lang.String salt) {

       resetTkCache();
                  
                          java.lang.String saltInternal = de.ivu.elect.jee.entity.EntityUtil.trimToNullOrMaxLength(salt, BenutzerConstants.SALT_MAX_LENGTH, getId(), getClass());
                  
       
      boolean thisAttributChanged =
      !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.salt
      , saltInternal);

      attributeChanged |= thisAttributChanged;

      hasChangedSalt |= thisAttributChanged;

      if (thisAttributChanged) {
      markDirty("salt");
      }


             if (!isSeitLadenVeraendertSalt) {
          isSeitLadenVeraendertSalt = thisAttributChanged;
         if (isSeitLadenVeraendertSalt){
           wertNachLadenSalt=this.salt;
         }
       }
      

       this.salt = saltInternal;

         }

        
  @javax.persistence.Column(name = "TANLISTE", nullable = BenutzerConstants.TANLISTE_NULLABLE, length=BenutzerConstants.TANLISTE_MAX_LENGTH)
        
  protected java.lang.String tanliste =  null;

  @javax.persistence.Transient
  protected boolean hasChangedTanliste = false;

  public boolean hasChangedTanliste(){
    return hasChangedTanliste;
  }
  
  /**
   * 
   *
   * getter for BENUTZER.TANLISTE
   */
  @javax.annotation.Nullable   @Override   public  java.lang.String getTanliste() {
        return tanliste;
      }

  /**
   * 
   *
   * setter for BENUTZER.TANLISTE
   *
   * @param tanliste
   */
  @Override   public void setTanliste(@javax.annotation.Nullable  java.lang.String tanliste) {

       resetTkCache();
                  
                          java.lang.String tanlisteInternal = de.ivu.elect.jee.entity.EntityUtil.trimToNullOrMaxLength(tanliste, BenutzerConstants.TANLISTE_MAX_LENGTH, getId(), getClass());
                  
       
      boolean thisAttributChanged =
      !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.tanliste
      , tanlisteInternal);

      attributeChanged |= thisAttributChanged;

      hasChangedTanliste |= thisAttributChanged;

      if (thisAttributChanged) {
      markDirty("tanliste");
      }


      

       this.tanliste = tanlisteInternal;

         }

        
  @javax.persistence.Column(name = "VORNAME", nullable = BenutzerConstants.VORNAME_NULLABLE, length=BenutzerConstants.VORNAME_MAX_LENGTH)
        
  protected java.lang.String vorname =  null;

  @javax.persistence.Transient
  protected boolean hasChangedVorname = false;

  public boolean hasChangedVorname(){
    return hasChangedVorname;
  }
       @javax.persistence.Transient
     private transient boolean isSeitLadenVeraendertVorname = false;
     @javax.persistence.Transient
     private transient java.lang.String wertNachLadenVorname;
  
  /**
   * 
   *
   * getter for BENUTZER.VORNAME
   */
  @javax.annotation.Nullable   @Override   public  java.lang.String getVorname() {
        return vorname;
      }

  /**
   * 
   *
   * setter for BENUTZER.VORNAME
   *
   * @param vorname
   */
  @Override   public void setVorname(@javax.annotation.Nullable  java.lang.String vorname) {

       resetTkCache();
                  
                          java.lang.String vornameInternal = de.ivu.elect.jee.entity.EntityUtil.trimToNullOrMaxLength(vorname, BenutzerConstants.VORNAME_MAX_LENGTH, getId(), getClass());
                  
       
      boolean thisAttributChanged =
      !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.vorname
      , vornameInternal);

      attributeChanged |= thisAttributChanged;

      hasChangedVorname |= thisAttributChanged;

      if (thisAttributChanged) {
      markDirty("vorname");
      }


             if (!isSeitLadenVeraendertVorname) {
          isSeitLadenVeraendertVorname = thisAttributChanged;
         if (isSeitLadenVeraendertVorname){
           wertNachLadenVorname=this.vorname;
         }
       }
      

       this.vorname = vornameInternal;

         }

    
/**
 * Beziehungen N:1 unidirektional
 */
  /**
   * Beziehung (unidirektional) zu CustomDataStorage
   */
  @javax.persistence.ManyToOne(fetch =  javax.persistence.FetchType.LAZY , optional=true, cascade = {javax.persistence.CascadeType.PERSIST})
  @javax.persistence.JoinColumns(@javax.persistence.JoinColumn(name = "CUSTOM_DATA_STORAGE_ID", referencedColumnName="CUSTOM_DATA_STORAGE_ID"))
  protected de.ivu.elect.business.customdata.entity.CustomDataStorage customDataStorage;

  /**
   * 
   */
  @Override
  public void setCustomDataStorage(@javax.annotation.Nullable  de.ivu.elect.business.customdata.entity.CustomDataStorage customDataStorage){
    resetTkCache();
    
    boolean thisAttributChanged =
    !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.customDataStorage
    , customDataStorage);

    attributeChanged |= thisAttributChanged;

    hasChangedCustomDataStorage |= thisAttributChanged;

    if (thisAttributChanged) {
    markDirty("customDataStorage");
    }

    this.customDataStorage = customDataStorage;
      }

  /**
   * 
   */
  @javax.annotation.Nullable   @Override
  public de.ivu.elect.business.customdata.entity.CustomDataStorage getCustomDataStorage(){
    return this.customDataStorage;
  }

  @javax.persistence.Transient
  protected boolean hasChangedCustomDataStorage = false;

  public boolean hasChangedCustomDataStorage(){
    return hasChangedCustomDataStorage;
  }

  /**
   * Beziehung (unidirektional) zu Mandant
   */
  @javax.persistence.ManyToOne(fetch =  javax.persistence.FetchType.LAZY , optional=false, cascade = {javax.persistence.CascadeType.PERSIST})
  @javax.persistence.JoinColumns(@javax.persistence.JoinColumn(name = "MANDANT_ID", referencedColumnName="MANDANT_ID"))
  protected de.ivu.elect.business.mandant.entity.Mandant mandant;

  /**
   * 
   */
  @Override
  public void setMandant( de.ivu.elect.business.mandant.entity.Mandant mandant){
    resetTkCache();
    
    boolean thisAttributChanged =
    !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.mandant
    , mandant);

    attributeChanged |= thisAttributChanged;

    hasChangedMandant |= thisAttributChanged;

    if (thisAttributChanged) {
    markDirty("mandant");
    }

    this.mandant = mandant;
      }

  /**
   * 
   */
    @Override
  public de.ivu.elect.business.mandant.entity.Mandant getMandant(){
    return this.mandant;
  }

  @javax.persistence.Transient
  protected boolean hasChangedMandant = false;

  public boolean hasChangedMandant(){
    return hasChangedMandant;
  }


/**
 * Beziehungen N:1 bidirektional
 */

  /**
   * Beziehungen 1:N unidirektional (nicht unterstuetzt)
   */

  /**
   * Beziehungen 1:N bidirektional
   */

  /**
   * Beziehung 1:N (bidirektional) zu BenutzerParametersByBenutzer
   *
   */
  @javax.persistence.OneToMany(targetEntity=de.ivu.elect.business.benutzerverwaltung.entity.BenutzerParameter.class, mappedBy="benutzer", fetch=javax.persistence.FetchType.LAZY )
// deaktiviert, gibt Probleme beim Löschen  @org.hibernate.annotations.Cache(usage = org.hibernate.annotations.CacheConcurrencyStrategy.TRANSACTIONAL)
  protected java.util.Set<de.ivu.elect.business.benutzerverwaltung.entity.BenutzerParameter> benutzerParametersByBenutzer;


  /**
   * getter muss read-only verwendet werden, da die Beziehung auf der anderen Seite nicht aktualisiert wird!
   */
  
  @Override
  public java.util.Set<de.ivu.elect.business.benutzerverwaltung.entity.BenutzerParameter> getBenutzerParametersByBenutzer(){
    if (benutzerParametersByBenutzer == null){
      return  java.util.Collections.<de.ivu.elect.business.benutzerverwaltung.entity.BenutzerParameter>unmodifiableSet(java.util.Collections.<de.ivu.elect.business.benutzerverwaltung.entity.BenutzerParameter>emptySet());
    }

    return java.util.Collections.<de.ivu.elect.business.benutzerverwaltung.entity.BenutzerParameter>unmodifiableSet(this.benutzerParametersByBenutzer);
  }

  @javax.persistence.Transient
  private boolean hasChangedBenutzerParametersByBenutzer = false;

  public boolean hasChangedBenutzerParametersByBenutzer() {
    return hasChangedBenutzerParametersByBenutzer;
  }

  /**
   * Hinzufuegen von de.ivu.elect.business.benutzerverwaltung.entity.BenutzerParameter
   */
  @Override
  public void addBenutzerParameterByBenutzer(de.ivu.elect.business.benutzerverwaltung.entity.BenutzerParameter benutzerParameterByBenutzer){
    try {
      if (!updateRelationship){
        updateRelationship = true;

        if (benutzerParameterByBenutzer != null){
          if (this.benutzerParametersByBenutzer == null) {
            this.benutzerParametersByBenutzer = new java.util.HashSet<>();
          }

          boolean isChanged = this.benutzerParametersByBenutzer.add(benutzerParameterByBenutzer);

          if(!hasChangedBenutzerParametersByBenutzer) {
            hasChangedBenutzerParametersByBenutzer =  isChanged;
          }

          // andere Seite der Beziehung aktualisieren
          benutzerParameterByBenutzer.setBenutzer(this);
        }
      }
    } finally {
      updateRelationship = false;
    }
  }

  /**
   * Entfernen von de.ivu.elect.business.benutzerverwaltung.entity.BenutzerParameter
   */
  @Override
  public void removeBenutzerParameterByBenutzer(de.ivu.elect.business.benutzerverwaltung.entity.BenutzerParameter benutzerParameterByBenutzer){
    try {
      if (!updateRelationship){
        updateRelationship = true;

        if (benutzerParameterByBenutzer != null){
          if (this.benutzerParametersByBenutzer != null) {
            boolean isChanged = this.benutzerParametersByBenutzer.remove(benutzerParameterByBenutzer);

            if(!hasChangedBenutzerParametersByBenutzer) {
              hasChangedBenutzerParametersByBenutzer =  isChanged;
            }
          }

          // andere Seite der Beziehung aktualisieren
          benutzerParameterByBenutzer.setBenutzer(null);
        }
      }
    } finally {
      updateRelationship = false;
    }
  }

 /**
  * Entfernen von allen de.ivu.elect.business.benutzerverwaltung.entity.BenutzerParameter
  */
   @Override
   public void removeAllBenutzerParameterByBenutzers(){
     java.util.Set<de.ivu.elect.business.benutzerverwaltung.entity.BenutzerParameter> toRemove = new java.util.HashSet<>(getBenutzerParametersByBenutzer());

     for (   de.ivu.elect.business.benutzerverwaltung.entity.BenutzerParameter entity:toRemove){
       removeBenutzerParameterByBenutzer(entity);
     }
   }

  /**
   * Beziehungen N:M bidirektional nicht selbstreferenzierend
   */
  /**
   * Beziehung N:M (bidirektional, fuehrend) zu Rolles
   */
  @javax.persistence.ManyToMany(fetch=javax.persistence.FetchType.LAZY)
  @javax.persistence.JoinTable(name="BENUTZER_ROLLE",
     joinColumns = {@javax.persistence.JoinColumn(name="BENUTZER_ID", referencedColumnName="benutzer_id")},
     inverseJoinColumns = {@javax.persistence.JoinColumn(name="ROLLE_ID", referencedColumnName="ROLLE_ID")}) 
// deaktiviert, gibt Probleme beim Löschen   @org.hibernate.annotations.Cache(usage = org.hibernate.annotations.CacheConcurrencyStrategy.TRANSACTIONAL)
  protected java.util.Set<de.ivu.elect.business.benutzerverwaltung.entity.Rolle> rolles;

  /**
   * getter muss read-only verwendet werden, da die Beziehung auf der anderen Seite nicht aktualisiert wird!
   */
  @Override
  public java.util.Set<de.ivu.elect.business.benutzerverwaltung.entity.Rolle> getRolles(){
    if (rolles == null){
      return  java.util.Collections.<de.ivu.elect.business.benutzerverwaltung.entity.Rolle>unmodifiableSet(java.util.Collections.<de.ivu.elect.business.benutzerverwaltung.entity.Rolle>emptySet());
    }
    return java.util.Collections.<de.ivu.elect.business.benutzerverwaltung.entity.Rolle>unmodifiableSet(this.rolles);
  }


  @javax.persistence.Transient
  private boolean hasChangedRolles = false;

  public boolean hasChangedRolles() {
    return hasChangedRolles;
  }


 /**
  * Hinzufuegen von de.ivu.elect.business.benutzerverwaltung.entity.Rolle
  */
  @Override
  public void addRolle(de.ivu.elect.business.benutzerverwaltung.entity.Rolle rolle){
    try {
      if (!updateRelationship){
        updateRelationship = true;

        if (rolle != null){
          if (this.rolles == null){
            this.rolles = new java.util.HashSet<>();
          }

          boolean isChanged = this.rolles.add(rolle);

          if(!hasChangedRolles) {
            hasChangedRolles =  isChanged;
          }

            }
      }
    } finally {
      updateRelationship = false;
    }
  }

  /**
   * Entfernen von de.ivu.elect.business.benutzerverwaltung.entity.Rolle
   */
  @Override
  public void removeRolle(de.ivu.elect.business.benutzerverwaltung.entity.Rolle rolle){
    try {
      if (!updateRelationship){
        updateRelationship = true;
        if (rolle != null){
          if (this.rolles != null){
            boolean isChanged = this.rolles.remove(rolle);

            if(!hasChangedRolles) {
              hasChangedRolles =  isChanged;
            }
          }

                  }
      }
    } finally {
      updateRelationship = false;
    }
  }

 /**
  * Entfernen von allen  de.ivu.elect.business.benutzerverwaltung.entity.Rolle
  */
   @Override
   public void removeAllRolles(){
     java.util.Set<de.ivu.elect.business.benutzerverwaltung.entity.Rolle> toRemove = new java.util.HashSet<>(getRolles());

     for (   de.ivu.elect.business.benutzerverwaltung.entity.Rolle entity:toRemove){
       removeRolle(entity);
     }
   }
  /**
   * Beziehung N:M (bidirektional, fuehrend) zu Gebiets
   */
  @javax.persistence.ManyToMany(fetch=javax.persistence.FetchType.LAZY)
  @javax.persistence.JoinTable(name="BERECHTIGT_FUER",
     joinColumns = {@javax.persistence.JoinColumn(name="BENUTZER_ID", referencedColumnName="benutzer_id")},
     inverseJoinColumns = {@javax.persistence.JoinColumn(name="GEBIET_ID", referencedColumnName="GEBIET_ID")}) 
// deaktiviert, gibt Probleme beim Löschen   @org.hibernate.annotations.Cache(usage = org.hibernate.annotations.CacheConcurrencyStrategy.TRANSACTIONAL)
  protected java.util.Set<de.ivu.elect.business.gebietsbaum.entity.Gebiet> gebiets;

  /**
   * getter muss read-only verwendet werden, da die Beziehung auf der anderen Seite nicht aktualisiert wird!
   */
  @Override
  public java.util.Set<de.ivu.elect.business.gebietsbaum.entity.Gebiet> getGebiets(){
    if (gebiets == null){
      return  java.util.Collections.<de.ivu.elect.business.gebietsbaum.entity.Gebiet>unmodifiableSet(java.util.Collections.<de.ivu.elect.business.gebietsbaum.entity.Gebiet>emptySet());
    }
    return java.util.Collections.<de.ivu.elect.business.gebietsbaum.entity.Gebiet>unmodifiableSet(this.gebiets);
  }


  @javax.persistence.Transient
  private boolean hasChangedGebiets = false;

  public boolean hasChangedGebiets() {
    return hasChangedGebiets;
  }


 /**
  * Hinzufuegen von de.ivu.elect.business.gebietsbaum.entity.Gebiet
  */
  @Override
  public void addGebiet(de.ivu.elect.business.gebietsbaum.entity.Gebiet gebiet){
    try {
      if (!updateRelationship){
        updateRelationship = true;

        if (gebiet != null){
          if (this.gebiets == null){
            this.gebiets = new java.util.HashSet<>();
          }

          boolean isChanged = this.gebiets.add(gebiet);

          if(!hasChangedGebiets) {
            hasChangedGebiets =  isChanged;
          }

            }
      }
    } finally {
      updateRelationship = false;
    }
  }

  /**
   * Entfernen von de.ivu.elect.business.gebietsbaum.entity.Gebiet
   */
  @Override
  public void removeGebiet(de.ivu.elect.business.gebietsbaum.entity.Gebiet gebiet){
    try {
      if (!updateRelationship){
        updateRelationship = true;
        if (gebiet != null){
          if (this.gebiets != null){
            boolean isChanged = this.gebiets.remove(gebiet);

            if(!hasChangedGebiets) {
              hasChangedGebiets =  isChanged;
            }
          }

                  }
      }
    } finally {
      updateRelationship = false;
    }
  }

 /**
  * Entfernen von allen  de.ivu.elect.business.gebietsbaum.entity.Gebiet
  */
   @Override
   public void removeAllGebiets(){
     java.util.Set<de.ivu.elect.business.gebietsbaum.entity.Gebiet> toRemove = new java.util.HashSet<>(getGebiets());

     for (   de.ivu.elect.business.gebietsbaum.entity.Gebiet entity:toRemove){
       removeGebiet(entity);
     }
   }


  /**
   * Beziehungen N:M bidirektional selbstreferenzierend
   */
  

  @Override
  public String toString() {
    StringBuilder sb = new StringBuilder();
    sb.append("Benutzer:");
    sb.append(getId());
    sb.append(" (TK: ");
    try {
      sb.append(getTk());
    } catch (Exception e) {
      sb.append(e.getMessage());
    }
    sb.append(")");
    return sb.toString();
}



  /**
   * Kopiert alle Attribute (ausser PK und Version) und UNIDIREKTIONALE n:1-Beziehungen in uebergebene Entitaet.
   *
   * @param other
   *
   * @deprecated Sollte nur mit Bedacht genutzt werden, da hier auch die Beziehungen kopiert werden. Deswegen markiert
   *             als Deprecated.
   */
  @Deprecated
  protected void copyEntity(Benutzer other){
                             other.bemerkung = this.bemerkung;
                                other.benutzerkennung = this.benutzerkennung;
                                other.familienname = this.familienname;
                                other.geschlecht = this.geschlecht;
                                other.gesperrt = this.gesperrt;
                                other.hotpSecret = this.hotpSecret;
                                other.letzteAnmeldung = this.letzteAnmeldung;
                                other.letzteNachrichtId = this.letzteNachrichtId;
                                other.loginVersuche = this.loginVersuche;
                                other.mussPasswortWechseln = this.mussPasswortWechseln;
                                other.passwort = this.passwort;
                                other.protokollalias = this.protokollalias;
                                other.salt = this.salt;
                                other.tanliste = this.tanliste;
                                other.vorname = this.vorname;
           
  other.setCustomDataStorage(this.getCustomDataStorage());
  other.setMandant(this.getMandant());
    if (this.transientContext != null && !this.transientContext.isEmpty()) {
      other.getTransientContext().putAll(this.transientContext);
    }
  }



    @Override
    public void copyEntityAttributesToOtherEntity(de.ivu.elect.jee.entity.Entity other) {
      if (other==null){
        return;
      }
      if (other.isInstanceOf(Benutzer.class)){
        copyEntityAttributesUsingSetter((Benutzer) other.castTo(Benutzer.class).getEntity());
      } else {
        throw new IllegalArgumentException("Keine Instanz von Benutzer: " + other);
      }
    }

  /**
  * Kopiert alle Attribute (ausser PK und Version)  in uebergebene Entitaet.
  *
  */
  public void copyEntityAttributesUsingSetter(Benutzer other){
               other.setBemerkung(this.bemerkung);
                  other.setBenutzerkennung(this.benutzerkennung);
                  other.setFamilienname(this.familienname);
                  other.setGeschlecht(this.geschlecht);
                  other.setGesperrt(this.gesperrt);
                  other.setHotpSecret(this.hotpSecret);
                  other.setLetzteAnmeldung(this.letzteAnmeldung);
                  other.setLetzteNachrichtId(this.letzteNachrichtId);
                  other.setLoginVersuche(this.loginVersuche);
                  other.setMussPasswortWechseln(this.mussPasswortWechseln);
                  other.setPasswort(this.passwort);
                  other.setProtokollalias(this.protokollalias);
                  other.setSalt(this.salt);
                  other.setTanliste(this.tanliste);
                  other.setVorname(this.vorname);
           other.setCustomDataXml(this.getCustomDataXml());
    if (this.transientContext != null && !this.transientContext.isEmpty()) {
      other.getTransientContext().putAll(this.transientContext);
    }
  }


  /**
   * Kopiert alle veränderten Attribute (ausser PK, CustomData, wenn vorhanden und Version) in uebergebene Entitaet.
   *
   */
  public void copyChangedEntityAttributesUsingSetter(Benutzer other){
                       if (hasChangedBemerkung) {
        other.setBemerkung(this.bemerkung);
      }
                             if (hasChangedBenutzerkennung) {
        other.setBenutzerkennung(this.benutzerkennung);
      }
                             if (hasChangedFamilienname) {
        other.setFamilienname(this.familienname);
      }
                             if (hasChangedGeschlecht) {
        other.setGeschlecht(this.geschlecht);
      }
                             if (hasChangedGesperrt) {
        other.setGesperrt(this.gesperrt);
      }
                             if (hasChangedHotpSecret) {
        other.setHotpSecret(this.hotpSecret);
      }
                             if (hasChangedLetzteAnmeldung) {
        other.setLetzteAnmeldung(this.letzteAnmeldung);
      }
                             if (hasChangedLetzteNachrichtId) {
        other.setLetzteNachrichtId(this.letzteNachrichtId);
      }
                             if (hasChangedLoginVersuche) {
        other.setLoginVersuche(this.loginVersuche);
      }
                             if (hasChangedMussPasswortWechseln) {
        other.setMussPasswortWechseln(this.mussPasswortWechseln);
      }
                             if (hasChangedPasswort) {
        other.setPasswort(this.passwort);
      }
                             if (hasChangedProtokollalias) {
        other.setProtokollalias(this.protokollalias);
      }
                             if (hasChangedSalt) {
        other.setSalt(this.salt);
      }
                             if (hasChangedTanliste) {
        other.setTanliste(this.tanliste);
      }
                             if (hasChangedVorname) {
        other.setVorname(this.vorname);
      }
             }




    /**
    * Hat die Entität überhaupt einen CustomDataStorage?
    */
    private boolean isCustomDataSupported() {
      return getCustomDataStorage()!=null;
    }

    @Override
    public de.ivu.elect.jee.entity.customdata.CustomData getCustomData() {
      if (isCustomDataSupported()) {
        de.ivu.elect.jee.entity.customdata.CustomData result = getCustomDataStorage().getCustomData();
        result.setTechnicalEntity(this); // Fachliche Entität bei jedem Zugriff setzen
        return result;
      }
      return de.ivu.elect.jee.entity.customdata.EmptyCustomData.INSTANCE;
    }


    @Override
    @SuppressWarnings("unchecked")
    public <T extends de.ivu.elect.jee.entity.customdata.CustomData> T getCustomData(Class<T> clazz) {
      if (isCustomDataSupported()) {
        return (T) getCustomData();
      }
      throw new IllegalStateException("Entität Benutzer besitzt kein CustomDataStorage: "+this);
    }


    @Override
    public void updateCustomData() {
      if (isCustomDataSupported()) {
        getCustomDataStorage().updateCustomData();
      }
    }


    public void clearCustomDataCache() {
      if (isCustomDataSupported()) {
        getCustomDataStorage().clearCustomDataCache();
      }
    }

    @Override
    public String getCustomDataXml(){
      if (isCustomDataSupported()) {
        return getCustomDataStorage().getCustomDataXml();
      }
      return "";
    }

    @Override
    public void setCustomDataXml(String customDataXml){
      if (isCustomDataSupported()) {
        if (org.apache.commons.lang3.StringUtils.isBlank(customDataXml)) {
          if (de.ivu.elect.business.system.control.FailOnUnkownCustomData.FAIL_ON_UNKNOWN_CUSTOM_DATA) {
            throw new IllegalStateException("Entität Benutzer hat CustomDataStorage, soll aber kein CustomData aufnehmen: '"+customDataXml+"'");
          }
          // ELECTMUC-2581
          System.err.println("Entität Benutzer hat CustomDataStorage, soll aber kein CustomData aufnehmen: '"+customDataXml+"'");
        } else {
          getCustomDataStorage().setCustomDataXml(customDataXml);
        }
        clearCustomDataCache(); // WASDE-1131
      } else {
       if (org.apache.commons.lang3.StringUtils.isNotBlank(customDataXml)) {
         if (customDataXml.endsWith("EmptyCustomData/>")) {
            // Abwärtskompatibilität...alles gut, die alten, leeren CustomDataObjekte...
         } else {
           if (de.ivu.elect.business.system.control.FailOnUnkownCustomData.FAIL_ON_UNKNOWN_CUSTOM_DATA) {
             throw new IllegalStateException("Entität Benutzer hat kein CustomDataStorage, soll aber CustomData aufnehmen: '"+customDataXml+"'");
           }
           // ELECT-5122
           System.err.println("Entität Benutzer hat kein CustomDataStorage, soll aber CustomData aufnehmen: '"+customDataXml+"'");
         }
       }
      }
    }

    public boolean hasChangedCustomDataXml() {
      if (isCustomDataSupported()) {
        return getCustomDataStorage().hasChangedCustomDataXml();
      }
      return false;
    }


    @javax.persistence.Transient
    private transient BenutzerTK tkCache;

    protected void resetTkCache() {
        tkCache = null;
    }

    public BenutzerTK getBenutzerTK(){
    if (tkCache==null) {
    tkCache = new BenutzerTK(

getBenutzerkennung()


  );}
  return tkCache;
}
    @Override
    public de.ivu.elect.jee.entity.tk.EntityTK getTk() {
       return getBenutzerTK();
    }

  @Override
  public BenutzerUK getUk(){
    return getBenutzerUK();
  }

  @Override
  public Class< ? > getEntityClass() {
    return Benutzer.class;
  }

public BenutzerUK getBenutzerUK(){

   return  new BenutzerUK(

getBenutzerkennung()
,     getMandant()==null?null:getMandant().getMandantUK()


  );
}

  @javax.persistence.Transient
  private transient BenutzerProperties properties;

  public BenutzerProperties getProperties(){
    if (properties == null) {
      properties = new BenutzerProperties(this);
    }
    return properties;
  }

  /**
   * @deprecated getProperties() verwenden.
   */
  @Deprecated
  public BenutzerProperties getBenutzerProperties(){
    return getProperties();
  }

  @Override
  public String getEntityTechnicalName() {
    return BenutzerConstants.MESSAGE_KEY_ENTITY_EINZAHL;
  }

  @Override
  public boolean isAenderungenProtokollieren(){
    
    return true;
  }


    @Override
   public void setProtokollierteAttributeMitWerten(java.util.Map<String, de.ivu.elect.jee.protokollierung.AttributWertVorher> werteVorher) {
     
      if (werteVorher.containsKey(BenutzerConstants.MESSAGE_KEY_BEMERKUNG_EINZAHL)){
        de.ivu.elect.jee.protokollierung.AttributWertVorher vorher = werteVorher.get(BenutzerConstants.MESSAGE_KEY_BEMERKUNG_EINZAHL);

        bemerkung =
     vorher.getAttributTyp().getValueAsString(vorher.getWertVorher());
          }

            
      if (werteVorher.containsKey(BenutzerConstants.MESSAGE_KEY_BENUTZERKENNUNG_EINZAHL)){
        de.ivu.elect.jee.protokollierung.AttributWertVorher vorher = werteVorher.get(BenutzerConstants.MESSAGE_KEY_BENUTZERKENNUNG_EINZAHL);

        benutzerkennung =
     vorher.getAttributTyp().getValueAsString(vorher.getWertVorher());
          }

            
      if (werteVorher.containsKey(BenutzerConstants.MESSAGE_KEY_FAMILIENNAME_EINZAHL)){
        de.ivu.elect.jee.protokollierung.AttributWertVorher vorher = werteVorher.get(BenutzerConstants.MESSAGE_KEY_FAMILIENNAME_EINZAHL);

        familienname =
     vorher.getAttributTyp().getValueAsString(vorher.getWertVorher());
          }

            
      if (werteVorher.containsKey(BenutzerConstants.MESSAGE_KEY_GESCHLECHT_EINZAHL)){
        de.ivu.elect.jee.protokollierung.AttributWertVorher vorher = werteVorher.get(BenutzerConstants.MESSAGE_KEY_GESCHLECHT_EINZAHL);

        geschlecht =
     (de.ivu.elect.business.person.entity.Geschlecht) vorher.getAttributTyp().getValueAsEnum(vorher.getWertVorher());
          }

            
      if (werteVorher.containsKey(BenutzerConstants.MESSAGE_KEY_GESPERRT_EINZAHL)){
        de.ivu.elect.jee.protokollierung.AttributWertVorher vorher = werteVorher.get(BenutzerConstants.MESSAGE_KEY_GESPERRT_EINZAHL);

        gesperrt =
     vorher.getAttributTyp().getValueAsBoolean(vorher.getWertVorher());
          }

                    
      if (werteVorher.containsKey(BenutzerConstants.MESSAGE_KEY_LETZTE_ANMELDUNG_EINZAHL)){
        de.ivu.elect.jee.protokollierung.AttributWertVorher vorher = werteVorher.get(BenutzerConstants.MESSAGE_KEY_LETZTE_ANMELDUNG_EINZAHL);

        letzteAnmeldung =
     vorher.getAttributTyp().getValueAsDate(vorher.getWertVorher());
          }

            
      if (werteVorher.containsKey(BenutzerConstants.MESSAGE_KEY_LETZTE_NACHRICHT_ID_EINZAHL)){
        de.ivu.elect.jee.protokollierung.AttributWertVorher vorher = werteVorher.get(BenutzerConstants.MESSAGE_KEY_LETZTE_NACHRICHT_ID_EINZAHL);

        letzteNachrichtId =
                        vorher.getAttributTyp().getValueAsLong(vorher.getWertVorher());
                  }

            
      if (werteVorher.containsKey(BenutzerConstants.MESSAGE_KEY_LOGINVERSUCHE_EINZAHL)){
        de.ivu.elect.jee.protokollierung.AttributWertVorher vorher = werteVorher.get(BenutzerConstants.MESSAGE_KEY_LOGINVERSUCHE_EINZAHL);

        loginVersuche =
                        vorher.getAttributTyp().getValueAsLong(vorher.getWertVorher());
                  }

            
      if (werteVorher.containsKey(BenutzerConstants.MESSAGE_KEY_MUSS_PASSWORT_WECHSELN_EINZAHL)){
        de.ivu.elect.jee.protokollierung.AttributWertVorher vorher = werteVorher.get(BenutzerConstants.MESSAGE_KEY_MUSS_PASSWORT_WECHSELN_EINZAHL);

        mussPasswortWechseln =
     vorher.getAttributTyp().getValueAsBoolean(vorher.getWertVorher());
          }

            
      if (werteVorher.containsKey(BenutzerConstants.MESSAGE_KEY_PASSWORT_EINZAHL)){
        de.ivu.elect.jee.protokollierung.AttributWertVorher vorher = werteVorher.get(BenutzerConstants.MESSAGE_KEY_PASSWORT_EINZAHL);

        passwort =
     vorher.getAttributTyp().getValueAsString(vorher.getWertVorher());
          }

            
      if (werteVorher.containsKey(BenutzerConstants.MESSAGE_KEY_PROTOKOLLALIAS_EINZAHL)){
        de.ivu.elect.jee.protokollierung.AttributWertVorher vorher = werteVorher.get(BenutzerConstants.MESSAGE_KEY_PROTOKOLLALIAS_EINZAHL);

        protokollalias =
     vorher.getAttributTyp().getValueAsString(vorher.getWertVorher());
          }

            
      if (werteVorher.containsKey(BenutzerConstants.MESSAGE_KEY_SALT_EINZAHL)){
        de.ivu.elect.jee.protokollierung.AttributWertVorher vorher = werteVorher.get(BenutzerConstants.MESSAGE_KEY_SALT_EINZAHL);

        salt =
     vorher.getAttributTyp().getValueAsString(vorher.getWertVorher());
          }

                    
      if (werteVorher.containsKey(BenutzerConstants.MESSAGE_KEY_VORNAME_EINZAHL)){
        de.ivu.elect.jee.protokollierung.AttributWertVorher vorher = werteVorher.get(BenutzerConstants.MESSAGE_KEY_VORNAME_EINZAHL);

        vorname =
     vorher.getAttributTyp().getValueAsString(vorher.getWertVorher());
          }

                }

  @Override
  public java.util.Map<String, de.ivu.elect.jee.protokollierung.VorherNachherWert> getProtokollierteAttributeMitWerten() {
    java.util.Map<String,de.ivu.elect.jee.protokollierung.VorherNachherWert> result;
        result = createEmptyProtokollierteAttributeMitWertenMap();
                        if (isSeitLadenVeraendertBemerkung) {
      result.put(BenutzerConstants.MESSAGE_KEY_BEMERKUNG_EINZAHL, new de.ivu.elect.jee.protokollierung.VorherNachherWert(
         de.ivu.elect.jee.protokollierung.AttributTyp.STRING
                , wertNachLadenBemerkung , bemerkung));
    }
                            if (isSeitLadenVeraendertBenutzerkennung) {
      result.put(BenutzerConstants.MESSAGE_KEY_BENUTZERKENNUNG_EINZAHL, new de.ivu.elect.jee.protokollierung.VorherNachherWert(
         de.ivu.elect.jee.protokollierung.AttributTyp.STRING
                , wertNachLadenBenutzerkennung , benutzerkennung));
    }
                            if (isSeitLadenVeraendertFamilienname) {
      result.put(BenutzerConstants.MESSAGE_KEY_FAMILIENNAME_EINZAHL, new de.ivu.elect.jee.protokollierung.VorherNachherWert(
         de.ivu.elect.jee.protokollierung.AttributTyp.STRING
                , wertNachLadenFamilienname , familienname));
    }
                            if (isSeitLadenVeraendertGeschlecht) {
      result.put(BenutzerConstants.MESSAGE_KEY_GESCHLECHT_EINZAHL, new de.ivu.elect.jee.protokollierung.VorherNachherWert(
         de.ivu.elect.jee.protokollierung.AttributTyp.ENUM
                , wertNachLadenGeschlecht , geschlecht));
    }
                            if (isSeitLadenVeraendertGesperrt) {
      result.put(BenutzerConstants.MESSAGE_KEY_GESPERRT_EINZAHL, new de.ivu.elect.jee.protokollierung.VorherNachherWert(
         de.ivu.elect.jee.protokollierung.AttributTyp.BOOLEAN
                , wertNachLadenGesperrt , gesperrt));
    }
                                                if (isSeitLadenVeraendertLetzteAnmeldung) {
      result.put(BenutzerConstants.MESSAGE_KEY_LETZTE_ANMELDUNG_EINZAHL, new de.ivu.elect.jee.protokollierung.VorherNachherWert(
         de.ivu.elect.jee.protokollierung.AttributTyp.TIMESTAMP
                , wertNachLadenLetzteAnmeldung , letzteAnmeldung));
    }
                            if (isSeitLadenVeraendertLetzteNachrichtId) {
      result.put(BenutzerConstants.MESSAGE_KEY_LETZTE_NACHRICHT_ID_EINZAHL, new de.ivu.elect.jee.protokollierung.VorherNachherWert(
                                    de.ivu.elect.jee.protokollierung.AttributTyp.LONG
                            , wertNachLadenLetzteNachrichtId , letzteNachrichtId));
    }
                            if (isSeitLadenVeraendertLoginVersuche) {
      result.put(BenutzerConstants.MESSAGE_KEY_LOGINVERSUCHE_EINZAHL, new de.ivu.elect.jee.protokollierung.VorherNachherWert(
                                    de.ivu.elect.jee.protokollierung.AttributTyp.LONG
                            , wertNachLadenLoginVersuche , loginVersuche));
    }
                            if (isSeitLadenVeraendertMussPasswortWechseln) {
      result.put(BenutzerConstants.MESSAGE_KEY_MUSS_PASSWORT_WECHSELN_EINZAHL, new de.ivu.elect.jee.protokollierung.VorherNachherWert(
         de.ivu.elect.jee.protokollierung.AttributTyp.BOOLEAN
                , wertNachLadenMussPasswortWechseln , mussPasswortWechseln));
    }
                            if (isSeitLadenVeraendertPasswort) {
      result.put(BenutzerConstants.MESSAGE_KEY_PASSWORT_EINZAHL, new de.ivu.elect.jee.protokollierung.VorherNachherWert(
         de.ivu.elect.jee.protokollierung.AttributTyp.STRING
                , wertNachLadenPasswort , passwort));
    }
                            if (isSeitLadenVeraendertProtokollalias) {
      result.put(BenutzerConstants.MESSAGE_KEY_PROTOKOLLALIAS_EINZAHL, new de.ivu.elect.jee.protokollierung.VorherNachherWert(
         de.ivu.elect.jee.protokollierung.AttributTyp.STRING
                , wertNachLadenProtokollalias , protokollalias));
    }
                            if (isSeitLadenVeraendertSalt) {
      result.put(BenutzerConstants.MESSAGE_KEY_SALT_EINZAHL, new de.ivu.elect.jee.protokollierung.VorherNachherWert(
         de.ivu.elect.jee.protokollierung.AttributTyp.STRING
                , wertNachLadenSalt , salt));
    }
                                                if (isSeitLadenVeraendertVorname) {
      result.put(BenutzerConstants.MESSAGE_KEY_VORNAME_EINZAHL, new de.ivu.elect.jee.protokollierung.VorherNachherWert(
         de.ivu.elect.jee.protokollierung.AttributTyp.STRING
                , wertNachLadenVorname , vorname));
    }
                return result;
  }

  @Override
  public void resetProtokollierteAttribute() {
                      isSeitLadenVeraendertBemerkung = false;
      wertNachLadenBemerkung = null;
                          isSeitLadenVeraendertBenutzerkennung = false;
      wertNachLadenBenutzerkennung = null;
                          isSeitLadenVeraendertFamilienname = false;
      wertNachLadenFamilienname = null;
                          isSeitLadenVeraendertGeschlecht = false;
      wertNachLadenGeschlecht = null;
                          isSeitLadenVeraendertGesperrt = false;
      wertNachLadenGesperrt = null;
                                          isSeitLadenVeraendertLetzteAnmeldung = false;
      wertNachLadenLetzteAnmeldung = null;
                          isSeitLadenVeraendertLetzteNachrichtId = false;
      wertNachLadenLetzteNachrichtId = null;
                          isSeitLadenVeraendertLoginVersuche = false;
      wertNachLadenLoginVersuche = null;
                          isSeitLadenVeraendertMussPasswortWechseln = false;
      wertNachLadenMussPasswortWechseln = null;
                          isSeitLadenVeraendertPasswort = false;
      wertNachLadenPasswort = null;
                          isSeitLadenVeraendertProtokollalias = false;
      wertNachLadenProtokollalias = null;
                          isSeitLadenVeraendertSalt = false;
      wertNachLadenSalt = null;
                                          isSeitLadenVeraendertVorname = false;
      wertNachLadenVorname = null;
                   }

  @Override
  public  java.util.List<de.ivu.elect.jee.entity.EntityFachlichAbhaengigNode> getFachlichAbhaengigeEntitaeten(){
            java.util.List<de.ivu.elect.jee.entity.EntityFachlichAbhaengigNode> result = new java.util.ArrayList<>();
                            return result;
  }

        
            protected String getInitialDiscriminator() {
              return "BENUTZER";
            }

            @Override
            public boolean isInstanceOf(Class<?> clazz) {
            return clazz.isInstance(this);
            }


            @Override
            public <E> de.ivu.elect.jee.entity.EntityContainer<E> castTo(Class<E> clazz) {
                return new de.ivu.elect.jee.entity.EntityContainer<>((E)this); // EntityContainer ist notwendig, da sonst von Hibernate die Entität wieder durch ihren Proxy ersetzt wird...
            }

  public boolean isPersistent() {
    return getId() != null;
  }


   private static final String BASE_CLASS_NAME = "Benutzer";
   @Override
   public String getBaseClassName() {
     return BASE_CLASS_NAME;
   }


    @Override
    public boolean equals(Object obj) {
    if (obj == null) {
    return false;
    }

    if (this==obj) {
    return true;
    }


    if (id != null) {
      try {
        return id.longValue() == ((de.ivu.elect.jee.entity.Entity) obj).getId().longValue() && BASE_CLASS_NAME.equals(((de.ivu.elect.jee.entity.Entity) obj).getBaseClassName());
      } catch (Exception ignored) {
        // do nothing
        return false;
      }
    }
   return super.equals(obj);
    }

  @javax.persistence.Transient
  private transient boolean hashCodeBerechnet = false;

  @javax.persistence.Transient
  private transient int hashCode = 0;


  @Deprecated // nur in Unit-Tests verwenden(!)
  public void resetHashCode() {
    hashCodeBerechnet = false;
    hashCode = 0;
  }

  @Override
    public int hashCode() {
      if (hashCodeBerechnet) {
      return hashCode;
    }

    if (id == null) {
      hashCode = super.hashCode();
    } else {
      hashCode = id.hashCode();
    }

    hashCodeBerechnet = true;

    return hashCode;

    }


                            @javax.persistence.Transient
                private transient java.util.Set
            <String> dirtyProperties = null;

                protected void markDirty(String property) {
            
          }

          public java.util.Set
      <String> getDirtyProperties() {
          if (dirtyProperties==null){
          dirtyProperties = new java.util.HashSet<>();
          }
          return dirtyProperties;
          }

          public void clearDirtyProperties(){
          dirtyProperties = null;
          }
          public boolean isHibernateDirty() {
            return dirtyProperties!=null;
          }

      
                public void resetValidation() {
        
    validationResult = null;
        }

        @javax.persistence.Transient
        private transient java.util.Set<de.ivu.elect.jee.entity.EntityConstraintViolation> validationResult;

                    public java.util.Set<de.ivu.elect.jee.entity.EntityConstraintViolation> validateEntity() {
            if (validationResult==null) {
               validationResult  = new java.util.HashSet<>();
                                                                                                           de.ivu.elect.jee.entity.EntityConstraintCheck.checkStringLength(BenutzerConstants.BEMERKUNG_MAX_LENGTH ,  bemerkung, this, BenutzerConstants.MESSAGE_KEY_BEMERKUNG_EINZAHL, validationResult);
                                                           de.ivu.elect.jee.entity.EntityConstraintCheck.checkNotNull(benutzerkennung, this, BenutzerConstants.MESSAGE_KEY_BENUTZERKENNUNG_EINZAHL, validationResult);
                                                                          de.ivu.elect.jee.entity.EntityConstraintCheck.checkStringLength(BenutzerConstants.BENUTZERKENNUNG_MAX_LENGTH , 1 ,  benutzerkennung, this, BenutzerConstants.MESSAGE_KEY_BENUTZERKENNUNG_EINZAHL, validationResult);
                                                                                                   de.ivu.elect.jee.entity.EntityConstraintCheck.checkStringLength(BenutzerConstants.FAMILIENNAME_MAX_LENGTH ,  familienname, this, BenutzerConstants.MESSAGE_KEY_FAMILIENNAME_EINZAHL, validationResult);
                                                           de.ivu.elect.jee.entity.EntityConstraintCheck.checkNotNull(geschlecht, this, BenutzerConstants.MESSAGE_KEY_GESCHLECHT_EINZAHL, validationResult);
                                                                                                                                                                                            de.ivu.elect.jee.entity.EntityConstraintCheck.checkStringLength(BenutzerConstants.HOTP_SECRET_MAX_LENGTH ,  hotpSecret, this, BenutzerConstants.MESSAGE_KEY_HOTP_SECRET_EINZAHL, validationResult);
                                                                                                                                                            de.ivu.elect.jee.entity.EntityConstraintCheck.checkValueRange(BenutzerConstants.LETZTE_NACHRICHT_ID_MAX_VALUE, BenutzerConstants.LETZTE_NACHRICHT_ID_MIN_VALUE, letzteNachrichtId, this, BenutzerConstants.MESSAGE_KEY_LETZTE_NACHRICHT_ID_EINZAHL, validationResult);
                                                           de.ivu.elect.jee.entity.EntityConstraintCheck.checkNotNull(loginVersuche, this, BenutzerConstants.MESSAGE_KEY_LOGINVERSUCHE_EINZAHL, validationResult);
                                                                          de.ivu.elect.jee.entity.EntityConstraintCheck.checkValueRange(BenutzerConstants.LOGINVERSUCHE_MAX_VALUE, BenutzerConstants.LOGINVERSUCHE_MIN_VALUE, loginVersuche, this, BenutzerConstants.MESSAGE_KEY_LOGINVERSUCHE_EINZAHL, validationResult);
                                                                                                                    de.ivu.elect.jee.entity.EntityConstraintCheck.checkNotNull(passwort, this, BenutzerConstants.MESSAGE_KEY_PASSWORT_EINZAHL, validationResult);
                                                                          de.ivu.elect.jee.entity.EntityConstraintCheck.checkStringLength(BenutzerConstants.PASSWORT_MAX_LENGTH , 1 ,  passwort, this, BenutzerConstants.MESSAGE_KEY_PASSWORT_EINZAHL, validationResult);
                                                                                                   de.ivu.elect.jee.entity.EntityConstraintCheck.checkStringLength(BenutzerConstants.PROTOKOLLALIAS_MAX_LENGTH ,  protokollalias, this, BenutzerConstants.MESSAGE_KEY_PROTOKOLLALIAS_EINZAHL, validationResult);
                                                           de.ivu.elect.jee.entity.EntityConstraintCheck.checkNotNull(salt, this, BenutzerConstants.MESSAGE_KEY_SALT_EINZAHL, validationResult);
                                                                          de.ivu.elect.jee.entity.EntityConstraintCheck.checkStringLength(BenutzerConstants.SALT_MAX_LENGTH , 1 ,  salt, this, BenutzerConstants.MESSAGE_KEY_SALT_EINZAHL, validationResult);
                                                                                                   de.ivu.elect.jee.entity.EntityConstraintCheck.checkStringLength(BenutzerConstants.TANLISTE_MAX_LENGTH ,  tanliste, this, BenutzerConstants.MESSAGE_KEY_TANLISTE_EINZAHL, validationResult);
                                                                                                   de.ivu.elect.jee.entity.EntityConstraintCheck.checkStringLength(BenutzerConstants.VORNAME_MAX_LENGTH ,  vorname, this, BenutzerConstants.MESSAGE_KEY_VORNAME_EINZAHL, validationResult);
                                    }
             return validationResult;
        }

            
        @javax.persistence.Transient
        protected transient java.util.Map<String, Object> transientContext;

        @Override
        public java.util.Map<String, Object> getTransientContext() {
          if (transientContext == null) {
             transientContext = new java.util.HashMap<>();
          }
        return transientContext;

        }
                              }
