/*
 * 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.aufgabe.entity;

@javax.persistence.NamedQueries(
 {



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

                         + "o"
                +".nummer"
              +" = ?1"

             +" AND "         + "o"
                +".wahl"
                +".wahlart"
                +".name"
              +" = ?2"

             +" AND "         + "o"
                +".wahl"
                +".wahlart"
                +".mandant"
                +".nummer"
              +" = ?3"

             +" AND "         + "o"
                +".wahl"
                +".wahltermin"
                +".nummer"
              +" = ?4"

             +" AND "         + "o"
                +".wahl"
                +".wahltermin"
                +".wahldatum"
              +" = ?5"

             +" AND "         + "o"
                +".wahl"
                +".wahltermin"
                +".mandant"
                +".nummer"
              +" = ?6"

             +" AND "         + "o"
                +".wahltermin"
                +".nummer"
              +" = ?7"

             +" AND "         + "o"
                +".wahltermin"
                +".wahldatum"
              +" = ?8"

             +" AND "         + "o"
                +".wahltermin"
                +".mandant"
                +".nummer"
              +" = ?9"

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


   )
   
     ,   @javax.persistence.NamedQuery(
     name="AUFGABE.WahlMaxNummer",
     query="SELECT MAX(o.nummer) FROM Aufgabe o WHERE o.wahl = ?1",
     hints = {@javax.persistence.QueryHint(name = "org.hibernate.cacheable", value = "false"),
                            @javax.persistence.QueryHint(name = "org.hibernate.flushMode", value = "commit")
             }
   )

        
         ,   @javax.persistence.NamedQuery(
     name="AUFGABE.Wahl",
     query="SELECT o FROM Aufgabe o WHERE o.wahl = ?1",
     hints = {@javax.persistence.QueryHint(name = "org.hibernate.cacheable", value = "true"),
                            @javax.persistence.QueryHint(name = "org.hibernate.flushMode", value = "commit")
             }
   )

        
         ,   @javax.persistence.NamedQuery(
     name="AUFGABE.WahlterminMaxNummer",
     query="SELECT MAX(o.nummer) FROM Aufgabe o WHERE o.wahltermin = ?1",
     hints = {@javax.persistence.QueryHint(name = "org.hibernate.cacheable", value = "false"),
                            @javax.persistence.QueryHint(name = "org.hibernate.flushMode", value = "commit")
             }
   )

        
         ,   @javax.persistence.NamedQuery(
     name="AUFGABE.Wahltermin",
     query="SELECT o FROM Aufgabe o WHERE o.wahltermin = ?1",
     hints = {@javax.persistence.QueryHint(name = "org.hibernate.cacheable", value = "true"),
                            @javax.persistence.QueryHint(name = "org.hibernate.flushMode", value = "commit")
             }
   )

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

public
 class Aufgabe
extends AbstractAufgabe
  {

  private static final long serialVersionUID = 0L;


  /**
   * default constructor
   */
  public Aufgabe() {
    super();
  }

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

  /**
   * PRIMARY KEY
   */
  @javax.persistence.Id
  @javax.persistence.Column(name = "aufgabe_id")
    @javax.persistence.GeneratedValue(strategy = javax.persistence.GenerationType.TABLE, generator = "Aufgabe")
    @javax.persistence.TableGenerator(name = "Aufgabe", table = "SEQUENCES", pkColumnName = "sequence_name", pkColumnValue = "Aufgabe", 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 AufgabePK pkCache;

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

    return pkCache;
  }

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

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

    return result;
  }

  public static <E extends Aufgabe> 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() {
        hasChangedAufgabentyp = false;
          hasChangedBearbeiterKennung = false;
          hasChangedBeschreibung = false;
          hasChangedDauerAnzahl = false;
          hasChangedDauerEinheit = false;
          hasChangedErstellerKennung = false;
          hasChangedErstellerTyp = false;
          hasChangedErstelltAm = false;
          hasChangedFaelligkeitAnzahl = false;
          hasChangedFaelligkeitEinheit = false;
          hasChangedFaelligkeitZeitpunkt = false;
          hasChangedKategorie = false;
          hasChangedLoesung = false;
          hasChangedNummer = false;
          hasChangedPrioritaet = false;
          hasChangedRechtsgrundlage = false;
          hasChangedStatus = false;
          hasChangedTitel = false;
          hasChangedVerantwortlich = false;
  
      hasChangedBearbeitet = false;
        hasChangedSichtbar = false;
        hasChangedWahltermin = false;
        hasChangedWahl = false;
  

          hasChangedAufgabeKommentarsByAufgabe = false;
      
    attributeChanged = false;
  }


  /**
   * ATTRIBUTE
   */

    
    @javax.persistence.Enumerated(javax.persistence.EnumType.STRING)
      @javax.persistence.Column(name = "AUFGABENTYP", nullable = AufgabeConstants.AUFGABENTYP_NULLABLE)
    
  protected de.ivu.elect.business.aufgabe.entity.Aufgabentyp aufgabentyp =  null;

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

  public boolean hasChangedAufgabentyp(){
    return hasChangedAufgabentyp;
  }
       @javax.persistence.Transient
     private transient boolean isSeitLadenVeraendertAufgabentyp = false;
     @javax.persistence.Transient
     private transient de.ivu.elect.business.aufgabe.entity.Aufgabentyp wertNachLadenAufgabentyp;
  
  /**
   * 
   *
   * getter for AUFGABE.AUFGABENTYP
   */
    @Override   public  de.ivu.elect.business.aufgabe.entity.Aufgabentyp getAufgabentyp() {
        return aufgabentyp;
      }

  /**
   * 
   *
   * setter for AUFGABE.AUFGABENTYP
   *
   * @param aufgabentyp
   */
  @Override   public void setAufgabentyp( de.ivu.elect.business.aufgabe.entity.Aufgabentyp aufgabentyp) {

       resetTkCache();
                  de.ivu.elect.business.aufgabe.entity.Aufgabentyp aufgabentypInternal = aufgabentyp;
       
       
      boolean thisAttributChanged =
      !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.aufgabentyp
      , aufgabentypInternal);

      attributeChanged |= thisAttributChanged;

      hasChangedAufgabentyp |= thisAttributChanged;

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


             if (!isSeitLadenVeraendertAufgabentyp) {
          isSeitLadenVeraendertAufgabentyp = thisAttributChanged;
         if (isSeitLadenVeraendertAufgabentyp){
           wertNachLadenAufgabentyp=this.aufgabentyp;
         }
       }
      

       this.aufgabentyp = aufgabentypInternal;

         }

        
  @javax.persistence.Column(name = "BEARBEITER_KENNUNG", nullable = AufgabeConstants.BEARBEITER_KENNUNG_NULLABLE, length=AufgabeConstants.BEARBEITER_KENNUNG_MAX_LENGTH)
        
  protected java.lang.String bearbeiterKennung =  null;

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

  public boolean hasChangedBearbeiterKennung(){
    return hasChangedBearbeiterKennung;
  }
       @javax.persistence.Transient
     private transient boolean isSeitLadenVeraendertBearbeiterKennung = false;
     @javax.persistence.Transient
     private transient java.lang.String wertNachLadenBearbeiterKennung;
  
  /**
   * 
   *
   * getter for AUFGABE.BEARBEITER_KENNUNG
   */
  @javax.annotation.Nullable   @Override   public  java.lang.String getBearbeiterKennung() {
        return bearbeiterKennung;
      }

  /**
   * 
   *
   * setter for AUFGABE.BEARBEITER_KENNUNG
   *
   * @param bearbeiterKennung
   */
  @Override   public void setBearbeiterKennung(@javax.annotation.Nullable  java.lang.String bearbeiterKennung) {

       resetTkCache();
                  
                          java.lang.String bearbeiterKennungInternal = de.ivu.elect.jee.entity.EntityUtil.trimToNullOrMaxLength(bearbeiterKennung, AufgabeConstants.BEARBEITER_KENNUNG_MAX_LENGTH, getId(), getClass());
                  
       
      boolean thisAttributChanged =
      !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.bearbeiterKennung
      , bearbeiterKennungInternal);

      attributeChanged |= thisAttributChanged;

      hasChangedBearbeiterKennung |= thisAttributChanged;

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


             if (!isSeitLadenVeraendertBearbeiterKennung) {
          isSeitLadenVeraendertBearbeiterKennung = thisAttributChanged;
         if (isSeitLadenVeraendertBearbeiterKennung){
           wertNachLadenBearbeiterKennung=this.bearbeiterKennung;
         }
       }
      

       this.bearbeiterKennung = bearbeiterKennungInternal;

         }

        
  @javax.persistence.Column(name = "BESCHREIBUNG", nullable = AufgabeConstants.BESCHREIBUNG_NULLABLE, length=AufgabeConstants.BESCHREIBUNG_MAX_LENGTH)
        
  protected java.lang.String beschreibung =  null;

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

  public boolean hasChangedBeschreibung(){
    return hasChangedBeschreibung;
  }
       @javax.persistence.Transient
     private transient boolean isSeitLadenVeraendertBeschreibung = false;
     @javax.persistence.Transient
     private transient java.lang.String wertNachLadenBeschreibung;
  
  /**
   * 
   *
   * getter for AUFGABE.BESCHREIBUNG
   */
  @javax.annotation.Nullable   @Override   public  java.lang.String getBeschreibung() {
        return beschreibung;
      }

  /**
   * 
   *
   * setter for AUFGABE.BESCHREIBUNG
   *
   * @param beschreibung
   */
  @Override   public void setBeschreibung(@javax.annotation.Nullable  java.lang.String beschreibung) {

       resetTkCache();
                  
                          java.lang.String beschreibungInternal = de.ivu.elect.jee.entity.EntityUtil.trimToNullOrMaxLength(beschreibung, AufgabeConstants.BESCHREIBUNG_MAX_LENGTH, getId(), getClass());
                  
       
      boolean thisAttributChanged =
      !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.beschreibung
      , beschreibungInternal);

      attributeChanged |= thisAttributChanged;

      hasChangedBeschreibung |= thisAttributChanged;

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


             if (!isSeitLadenVeraendertBeschreibung) {
          isSeitLadenVeraendertBeschreibung = thisAttributChanged;
         if (isSeitLadenVeraendertBeschreibung){
           wertNachLadenBeschreibung=this.beschreibung;
         }
       }
      

       this.beschreibung = beschreibungInternal;

         }

        
      @javax.persistence.Column(name = "DAUER_ANZAHL", nullable = AufgabeConstants.DAUER_ANZAHL_NULLABLE, precision=AufgabeConstants.DAUER_ANZAHL_PRECISION, scale=AufgabeConstants.DAUER_ANZAHL_SCALE)
            
  protected java.lang.Long dauerAnzahl =  Long.valueOf("0");

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

  public boolean hasChangedDauerAnzahl(){
    return hasChangedDauerAnzahl;
  }
       @javax.persistence.Transient
     private transient boolean isSeitLadenVeraendertDauerAnzahl = false;
     @javax.persistence.Transient
     private transient java.lang.Long wertNachLadenDauerAnzahl;
  
  /**
   * 
   *
   * getter for AUFGABE.DAUER_ANZAHL
   */
    @Override   public  java.lang.Long getDauerAnzahl() {
        return dauerAnzahl;
      }

  /**
   * 
   *
   * setter for AUFGABE.DAUER_ANZAHL
   *
   * @param dauerAnzahl
   */
  @Override   public void setDauerAnzahl( java.lang.Long dauerAnzahl) {

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

      attributeChanged |= thisAttributChanged;

      hasChangedDauerAnzahl |= thisAttributChanged;

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


             if (!isSeitLadenVeraendertDauerAnzahl) {
          isSeitLadenVeraendertDauerAnzahl = thisAttributChanged;
         if (isSeitLadenVeraendertDauerAnzahl){
           wertNachLadenDauerAnzahl=this.dauerAnzahl;
         }
       }
      

       this.dauerAnzahl = dauerAnzahlInternal;

         }

        
    @javax.persistence.Enumerated(javax.persistence.EnumType.STRING)
      @javax.persistence.Column(name = "DAUER_EINHEIT", nullable = AufgabeConstants.DAUER_EINHEIT_NULLABLE)
    
  protected de.ivu.elect.business.aufgabe.entity.AufgabenEinheitTyp dauerEinheit =  de.ivu.elect.business.aufgabe.entity.AufgabenEinheitTyp.OHNE;

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

  public boolean hasChangedDauerEinheit(){
    return hasChangedDauerEinheit;
  }
       @javax.persistence.Transient
     private transient boolean isSeitLadenVeraendertDauerEinheit = false;
     @javax.persistence.Transient
     private transient de.ivu.elect.business.aufgabe.entity.AufgabenEinheitTyp wertNachLadenDauerEinheit;
  
  /**
   * 
   *
   * getter for AUFGABE.DAUER_EINHEIT
   */
    @Override   public  de.ivu.elect.business.aufgabe.entity.AufgabenEinheitTyp getDauerEinheit() {
        return dauerEinheit;
      }

  /**
   * 
   *
   * setter for AUFGABE.DAUER_EINHEIT
   *
   * @param dauerEinheit
   */
  @Override   public void setDauerEinheit( de.ivu.elect.business.aufgabe.entity.AufgabenEinheitTyp dauerEinheit) {

       resetTkCache();
                  de.ivu.elect.business.aufgabe.entity.AufgabenEinheitTyp dauerEinheitInternal = dauerEinheit;
       
       
      boolean thisAttributChanged =
      !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.dauerEinheit
      , dauerEinheitInternal);

      attributeChanged |= thisAttributChanged;

      hasChangedDauerEinheit |= thisAttributChanged;

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


             if (!isSeitLadenVeraendertDauerEinheit) {
          isSeitLadenVeraendertDauerEinheit = thisAttributChanged;
         if (isSeitLadenVeraendertDauerEinheit){
           wertNachLadenDauerEinheit=this.dauerEinheit;
         }
       }
      

       this.dauerEinheit = dauerEinheitInternal;

         }

        
      @javax.persistence.Column(name = "ERSTELLER_KENNUNG", nullable = AufgabeConstants.ERSTELLER_KENNUNG_NULLABLE, length=AufgabeConstants.ERSTELLER_KENNUNG_MAX_LENGTH)
        
  protected java.lang.String erstellerKennung =  null;

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

  public boolean hasChangedErstellerKennung(){
    return hasChangedErstellerKennung;
  }
       @javax.persistence.Transient
     private transient boolean isSeitLadenVeraendertErstellerKennung = false;
     @javax.persistence.Transient
     private transient java.lang.String wertNachLadenErstellerKennung;
  
  /**
   * 
   *
   * getter for AUFGABE.ERSTELLER_KENNUNG
   */
    @Override   public  java.lang.String getErstellerKennung() {
        return erstellerKennung;
      }

  /**
   * 
   *
   * setter for AUFGABE.ERSTELLER_KENNUNG
   *
   * @param erstellerKennung
   */
  @Override   public void setErstellerKennung( java.lang.String erstellerKennung) {

       resetTkCache();
                  
                          java.lang.String erstellerKennungInternal = de.ivu.elect.jee.entity.EntityUtil.trimToNullOrMaxLength(erstellerKennung, AufgabeConstants.ERSTELLER_KENNUNG_MAX_LENGTH, getId(), getClass());
                  
       
      boolean thisAttributChanged =
      !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.erstellerKennung
      , erstellerKennungInternal);

      attributeChanged |= thisAttributChanged;

      hasChangedErstellerKennung |= thisAttributChanged;

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


             if (!isSeitLadenVeraendertErstellerKennung) {
          isSeitLadenVeraendertErstellerKennung = thisAttributChanged;
         if (isSeitLadenVeraendertErstellerKennung){
           wertNachLadenErstellerKennung=this.erstellerKennung;
         }
       }
      

       this.erstellerKennung = erstellerKennungInternal;

         }

        
    @javax.persistence.Enumerated(javax.persistence.EnumType.STRING)
      @javax.persistence.Column(name = "ERSTELLER_TYP", nullable = AufgabeConstants.ERSTELLER_TYP_NULLABLE)
    
  protected de.ivu.elect.business.aufgabe.entity.AufgabenErstellerTyp erstellerTyp =  null;

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

  public boolean hasChangedErstellerTyp(){
    return hasChangedErstellerTyp;
  }
       @javax.persistence.Transient
     private transient boolean isSeitLadenVeraendertErstellerTyp = false;
     @javax.persistence.Transient
     private transient de.ivu.elect.business.aufgabe.entity.AufgabenErstellerTyp wertNachLadenErstellerTyp;
  
  /**
   * 
   *
   * getter for AUFGABE.ERSTELLER_TYP
   */
    @Override   public  de.ivu.elect.business.aufgabe.entity.AufgabenErstellerTyp getErstellerTyp() {
        return erstellerTyp;
      }

  /**
   * 
   *
   * setter for AUFGABE.ERSTELLER_TYP
   *
   * @param erstellerTyp
   */
  @Override   public void setErstellerTyp( de.ivu.elect.business.aufgabe.entity.AufgabenErstellerTyp erstellerTyp) {

       resetTkCache();
                  de.ivu.elect.business.aufgabe.entity.AufgabenErstellerTyp erstellerTypInternal = erstellerTyp;
       
       
      boolean thisAttributChanged =
      !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.erstellerTyp
      , erstellerTypInternal);

      attributeChanged |= thisAttributChanged;

      hasChangedErstellerTyp |= thisAttributChanged;

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


             if (!isSeitLadenVeraendertErstellerTyp) {
          isSeitLadenVeraendertErstellerTyp = thisAttributChanged;
         if (isSeitLadenVeraendertErstellerTyp){
           wertNachLadenErstellerTyp=this.erstellerTyp;
         }
       }
      

       this.erstellerTyp = erstellerTypInternal;

         }

        
      @javax.persistence.Temporal(javax.persistence.TemporalType.TIMESTAMP)
  @javax.persistence.Column(name = "ERSTELLT_AM", nullable = AufgabeConstants.ERSTELLT_AM_NULLABLE, precision=AufgabeConstants.ERSTELLT_AM_PRECISION)
    
  protected java.util.Date erstelltAm =  null;

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

  public boolean hasChangedErstelltAm(){
    return hasChangedErstelltAm;
  }
       @javax.persistence.Transient
     private transient boolean isSeitLadenVeraendertErstelltAm = false;
     @javax.persistence.Transient
     private transient java.util.Date wertNachLadenErstelltAm;
  
  /**
   * 
   *
   * getter for AUFGABE.ERSTELLT_AM
   */
    @Override   public  java.util.Date getErstelltAm() {
              if (erstelltAm == null){
            return null;
          } else {
                          return erstelltAm;
          }
      }

  /**
   * 
   *
   * setter for AUFGABE.ERSTELLT_AM
   *
   * @param erstelltAm
   */
  @Override   public void setErstelltAm( java.util.Date erstelltAm) {

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

      attributeChanged |= thisAttributChanged;

      hasChangedErstelltAm |= thisAttributChanged;

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


             if (!isSeitLadenVeraendertErstelltAm) {
          isSeitLadenVeraendertErstelltAm = thisAttributChanged;
         if (isSeitLadenVeraendertErstelltAm){
           wertNachLadenErstelltAm=this.erstelltAm;
         }
       }
      

       this.erstelltAm = erstelltAmInternal;

         }

        
      @javax.persistence.Column(name = "FAELLIGKEIT_ANZAHL", nullable = AufgabeConstants.FAELLIGKEIT_ANZAHL_NULLABLE, precision=AufgabeConstants.FAELLIGKEIT_ANZAHL_PRECISION, scale=AufgabeConstants.FAELLIGKEIT_ANZAHL_SCALE)
            
  protected java.lang.Long faelligkeitAnzahl =  Long.valueOf("0");

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

  public boolean hasChangedFaelligkeitAnzahl(){
    return hasChangedFaelligkeitAnzahl;
  }
       @javax.persistence.Transient
     private transient boolean isSeitLadenVeraendertFaelligkeitAnzahl = false;
     @javax.persistence.Transient
     private transient java.lang.Long wertNachLadenFaelligkeitAnzahl;
  
  /**
   * 
   *
   * getter for AUFGABE.FAELLIGKEIT_ANZAHL
   */
    @Override   public  java.lang.Long getFaelligkeitAnzahl() {
        return faelligkeitAnzahl;
      }

  /**
   * 
   *
   * setter for AUFGABE.FAELLIGKEIT_ANZAHL
   *
   * @param faelligkeitAnzahl
   */
  @Override   public void setFaelligkeitAnzahl( java.lang.Long faelligkeitAnzahl) {

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

      attributeChanged |= thisAttributChanged;

      hasChangedFaelligkeitAnzahl |= thisAttributChanged;

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


             if (!isSeitLadenVeraendertFaelligkeitAnzahl) {
          isSeitLadenVeraendertFaelligkeitAnzahl = thisAttributChanged;
         if (isSeitLadenVeraendertFaelligkeitAnzahl){
           wertNachLadenFaelligkeitAnzahl=this.faelligkeitAnzahl;
         }
       }
      

       this.faelligkeitAnzahl = faelligkeitAnzahlInternal;

         }

        
    @javax.persistence.Enumerated(javax.persistence.EnumType.STRING)
      @javax.persistence.Column(name = "FAELLIGKEIT_EINHEIT", nullable = AufgabeConstants.FAELLIGKEIT_EINHEIT_NULLABLE)
    
  protected de.ivu.elect.business.aufgabe.entity.AufgabenEinheitTyp faelligkeitEinheit =  de.ivu.elect.business.aufgabe.entity.AufgabenEinheitTyp.OHNE;

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

  public boolean hasChangedFaelligkeitEinheit(){
    return hasChangedFaelligkeitEinheit;
  }
       @javax.persistence.Transient
     private transient boolean isSeitLadenVeraendertFaelligkeitEinheit = false;
     @javax.persistence.Transient
     private transient de.ivu.elect.business.aufgabe.entity.AufgabenEinheitTyp wertNachLadenFaelligkeitEinheit;
  
  /**
   * 
   *
   * getter for AUFGABE.FAELLIGKEIT_EINHEIT
   */
    @Override   public  de.ivu.elect.business.aufgabe.entity.AufgabenEinheitTyp getFaelligkeitEinheit() {
        return faelligkeitEinheit;
      }

  /**
   * 
   *
   * setter for AUFGABE.FAELLIGKEIT_EINHEIT
   *
   * @param faelligkeitEinheit
   */
  @Override   public void setFaelligkeitEinheit( de.ivu.elect.business.aufgabe.entity.AufgabenEinheitTyp faelligkeitEinheit) {

       resetTkCache();
                  de.ivu.elect.business.aufgabe.entity.AufgabenEinheitTyp faelligkeitEinheitInternal = faelligkeitEinheit;
       
       
      boolean thisAttributChanged =
      !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.faelligkeitEinheit
      , faelligkeitEinheitInternal);

      attributeChanged |= thisAttributChanged;

      hasChangedFaelligkeitEinheit |= thisAttributChanged;

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


             if (!isSeitLadenVeraendertFaelligkeitEinheit) {
          isSeitLadenVeraendertFaelligkeitEinheit = thisAttributChanged;
         if (isSeitLadenVeraendertFaelligkeitEinheit){
           wertNachLadenFaelligkeitEinheit=this.faelligkeitEinheit;
         }
       }
      

       this.faelligkeitEinheit = faelligkeitEinheitInternal;

         }

        
  @javax.persistence.Temporal(javax.persistence.TemporalType.TIMESTAMP)
  @javax.persistence.Column(name = "FAELLIGKEIT_ZEITPUNKT", nullable = AufgabeConstants.FAELLIGKEIT_ZEITPUNKT_NULLABLE, precision=AufgabeConstants.FAELLIGKEIT_ZEITPUNKT_PRECISION)
    
  protected java.util.Date faelligkeitZeitpunkt =  null;

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

  public boolean hasChangedFaelligkeitZeitpunkt(){
    return hasChangedFaelligkeitZeitpunkt;
  }
       @javax.persistence.Transient
     private transient boolean isSeitLadenVeraendertFaelligkeitZeitpunkt = false;
     @javax.persistence.Transient
     private transient java.util.Date wertNachLadenFaelligkeitZeitpunkt;
  
  /**
   * 
   *
   * getter for AUFGABE.FAELLIGKEIT_ZEITPUNKT
   */
  @javax.annotation.Nullable   @Override   public  java.util.Date getFaelligkeitZeitpunkt() {
              if (faelligkeitZeitpunkt == null){
            return null;
          } else {
                          return faelligkeitZeitpunkt;
          }
      }

  /**
   * 
   *
   * setter for AUFGABE.FAELLIGKEIT_ZEITPUNKT
   *
   * @param faelligkeitZeitpunkt
   */
  @Override   public void setFaelligkeitZeitpunkt(@javax.annotation.Nullable  java.util.Date faelligkeitZeitpunkt) {

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

      attributeChanged |= thisAttributChanged;

      hasChangedFaelligkeitZeitpunkt |= thisAttributChanged;

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


             if (!isSeitLadenVeraendertFaelligkeitZeitpunkt) {
          isSeitLadenVeraendertFaelligkeitZeitpunkt = thisAttributChanged;
         if (isSeitLadenVeraendertFaelligkeitZeitpunkt){
           wertNachLadenFaelligkeitZeitpunkt=this.faelligkeitZeitpunkt;
         }
       }
      

       this.faelligkeitZeitpunkt = faelligkeitZeitpunktInternal;

         }

        
  @javax.persistence.Column(name = "KATEGORIE", nullable = AufgabeConstants.KATEGORIE_NULLABLE, length=AufgabeConstants.KATEGORIE_MAX_LENGTH)
        
  protected java.lang.String kategorie =  null;

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

  public boolean hasChangedKategorie(){
    return hasChangedKategorie;
  }
       @javax.persistence.Transient
     private transient boolean isSeitLadenVeraendertKategorie = false;
     @javax.persistence.Transient
     private transient java.lang.String wertNachLadenKategorie;
  
  /**
   * 
   *
   * getter for AUFGABE.KATEGORIE
   */
  @javax.annotation.Nullable   @Override   public  java.lang.String getKategorie() {
        return kategorie;
      }

  /**
   * 
   *
   * setter for AUFGABE.KATEGORIE
   *
   * @param kategorie
   */
  @Override   public void setKategorie(@javax.annotation.Nullable  java.lang.String kategorie) {

       resetTkCache();
                  
                          java.lang.String kategorieInternal = de.ivu.elect.jee.entity.EntityUtil.trimToNullOrMaxLength(kategorie, AufgabeConstants.KATEGORIE_MAX_LENGTH, getId(), getClass());
                  
       
      boolean thisAttributChanged =
      !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.kategorie
      , kategorieInternal);

      attributeChanged |= thisAttributChanged;

      hasChangedKategorie |= thisAttributChanged;

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


             if (!isSeitLadenVeraendertKategorie) {
          isSeitLadenVeraendertKategorie = thisAttributChanged;
         if (isSeitLadenVeraendertKategorie){
           wertNachLadenKategorie=this.kategorie;
         }
       }
      

       this.kategorie = kategorieInternal;

         }

        
  @javax.persistence.Column(name = "LOESUNG", nullable = AufgabeConstants.LOESUNG_NULLABLE, length=AufgabeConstants.LOESUNG_MAX_LENGTH)
        
  protected java.lang.String loesung =  null;

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

  public boolean hasChangedLoesung(){
    return hasChangedLoesung;
  }
       @javax.persistence.Transient
     private transient boolean isSeitLadenVeraendertLoesung = false;
     @javax.persistence.Transient
     private transient java.lang.String wertNachLadenLoesung;
  
  /**
   * 
   *
   * getter for AUFGABE.LOESUNG
   */
  @javax.annotation.Nullable   @Override   public  java.lang.String getLoesung() {
        return loesung;
      }

  /**
   * 
   *
   * setter for AUFGABE.LOESUNG
   *
   * @param loesung
   */
  @Override   public void setLoesung(@javax.annotation.Nullable  java.lang.String loesung) {

       resetTkCache();
                  
                          java.lang.String loesungInternal = de.ivu.elect.jee.entity.EntityUtil.trimToNullOrMaxLength(loesung, AufgabeConstants.LOESUNG_MAX_LENGTH, getId(), getClass());
                  
       
      boolean thisAttributChanged =
      !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.loesung
      , loesungInternal);

      attributeChanged |= thisAttributChanged;

      hasChangedLoesung |= thisAttributChanged;

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


             if (!isSeitLadenVeraendertLoesung) {
          isSeitLadenVeraendertLoesung = thisAttributChanged;
         if (isSeitLadenVeraendertLoesung){
           wertNachLadenLoesung=this.loesung;
         }
       }
      

       this.loesung = loesungInternal;

         }

        
      @javax.persistence.Column(name = "NUMMER", nullable = AufgabeConstants.NUMMER_NULLABLE, precision=AufgabeConstants.NUMMER_PRECISION, scale=AufgabeConstants.NUMMER_SCALE)
            
  protected java.lang.Long nummer =  null;

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

  public boolean hasChangedNummer(){
    return hasChangedNummer;
  }
       @javax.persistence.Transient
     private transient boolean isSeitLadenVeraendertNummer = false;
     @javax.persistence.Transient
     private transient java.lang.Long wertNachLadenNummer;
  
  /**
   * 
   *
   * getter for AUFGABE.NUMMER
   */
    @Override   public  java.lang.Long getNummer() {
        return nummer;
      }

  /**
   * 
   *
   * setter for AUFGABE.NUMMER
   *
   * @param nummer
   */
  @Override   public void setNummer( java.lang.Long nummer) {

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

      attributeChanged |= thisAttributChanged;

      hasChangedNummer |= thisAttributChanged;

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


             if (!isSeitLadenVeraendertNummer) {
          isSeitLadenVeraendertNummer = thisAttributChanged;
         if (isSeitLadenVeraendertNummer){
           wertNachLadenNummer=this.nummer;
         }
       }
      

       this.nummer = nummerInternal;

         }

        
    @javax.persistence.Enumerated(javax.persistence.EnumType.STRING)
      @javax.persistence.Column(name = "PRIORITAET", nullable = AufgabeConstants.PRIORITAET_NULLABLE)
    
  protected de.ivu.elect.business.aufgabe.entity.AufgabenPrioritaet prioritaet =  de.ivu.elect.business.aufgabe.entity.AufgabenPrioritaet.OHNE;

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

  public boolean hasChangedPrioritaet(){
    return hasChangedPrioritaet;
  }
       @javax.persistence.Transient
     private transient boolean isSeitLadenVeraendertPrioritaet = false;
     @javax.persistence.Transient
     private transient de.ivu.elect.business.aufgabe.entity.AufgabenPrioritaet wertNachLadenPrioritaet;
  
  /**
   * 
   *
   * getter for AUFGABE.PRIORITAET
   */
    @Override   public  de.ivu.elect.business.aufgabe.entity.AufgabenPrioritaet getPrioritaet() {
        return prioritaet;
      }

  /**
   * 
   *
   * setter for AUFGABE.PRIORITAET
   *
   * @param prioritaet
   */
  @Override   public void setPrioritaet( de.ivu.elect.business.aufgabe.entity.AufgabenPrioritaet prioritaet) {

       resetTkCache();
                  de.ivu.elect.business.aufgabe.entity.AufgabenPrioritaet prioritaetInternal = prioritaet;
       
       
      boolean thisAttributChanged =
      !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.prioritaet
      , prioritaetInternal);

      attributeChanged |= thisAttributChanged;

      hasChangedPrioritaet |= thisAttributChanged;

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


             if (!isSeitLadenVeraendertPrioritaet) {
          isSeitLadenVeraendertPrioritaet = thisAttributChanged;
         if (isSeitLadenVeraendertPrioritaet){
           wertNachLadenPrioritaet=this.prioritaet;
         }
       }
      

       this.prioritaet = prioritaetInternal;

         }

        
  @javax.persistence.Column(name = "RECHTSGRUNDLAGE", nullable = AufgabeConstants.RECHTSGRUNDLAGE_NULLABLE, length=AufgabeConstants.RECHTSGRUNDLAGE_MAX_LENGTH)
        
  protected java.lang.String rechtsgrundlage =  null;

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

  public boolean hasChangedRechtsgrundlage(){
    return hasChangedRechtsgrundlage;
  }
  
  /**
   * 
   *
   * getter for AUFGABE.RECHTSGRUNDLAGE
   */
  @javax.annotation.Nullable   @Override   public  java.lang.String getRechtsgrundlage() {
        return rechtsgrundlage;
      }

  /**
   * 
   *
   * setter for AUFGABE.RECHTSGRUNDLAGE
   *
   * @param rechtsgrundlage
   */
  @Override   public void setRechtsgrundlage(@javax.annotation.Nullable  java.lang.String rechtsgrundlage) {

       resetTkCache();
                  
                          java.lang.String rechtsgrundlageInternal = de.ivu.elect.jee.entity.EntityUtil.trimToNullOrMaxLength(rechtsgrundlage, AufgabeConstants.RECHTSGRUNDLAGE_MAX_LENGTH, getId(), getClass());
                  
       
      boolean thisAttributChanged =
      !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.rechtsgrundlage
      , rechtsgrundlageInternal);

      attributeChanged |= thisAttributChanged;

      hasChangedRechtsgrundlage |= thisAttributChanged;

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


      

       this.rechtsgrundlage = rechtsgrundlageInternal;

         }

        
    @javax.persistence.Enumerated(javax.persistence.EnumType.STRING)
      @javax.persistence.Column(name = "STATUS", nullable = AufgabeConstants.STATUS_NULLABLE)
    
  protected de.ivu.elect.business.aufgabe.entity.AufgabenStatus status =  null;

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

  public boolean hasChangedStatus(){
    return hasChangedStatus;
  }
       @javax.persistence.Transient
     private transient boolean isSeitLadenVeraendertStatus = false;
     @javax.persistence.Transient
     private transient de.ivu.elect.business.aufgabe.entity.AufgabenStatus wertNachLadenStatus;
  
  /**
   * 
   *
   * getter for AUFGABE.STATUS
   */
    @Override   public  de.ivu.elect.business.aufgabe.entity.AufgabenStatus getStatus() {
        return status;
      }

  /**
   * 
   *
   * setter for AUFGABE.STATUS
   *
   * @param status
   */
  @Override   public void setStatus( de.ivu.elect.business.aufgabe.entity.AufgabenStatus status) {

       resetTkCache();
                  de.ivu.elect.business.aufgabe.entity.AufgabenStatus statusInternal = status;
       
       
      boolean thisAttributChanged =
      !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.status
      , statusInternal);

      attributeChanged |= thisAttributChanged;

      hasChangedStatus |= thisAttributChanged;

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


             if (!isSeitLadenVeraendertStatus) {
          isSeitLadenVeraendertStatus = thisAttributChanged;
         if (isSeitLadenVeraendertStatus){
           wertNachLadenStatus=this.status;
         }
       }
      

       this.status = statusInternal;

         }

        
      @javax.persistence.Column(name = "TITEL", nullable = AufgabeConstants.TITEL_NULLABLE, length=AufgabeConstants.TITEL_MAX_LENGTH)
        
  protected java.lang.String titel =  null;

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

  public boolean hasChangedTitel(){
    return hasChangedTitel;
  }
       @javax.persistence.Transient
     private transient boolean isSeitLadenVeraendertTitel = false;
     @javax.persistence.Transient
     private transient java.lang.String wertNachLadenTitel;
  
  /**
   * 
   *
   * getter for AUFGABE.TITEL
   */
    @Override   public  java.lang.String getTitel() {
        return titel;
      }

  /**
   * 
   *
   * setter for AUFGABE.TITEL
   *
   * @param titel
   */
  @Override   public void setTitel( java.lang.String titel) {

       resetTkCache();
                  
                          java.lang.String titelInternal = de.ivu.elect.jee.entity.EntityUtil.trimToNullOrMaxLength(titel, AufgabeConstants.TITEL_MAX_LENGTH, getId(), getClass());
                  
       
      boolean thisAttributChanged =
      !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.titel
      , titelInternal);

      attributeChanged |= thisAttributChanged;

      hasChangedTitel |= thisAttributChanged;

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


             if (!isSeitLadenVeraendertTitel) {
          isSeitLadenVeraendertTitel = thisAttributChanged;
         if (isSeitLadenVeraendertTitel){
           wertNachLadenTitel=this.titel;
         }
       }
      

       this.titel = titelInternal;

         }

        
  @javax.persistence.Column(name = "VERANTWORTLICH", nullable = AufgabeConstants.VERANTWORTLICH_NULLABLE, length=AufgabeConstants.VERANTWORTLICH_MAX_LENGTH)
        
  protected java.lang.String verantwortlich =  null;

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

  public boolean hasChangedVerantwortlich(){
    return hasChangedVerantwortlich;
  }
  
  /**
   * 
   *
   * getter for AUFGABE.VERANTWORTLICH
   */
  @javax.annotation.Nullable   @Override   public  java.lang.String getVerantwortlich() {
        return verantwortlich;
      }

  /**
   * 
   *
   * setter for AUFGABE.VERANTWORTLICH
   *
   * @param verantwortlich
   */
  @Override   public void setVerantwortlich(@javax.annotation.Nullable  java.lang.String verantwortlich) {

       resetTkCache();
                  
                          java.lang.String verantwortlichInternal = de.ivu.elect.jee.entity.EntityUtil.trimToNullOrMaxLength(verantwortlich, AufgabeConstants.VERANTWORTLICH_MAX_LENGTH, getId(), getClass());
                  
       
      boolean thisAttributChanged =
      !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.verantwortlich
      , verantwortlichInternal);

      attributeChanged |= thisAttributChanged;

      hasChangedVerantwortlich |= thisAttributChanged;

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


      

       this.verantwortlich = verantwortlichInternal;

         }

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

  /**
   * 
   */
  @Override
  public void setBearbeitet(@javax.annotation.Nullable  de.ivu.elect.business.benutzerverwaltung.entity.Rolle bearbeitet){
    resetTkCache();
    
    boolean thisAttributChanged =
    !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.bearbeitet
    , bearbeitet);

    attributeChanged |= thisAttributChanged;

    hasChangedBearbeitet |= thisAttributChanged;

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

    this.bearbeitet = bearbeitet;
      }

  /**
   * 
   */
  @javax.annotation.Nullable   @Override
  public de.ivu.elect.business.benutzerverwaltung.entity.Rolle getBearbeitet(){
    return this.bearbeitet;
  }

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

  public boolean hasChangedBearbeitet(){
    return hasChangedBearbeitet;
  }

  /**
   * Beziehung (unidirektional) zu Sichtbar
   */
  @javax.persistence.ManyToOne(fetch =  javax.persistence.FetchType.LAZY , optional=true, cascade = {javax.persistence.CascadeType.PERSIST})
  @javax.persistence.JoinColumns(@javax.persistence.JoinColumn(name = "SICHTBAR_ID", referencedColumnName="ROLLE_ID"))
  protected de.ivu.elect.business.benutzerverwaltung.entity.Rolle sichtbar;

  /**
   * 
   */
  @Override
  public void setSichtbar(@javax.annotation.Nullable  de.ivu.elect.business.benutzerverwaltung.entity.Rolle sichtbar){
    resetTkCache();
    
    boolean thisAttributChanged =
    !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.sichtbar
    , sichtbar);

    attributeChanged |= thisAttributChanged;

    hasChangedSichtbar |= thisAttributChanged;

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

    this.sichtbar = sichtbar;
      }

  /**
   * 
   */
  @javax.annotation.Nullable   @Override
  public de.ivu.elect.business.benutzerverwaltung.entity.Rolle getSichtbar(){
    return this.sichtbar;
  }

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

  public boolean hasChangedSichtbar(){
    return hasChangedSichtbar;
  }

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

  /**
   * 
   */
  @Override
  public void setWahltermin( de.ivu.elect.business.wahl.entity.Wahltermin wahltermin){
    resetTkCache();
    
    boolean thisAttributChanged =
    !de.ivu.elect.jee.entity.EntityUtil.compareObjects(this.wahltermin
    , wahltermin);

    attributeChanged |= thisAttributChanged;

    hasChangedWahltermin |= thisAttributChanged;

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

    this.wahltermin = wahltermin;
      }

  /**
   * 
   */
    @Override
  public de.ivu.elect.business.wahl.entity.Wahltermin getWahltermin(){
    return this.wahltermin;
  }

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

  public boolean hasChangedWahltermin(){
    return hasChangedWahltermin;
  }

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

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

    attributeChanged |= thisAttributChanged;

    hasChangedWahl |= thisAttributChanged;

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

    this.wahl = wahl;
      }

  /**
   * 
   */
  @javax.annotation.Nullable   @Override
  public de.ivu.elect.business.wahl.entity.Wahl getWahl(){
    return this.wahl;
  }

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

  public boolean hasChangedWahl(){
    return hasChangedWahl;
  }


/**
 * Beziehungen N:1 bidirektional
 */

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

  /**
   * Beziehungen 1:N bidirektional
   */

  /**
   * Beziehung 1:N (bidirektional) zu AufgabeKommentarsByAufgabe
   *
   */
  @javax.persistence.OneToMany(targetEntity=de.ivu.elect.business.aufgabe.entity.AufgabeKommentar.class, mappedBy="aufgabe", 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.aufgabe.entity.AufgabeKommentar> aufgabeKommentarsByAufgabe;


  /**
   * 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.aufgabe.entity.AufgabeKommentar> getAufgabeKommentarsByAufgabe(){
    if (aufgabeKommentarsByAufgabe == null){
      return  java.util.Collections.<de.ivu.elect.business.aufgabe.entity.AufgabeKommentar>unmodifiableSet(java.util.Collections.<de.ivu.elect.business.aufgabe.entity.AufgabeKommentar>emptySet());
    }

    return java.util.Collections.<de.ivu.elect.business.aufgabe.entity.AufgabeKommentar>unmodifiableSet(this.aufgabeKommentarsByAufgabe);
  }

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

  public boolean hasChangedAufgabeKommentarsByAufgabe() {
    return hasChangedAufgabeKommentarsByAufgabe;
  }

  /**
   * Hinzufuegen von de.ivu.elect.business.aufgabe.entity.AufgabeKommentar
   */
  @Override
  public void addAufgabeKommentarByAufgabe(de.ivu.elect.business.aufgabe.entity.AufgabeKommentar aufgabeKommentarByAufgabe){
    try {
      if (!updateRelationship){
        updateRelationship = true;

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

          boolean isChanged = this.aufgabeKommentarsByAufgabe.add(aufgabeKommentarByAufgabe);

          if(!hasChangedAufgabeKommentarsByAufgabe) {
            hasChangedAufgabeKommentarsByAufgabe =  isChanged;
          }

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

  /**
   * Entfernen von de.ivu.elect.business.aufgabe.entity.AufgabeKommentar
   */
  @Override
  public void removeAufgabeKommentarByAufgabe(de.ivu.elect.business.aufgabe.entity.AufgabeKommentar aufgabeKommentarByAufgabe){
    try {
      if (!updateRelationship){
        updateRelationship = true;

        if (aufgabeKommentarByAufgabe != null){
          if (this.aufgabeKommentarsByAufgabe != null) {
            boolean isChanged = this.aufgabeKommentarsByAufgabe.remove(aufgabeKommentarByAufgabe);

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

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

 /**
  * Entfernen von allen de.ivu.elect.business.aufgabe.entity.AufgabeKommentar
  */
   @Override
   public void removeAllAufgabeKommentarByAufgabes(){
     java.util.Set<de.ivu.elect.business.aufgabe.entity.AufgabeKommentar> toRemove = new java.util.HashSet<>(getAufgabeKommentarsByAufgabe());

     for (   de.ivu.elect.business.aufgabe.entity.AufgabeKommentar entity:toRemove){
       removeAufgabeKommentarByAufgabe(entity);
     }
   }

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


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

  @Override
  public String toString() {
    StringBuilder sb = new StringBuilder();
    sb.append("Aufgabe:");
    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(Aufgabe other){
                             other.aufgabentyp = this.aufgabentyp;
                                other.bearbeiterKennung = this.bearbeiterKennung;
                                other.beschreibung = this.beschreibung;
                                other.dauerAnzahl = this.dauerAnzahl;
                                other.dauerEinheit = this.dauerEinheit;
                                other.erstellerKennung = this.erstellerKennung;
                                other.erstellerTyp = this.erstellerTyp;
                                other.erstelltAm = this.erstelltAm;
                                other.faelligkeitAnzahl = this.faelligkeitAnzahl;
                                other.faelligkeitEinheit = this.faelligkeitEinheit;
                                other.faelligkeitZeitpunkt = this.faelligkeitZeitpunkt;
                                other.kategorie = this.kategorie;
                                other.loesung = this.loesung;
                                other.nummer = this.nummer;
                                other.prioritaet = this.prioritaet;
                                other.rechtsgrundlage = this.rechtsgrundlage;
                                other.status = this.status;
                                other.titel = this.titel;
                                other.verantwortlich = this.verantwortlich;
           
  other.setBearbeitet(this.getBearbeitet());
  other.setSichtbar(this.getSichtbar());
  other.setWahltermin(this.getWahltermin());
  other.setWahl(this.getWahl());
    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(Aufgabe.class)){
        copyEntityAttributesUsingSetter((Aufgabe) other.castTo(Aufgabe.class).getEntity());
      } else {
        throw new IllegalArgumentException("Keine Instanz von Aufgabe: " + other);
      }
    }

  /**
  * Kopiert alle Attribute (ausser PK und Version)  in uebergebene Entitaet.
  *
  */
  public void copyEntityAttributesUsingSetter(Aufgabe other){
               other.setAufgabentyp(this.aufgabentyp);
                  other.setBearbeiterKennung(this.bearbeiterKennung);
                  other.setBeschreibung(this.beschreibung);
                  other.setDauerAnzahl(this.dauerAnzahl);
                  other.setDauerEinheit(this.dauerEinheit);
                  other.setErstellerKennung(this.erstellerKennung);
                  other.setErstellerTyp(this.erstellerTyp);
                  other.setErstelltAm(this.erstelltAm);
                  other.setFaelligkeitAnzahl(this.faelligkeitAnzahl);
                  other.setFaelligkeitEinheit(this.faelligkeitEinheit);
                  other.setFaelligkeitZeitpunkt(this.faelligkeitZeitpunkt);
                  other.setKategorie(this.kategorie);
                  other.setLoesung(this.loesung);
                  other.setNummer(this.nummer);
                  other.setPrioritaet(this.prioritaet);
                  other.setRechtsgrundlage(this.rechtsgrundlage);
                  other.setStatus(this.status);
                  other.setTitel(this.titel);
                  other.setVerantwortlich(this.verantwortlich);
           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(Aufgabe other){
                       if (hasChangedAufgabentyp) {
        other.setAufgabentyp(this.aufgabentyp);
      }
                             if (hasChangedBearbeiterKennung) {
        other.setBearbeiterKennung(this.bearbeiterKennung);
      }
                             if (hasChangedBeschreibung) {
        other.setBeschreibung(this.beschreibung);
      }
                             if (hasChangedDauerAnzahl) {
        other.setDauerAnzahl(this.dauerAnzahl);
      }
                             if (hasChangedDauerEinheit) {
        other.setDauerEinheit(this.dauerEinheit);
      }
                             if (hasChangedErstellerKennung) {
        other.setErstellerKennung(this.erstellerKennung);
      }
                             if (hasChangedErstellerTyp) {
        other.setErstellerTyp(this.erstellerTyp);
      }
                             if (hasChangedErstelltAm) {
        other.setErstelltAm(this.erstelltAm);
      }
                             if (hasChangedFaelligkeitAnzahl) {
        other.setFaelligkeitAnzahl(this.faelligkeitAnzahl);
      }
                             if (hasChangedFaelligkeitEinheit) {
        other.setFaelligkeitEinheit(this.faelligkeitEinheit);
      }
                             if (hasChangedFaelligkeitZeitpunkt) {
        other.setFaelligkeitZeitpunkt(this.faelligkeitZeitpunkt);
      }
                             if (hasChangedKategorie) {
        other.setKategorie(this.kategorie);
      }
                             if (hasChangedLoesung) {
        other.setLoesung(this.loesung);
      }
                             if (hasChangedNummer) {
        other.setNummer(this.nummer);
      }
                             if (hasChangedPrioritaet) {
        other.setPrioritaet(this.prioritaet);
      }
                             if (hasChangedRechtsgrundlage) {
        other.setRechtsgrundlage(this.rechtsgrundlage);
      }
                             if (hasChangedStatus) {
        other.setStatus(this.status);
      }
                             if (hasChangedTitel) {
        other.setTitel(this.titel);
      }
                             if (hasChangedVerantwortlich) {
        other.setVerantwortlich(this.verantwortlich);
      }
             }





    @javax.persistence.Transient
    private transient AufgabeTK tkCache;

    protected void resetTkCache() {
        tkCache = null;
    }

    public AufgabeTK getAufgabeTK(){
    if (tkCache==null) {
    tkCache = new AufgabeTK(

getNummer()


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

  @Override
  public AufgabeUK getUk(){
    return getAufgabeUK();
  }

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

public AufgabeUK getAufgabeUK(){

   return  new AufgabeUK(

getNummer()
,     getWahl()==null?null:getWahl().getWahlUK()
,     getWahltermin()==null?null:getWahltermin().getWahlterminUK()


  );
}

  @javax.persistence.Transient
  private transient AufgabeProperties properties;

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

  /**
   * @deprecated getProperties() verwenden.
   */
  @Deprecated
  public AufgabeProperties getAufgabeProperties(){
    return getProperties();
  }

  @Override
  public String getEntityTechnicalName() {
    return AufgabeConstants.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(AufgabeConstants.MESSAGE_KEY_AUFGABENTYP_EINZAHL)){
        de.ivu.elect.jee.protokollierung.AttributWertVorher vorher = werteVorher.get(AufgabeConstants.MESSAGE_KEY_AUFGABENTYP_EINZAHL);

        aufgabentyp =
     (de.ivu.elect.business.aufgabe.entity.Aufgabentyp) vorher.getAttributTyp().getValueAsEnum(vorher.getWertVorher());
          }

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

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

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

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

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

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

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

        dauerEinheit =
     (de.ivu.elect.business.aufgabe.entity.AufgabenEinheitTyp) vorher.getAttributTyp().getValueAsEnum(vorher.getWertVorher());
          }

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

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

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

        erstellerTyp =
     (de.ivu.elect.business.aufgabe.entity.AufgabenErstellerTyp) vorher.getAttributTyp().getValueAsEnum(vorher.getWertVorher());
          }

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

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

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

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

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

        faelligkeitEinheit =
     (de.ivu.elect.business.aufgabe.entity.AufgabenEinheitTyp) vorher.getAttributTyp().getValueAsEnum(vorher.getWertVorher());
          }

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

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

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

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

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

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

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

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

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

        prioritaet =
     (de.ivu.elect.business.aufgabe.entity.AufgabenPrioritaet) vorher.getAttributTyp().getValueAsEnum(vorher.getWertVorher());
          }

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

        status =
     (de.ivu.elect.business.aufgabe.entity.AufgabenStatus) vorher.getAttributTyp().getValueAsEnum(vorher.getWertVorher());
          }

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

        titel =
     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 (isSeitLadenVeraendertAufgabentyp) {
      result.put(AufgabeConstants.MESSAGE_KEY_AUFGABENTYP_EINZAHL, new de.ivu.elect.jee.protokollierung.VorherNachherWert(
         de.ivu.elect.jee.protokollierung.AttributTyp.ENUM
                , wertNachLadenAufgabentyp , aufgabentyp));
    }
                            if (isSeitLadenVeraendertBearbeiterKennung) {
      result.put(AufgabeConstants.MESSAGE_KEY_BEARBEITER_KENNUNG_EINZAHL, new de.ivu.elect.jee.protokollierung.VorherNachherWert(
         de.ivu.elect.jee.protokollierung.AttributTyp.STRING
                , wertNachLadenBearbeiterKennung , bearbeiterKennung));
    }
                            if (isSeitLadenVeraendertBeschreibung) {
      result.put(AufgabeConstants.MESSAGE_KEY_BESCHREIBUNG_EINZAHL, new de.ivu.elect.jee.protokollierung.VorherNachherWert(
         de.ivu.elect.jee.protokollierung.AttributTyp.STRING
                , wertNachLadenBeschreibung , beschreibung));
    }
                            if (isSeitLadenVeraendertDauerAnzahl) {
      result.put(AufgabeConstants.MESSAGE_KEY_DAUER_ANZAHL_EINZAHL, new de.ivu.elect.jee.protokollierung.VorherNachherWert(
                                    de.ivu.elect.jee.protokollierung.AttributTyp.LONG
                            , wertNachLadenDauerAnzahl , dauerAnzahl));
    }
                            if (isSeitLadenVeraendertDauerEinheit) {
      result.put(AufgabeConstants.MESSAGE_KEY_DAUER_EINHEIT_EINZAHL, new de.ivu.elect.jee.protokollierung.VorherNachherWert(
         de.ivu.elect.jee.protokollierung.AttributTyp.ENUM
                , wertNachLadenDauerEinheit , dauerEinheit));
    }
                            if (isSeitLadenVeraendertErstellerKennung) {
      result.put(AufgabeConstants.MESSAGE_KEY_ERSTELLER_KENNUNG_EINZAHL, new de.ivu.elect.jee.protokollierung.VorherNachherWert(
         de.ivu.elect.jee.protokollierung.AttributTyp.STRING
                , wertNachLadenErstellerKennung , erstellerKennung));
    }
                            if (isSeitLadenVeraendertErstellerTyp) {
      result.put(AufgabeConstants.MESSAGE_KEY_ERSTELLER_TYP_EINZAHL, new de.ivu.elect.jee.protokollierung.VorherNachherWert(
         de.ivu.elect.jee.protokollierung.AttributTyp.ENUM
                , wertNachLadenErstellerTyp , erstellerTyp));
    }
                            if (isSeitLadenVeraendertErstelltAm) {
      result.put(AufgabeConstants.MESSAGE_KEY_ERSTELLT_AM_EINZAHL, new de.ivu.elect.jee.protokollierung.VorherNachherWert(
         de.ivu.elect.jee.protokollierung.AttributTyp.TIMESTAMP
                , wertNachLadenErstelltAm , erstelltAm));
    }
                            if (isSeitLadenVeraendertFaelligkeitAnzahl) {
      result.put(AufgabeConstants.MESSAGE_KEY_FAELLIGKEIT_ANZAHL_EINZAHL, new de.ivu.elect.jee.protokollierung.VorherNachherWert(
                                    de.ivu.elect.jee.protokollierung.AttributTyp.LONG
                            , wertNachLadenFaelligkeitAnzahl , faelligkeitAnzahl));
    }
                            if (isSeitLadenVeraendertFaelligkeitEinheit) {
      result.put(AufgabeConstants.MESSAGE_KEY_FAELLIGKEIT_EINHEIT_EINZAHL, new de.ivu.elect.jee.protokollierung.VorherNachherWert(
         de.ivu.elect.jee.protokollierung.AttributTyp.ENUM
                , wertNachLadenFaelligkeitEinheit , faelligkeitEinheit));
    }
                            if (isSeitLadenVeraendertFaelligkeitZeitpunkt) {
      result.put(AufgabeConstants.MESSAGE_KEY_FAELLIGKEIT_ZEITPUNKT_EINZAHL, new de.ivu.elect.jee.protokollierung.VorherNachherWert(
         de.ivu.elect.jee.protokollierung.AttributTyp.TIMESTAMP
                , wertNachLadenFaelligkeitZeitpunkt , faelligkeitZeitpunkt));
    }
                            if (isSeitLadenVeraendertKategorie) {
      result.put(AufgabeConstants.MESSAGE_KEY_KATEGORIE_EINZAHL, new de.ivu.elect.jee.protokollierung.VorherNachherWert(
         de.ivu.elect.jee.protokollierung.AttributTyp.STRING
                , wertNachLadenKategorie , kategorie));
    }
                            if (isSeitLadenVeraendertLoesung) {
      result.put(AufgabeConstants.MESSAGE_KEY_LOESUNG_EINZAHL, new de.ivu.elect.jee.protokollierung.VorherNachherWert(
         de.ivu.elect.jee.protokollierung.AttributTyp.STRING
                , wertNachLadenLoesung , loesung));
    }
                            if (isSeitLadenVeraendertNummer) {
      result.put(AufgabeConstants.MESSAGE_KEY_NUMMER_EINZAHL, new de.ivu.elect.jee.protokollierung.VorherNachherWert(
                                    de.ivu.elect.jee.protokollierung.AttributTyp.LONG
                            , wertNachLadenNummer , nummer));
    }
                            if (isSeitLadenVeraendertPrioritaet) {
      result.put(AufgabeConstants.MESSAGE_KEY_PRIORITAET_EINZAHL, new de.ivu.elect.jee.protokollierung.VorherNachherWert(
         de.ivu.elect.jee.protokollierung.AttributTyp.ENUM
                , wertNachLadenPrioritaet , prioritaet));
    }
                                                if (isSeitLadenVeraendertStatus) {
      result.put(AufgabeConstants.MESSAGE_KEY_STATUS_EINZAHL, new de.ivu.elect.jee.protokollierung.VorherNachherWert(
         de.ivu.elect.jee.protokollierung.AttributTyp.ENUM
                , wertNachLadenStatus , status));
    }
                            if (isSeitLadenVeraendertTitel) {
      result.put(AufgabeConstants.MESSAGE_KEY_TITEL_EINZAHL, new de.ivu.elect.jee.protokollierung.VorherNachherWert(
         de.ivu.elect.jee.protokollierung.AttributTyp.STRING
                , wertNachLadenTitel , titel));
    }
                                    return result;
  }

  @Override
  public void resetProtokollierteAttribute() {
                      isSeitLadenVeraendertAufgabentyp = false;
      wertNachLadenAufgabentyp = null;
                          isSeitLadenVeraendertBearbeiterKennung = false;
      wertNachLadenBearbeiterKennung = null;
                          isSeitLadenVeraendertBeschreibung = false;
      wertNachLadenBeschreibung = null;
                          isSeitLadenVeraendertDauerAnzahl = false;
      wertNachLadenDauerAnzahl = null;
                          isSeitLadenVeraendertDauerEinheit = false;
      wertNachLadenDauerEinheit = null;
                          isSeitLadenVeraendertErstellerKennung = false;
      wertNachLadenErstellerKennung = null;
                          isSeitLadenVeraendertErstellerTyp = false;
      wertNachLadenErstellerTyp = null;
                          isSeitLadenVeraendertErstelltAm = false;
      wertNachLadenErstelltAm = null;
                          isSeitLadenVeraendertFaelligkeitAnzahl = false;
      wertNachLadenFaelligkeitAnzahl = null;
                          isSeitLadenVeraendertFaelligkeitEinheit = false;
      wertNachLadenFaelligkeitEinheit = null;
                          isSeitLadenVeraendertFaelligkeitZeitpunkt = false;
      wertNachLadenFaelligkeitZeitpunkt = null;
                          isSeitLadenVeraendertKategorie = false;
      wertNachLadenKategorie = null;
                          isSeitLadenVeraendertLoesung = false;
      wertNachLadenLoesung = null;
                          isSeitLadenVeraendertNummer = false;
      wertNachLadenNummer = null;
                          isSeitLadenVeraendertPrioritaet = false;
      wertNachLadenPrioritaet = null;
                                          isSeitLadenVeraendertStatus = false;
      wertNachLadenStatus = null;
                          isSeitLadenVeraendertTitel = false;
      wertNachLadenTitel = 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 "AUFGABE";
            }

            @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 = "Aufgabe";
   @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.checkNotNull(aufgabentyp, this, AufgabeConstants.MESSAGE_KEY_AUFGABENTYP_EINZAHL, validationResult);
                                                                                                                                   de.ivu.elect.jee.entity.EntityConstraintCheck.checkStringLength(AufgabeConstants.BEARBEITER_KENNUNG_MAX_LENGTH ,  bearbeiterKennung, this, AufgabeConstants.MESSAGE_KEY_BEARBEITER_KENNUNG_EINZAHL, validationResult);
                                                                                                   de.ivu.elect.jee.entity.EntityConstraintCheck.checkStringLength(AufgabeConstants.BESCHREIBUNG_MAX_LENGTH ,  beschreibung, this, AufgabeConstants.MESSAGE_KEY_BESCHREIBUNG_EINZAHL, validationResult);
                                                           de.ivu.elect.jee.entity.EntityConstraintCheck.checkNotNull(dauerAnzahl, this, AufgabeConstants.MESSAGE_KEY_DAUER_ANZAHL_EINZAHL, validationResult);
                                                                          de.ivu.elect.jee.entity.EntityConstraintCheck.checkValueRange(AufgabeConstants.DAUER_ANZAHL_MAX_VALUE, AufgabeConstants.DAUER_ANZAHL_MIN_VALUE, dauerAnzahl, this, AufgabeConstants.MESSAGE_KEY_DAUER_ANZAHL_EINZAHL, validationResult);
                                                           de.ivu.elect.jee.entity.EntityConstraintCheck.checkNotNull(dauerEinheit, this, AufgabeConstants.MESSAGE_KEY_DAUER_EINHEIT_EINZAHL, validationResult);
                                                                                           de.ivu.elect.jee.entity.EntityConstraintCheck.checkNotNull(erstellerKennung, this, AufgabeConstants.MESSAGE_KEY_ERSTELLER_KENNUNG_EINZAHL, validationResult);
                                                                          de.ivu.elect.jee.entity.EntityConstraintCheck.checkStringLength(AufgabeConstants.ERSTELLER_KENNUNG_MAX_LENGTH , 1 ,  erstellerKennung, this, AufgabeConstants.MESSAGE_KEY_ERSTELLER_KENNUNG_EINZAHL, validationResult);
                                                           de.ivu.elect.jee.entity.EntityConstraintCheck.checkNotNull(erstellerTyp, this, AufgabeConstants.MESSAGE_KEY_ERSTELLER_TYP_EINZAHL, validationResult);
                                                                                           de.ivu.elect.jee.entity.EntityConstraintCheck.checkNotNull(erstelltAm, this, AufgabeConstants.MESSAGE_KEY_ERSTELLT_AM_EINZAHL, validationResult);
                                                                                           de.ivu.elect.jee.entity.EntityConstraintCheck.checkNotNull(faelligkeitAnzahl, this, AufgabeConstants.MESSAGE_KEY_FAELLIGKEIT_ANZAHL_EINZAHL, validationResult);
                                                                          de.ivu.elect.jee.entity.EntityConstraintCheck.checkValueRange(AufgabeConstants.FAELLIGKEIT_ANZAHL_MAX_VALUE, AufgabeConstants.FAELLIGKEIT_ANZAHL_MIN_VALUE, faelligkeitAnzahl, this, AufgabeConstants.MESSAGE_KEY_FAELLIGKEIT_ANZAHL_EINZAHL, validationResult);
                                                           de.ivu.elect.jee.entity.EntityConstraintCheck.checkNotNull(faelligkeitEinheit, this, AufgabeConstants.MESSAGE_KEY_FAELLIGKEIT_EINHEIT_EINZAHL, validationResult);
                                                                                                                                                                                            de.ivu.elect.jee.entity.EntityConstraintCheck.checkStringLength(AufgabeConstants.KATEGORIE_MAX_LENGTH ,  kategorie, this, AufgabeConstants.MESSAGE_KEY_KATEGORIE_EINZAHL, validationResult);
                                                                                                   de.ivu.elect.jee.entity.EntityConstraintCheck.checkStringLength(AufgabeConstants.LOESUNG_MAX_LENGTH ,  loesung, this, AufgabeConstants.MESSAGE_KEY_LOESUNG_EINZAHL, validationResult);
                                                           de.ivu.elect.jee.entity.EntityConstraintCheck.checkNotNull(nummer, this, AufgabeConstants.MESSAGE_KEY_NUMMER_EINZAHL, validationResult);
                                                                          de.ivu.elect.jee.entity.EntityConstraintCheck.checkValueRange(AufgabeConstants.NUMMER_MAX_VALUE, AufgabeConstants.NUMMER_MIN_VALUE, nummer, this, AufgabeConstants.MESSAGE_KEY_NUMMER_EINZAHL, validationResult);
                                                           de.ivu.elect.jee.entity.EntityConstraintCheck.checkNotNull(prioritaet, this, AufgabeConstants.MESSAGE_KEY_PRIORITAET_EINZAHL, validationResult);
                                                                                                                                   de.ivu.elect.jee.entity.EntityConstraintCheck.checkStringLength(AufgabeConstants.RECHTSGRUNDLAGE_MAX_LENGTH ,  rechtsgrundlage, this, AufgabeConstants.MESSAGE_KEY_RECHTSGRUNDLAGE_EINZAHL, validationResult);
                                                           de.ivu.elect.jee.entity.EntityConstraintCheck.checkNotNull(status, this, AufgabeConstants.MESSAGE_KEY_STATUS_EINZAHL, validationResult);
                                                                                           de.ivu.elect.jee.entity.EntityConstraintCheck.checkNotNull(titel, this, AufgabeConstants.MESSAGE_KEY_TITEL_EINZAHL, validationResult);
                                                                          de.ivu.elect.jee.entity.EntityConstraintCheck.checkStringLength(AufgabeConstants.TITEL_MAX_LENGTH , 1 ,  titel, this, AufgabeConstants.MESSAGE_KEY_TITEL_EINZAHL, validationResult);
                                                                                                   de.ivu.elect.jee.entity.EntityConstraintCheck.checkStringLength(AufgabeConstants.VERANTWORTLICH_MAX_LENGTH ,  verantwortlich, this, AufgabeConstants.MESSAGE_KEY_VERANTWORTLICH_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;

        }
                              }
